java中什么是线程

www.xservx.com | 备案号:蜀ICP备2026035467号-3

⚡ java中什么是线程:核心概念解析

在现代软件开发中,java中什么是线程已成为开发者必须掌握的核心并发编程基础。线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。

在Java语言中,线程是通过java.lang.Thread类及其相关API实现的。Java线程模型基于操作系统线程模型(1:1模型),即每个Java线程都映射到一个操作系统原生线程上。这种设计既保证了跨平台兼容性,又充分利用了现代多核处理器的并行计算能力。

理解java中什么是线程的关键在于把握三个核心特征:**轻量级**、**共享性**和**异步性**。与进程相比,线程的创建、切换和销毁开销更小;同一进程内的线程共享进程的内存空间和系统资源;线程的执行是异步的,多个线程可以并发执行而无需等待彼此完成。

在分布式系统和高并发应用中,线程管理能力直接决定了应用的性能和稳定性。例如,Web服务器需要同时处理成千上万的HTTP请求,每个请求通常由一个独立线程处理;数据库连接池通过线程池技术高效复用线程资源;异步任务处理框架(如CompletableFuture)则依赖线程实现非阻塞操作。

需要特别注意的是,线程并非越多越好。线程数量过多会导致上下文切换开销增大、内存消耗激增,甚至引发系统崩溃。因此,合理设计线程模型、科学管理线程生命周期、正确处理线程同步问题,是Java并发编程的核心挑战。

〔线程与进程的根本区别〕

进程是操作系统分配资源的基本单位,而线程是CPU调度的基本单位。一个进程至少包含一个线程(主线程),也可以创建多个线程。进程之间内存空间相互隔离,通信需要通过进程间通信机制(如管道、消息队列、共享内存等);而同一进程内的线程共享进程的地址空间、文件描述符、信号处理等资源,通信更加高效。

例如,一个Java应用程序启动时会创建JVM进程,该进程中包含多个线程:主线程(执行main方法)、垃圾回收线程(GC Thread)、JIT编译线程等。当用户调用new Thread().start()时,JVM会创建一个新的操作系统线程,并在其中执行run()方法中的代码。

从资源占用角度看,进程创建需要分配独立的虚拟地址空间、页表、文件描述符表等,开销较大;线程创建只需分配少量私有数据(如栈、寄存器状态),共享进程的大部分资源,开销显著降低。例如,在Linux系统中,创建一个进程的开销约为创建一个线程的10-100倍。

从安全角度看,线程共享内存空间带来了高效性,但也引入了线程安全问题。多个线程同时访问共享变量时,若缺乏同步机制,可能导致数据不一致、竞态条件等异常。因此,理解java中什么是线程必须同时掌握线程同步原理和最佳实践。

⚙️ java线程生命周期详解

Java线程有6种状态,定义在Thread.State枚举中,这些状态反映了线程在其生命周期中的不同阶段:

  • NEW:线程被创建但尚未启动,即调用start()方法之前
  • RUNNABLE:线程正在JVM中执行,可能正在操作系统线程上运行或等待操作系统资源
  • BLOCKED:线程被阻塞等待监视器锁以进入同步代码块/方法
  • WAITING:线程无限期等待其他线程执行特定操作(如notify/notifyAll)
  • TIMED_WAITING:线程在指定时间内等待(如sleep、wait(timeout)、join(timeout))
  • TERMINATED:线程已执行完毕

这些状态转换关系如下图所示(文字描述):

NEW → RUNNABLE

调用start()方法后,线程进入可运行状态,等待操作系统调度

RUNNABLE ↔ BLOCKED

线程尝试获取synchronized锁失败时进入BLOCKED状态,获取锁后恢复RUNNABLE

RUNNABLE → WAITING/TIMED_WAITING

调用wait()、join()、sleep()等方法后进入等待状态

WAITING/TIMED_WAITING → RUNNABLE

等待条件满足(如notify、超时、join完成)后恢复可运行

RUNNABLE → TERMINATED

run()方法执行完毕或抛出未捕获异常后线程终止

〈线程状态转换实战示例〉

以下代码演示了线程状态的完整转换过程:

public class ThreadStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行");
            try {
                synchronized (ThreadStateDemo.class) {
                    ThreadStateDemo.class.wait(); // TIMED_WAITING
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("线程即将结束");
        });
        System.out.println("创建后状态: " + thread.getState()); // NEW
        thread.start();
        Thread.sleep(100); // 等待线程启动
        System.out.println("启动后状态: " + thread.getState()); // RUNNABLE/BLOCKED
        // 模拟持有锁并唤醒等待
        synchronized (ThreadStateDemo.class) {
            ThreadStateDemo.class.notify();
        }
        Thread.sleep(100);
        System.out.println("唤醒后状态: " + thread.getState()); // RUNNABLE/TERMINATED
        thread.join();
        System.out.println("结束后状态: " + thread.getState()); // TERMINATED
    }
}

运行结果可能为:

创建后状态: NEW
启动后状态: RUNNABLE
线程开始执行
唤醒后状态: TERMINATED
线程即将结束
结束后状态: TERMINATED

注意:由于线程调度的不确定性,实际运行结果可能略有差异。BLOCKED状态通常在多个线程竞争同一锁时出现,而WAITING/TIMED_WAITING状态则发生在显式调用wait()或sleep()等方法时。

〔线程池中的状态特殊处理〕

在ThreadPoolExecutor中,线程池本身有5种状态:RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED。这些状态与Thread.State不同,用于管理线程池的生命周期。例如:

  • RUNNING:接受新任务并处理队列任务
  • SHUTDOWN:不接受新任务,但处理队列中剩余任务
  • STOP:不接受新任务,不处理队列任务,中断正在执行的任务

理解线程状态转换对调试并发问题至关重要。例如,当应用出现"假死"现象时,通过jstack工具查看线程堆栈,若大量线程处于BLOCKED状态,说明存在锁竞争激烈;若线程处于WAITING状态,可能需要检查notify/notifyAll调用是否缺失。

⚡ java线程创建方式深度对比

在java中什么是线程的实践中,线程创建有三种主要方式,每种方式适用于不同场景:

  1. 继承Thread类:最基础的方式,但受限于Java单继承特性
  2. 实现Runnable接口:推荐方式,避免单继承限制,符合组合优于继承原则
  3. 实现Callable接口+Future:支持返回值和异常处理,适用于需要结果返回的场景
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("当前线程: " + Thread.currentThread().getName());
        // 业务逻辑
    }
    public static void main(String[] args) {
        new MyThread().start(); // 启动新线程
        new MyThread().start(); // 启动另一个线程
        // 注意:不能重复调用start()
        // new MyThread().start(); // IllegalStateException: thread already started
    }
}

优点:实现简单,直接调用start()即可启动线程

缺点:Java单继承限制,无法继承其他类;线程任务与线程对象耦合度高

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("当前线程: " + Thread.currentThread().getName());
        // 业务逻辑
    }
    public static void main(String[] args) {
        new Thread(new MyRunnable()).start();
        new Thread(new MyRunnable()).start();
    }
}

优点:避免单继承限制;任务与线程分离,提高代码灵活性

缺点:无法直接返回结果;异常处理受限(只能捕获不能抛出)

import java.util.concurrent.*;
public class MyCallable implements Callable {
    @Override
    public Integer call() throws Exception {
        System.out.println("当前线程: " + Thread.currentThread().getName());
        // 业务逻辑
        return 42;
    }
    public static void main(String[] args) throws Exception {
        FutureTask task = new FutureTask<>(new MyCallable());
        new Thread(task).start();
        // 阻塞等待结果
        Integer result = task.get();
        System.out.println("计算结果: " + result);
    }
}

优点:支持返回值;支持抛出异常;可与Future/FutureTask配合实现异步编程

缺点:使用相对复杂;需要处理InterruptedException等受检异常

〔线程创建最佳实践〕

现代Java开发中,推荐优先使用线程池(ExecutorService)而非直接创建线程。原因如下:

  • 避免频繁创建销毁线程的开销(线程池复用线程)
  • 统一管理线程资源,防止线程过多导致系统崩溃
  • 提供丰富的配置选项(核心线程数、最大线程数、队列策略等)
  • 支持定时任务、周期任务等高级功能

示例:使用Executors创建固定大小线程池处理批量任务

ExecutorService executor = Executors.newFixedThreadPool(5);
List> tasks = IntStream.range(0, 10)
    .mapToObj(i -> (Callable) (() -> "Task " + i + " completed"))
    .collect(Collectors.toList());
List> futures = executor.invokeAll(tasks);
futures.stream()
    .map(f -> {
        try { return f.get(); }
        catch (Exception e) { throw new RuntimeException(e); }
    })
    .forEach(System.out::println);
executor.shutdown();

注意:Executors工厂方法虽方便,但生产环境建议直接使用ThreadPoolExecutor构造函数,明确指定参数避免资源耗尽风险。

⚙️ java线程同步机制深度解析

当多个线程并发访问共享数据时,必须通过同步机制保证数据一致性。Java提供了多种同步工具,核心是理解java中什么是线程的可见性、原子性和有序性问题。

  • 可见性:一个线程对共享变量的修改,其他线程能立即看到
  • 原子性:操作不可被中断,要么全部执行要么全部不执行
  • 有序性:程序执行顺序与代码顺序一致(受指令重排序影响)
public class Counter {
    private int count = 0;
    // 同步方法
    public synchronized void increment() {
        count++; // 等价于 count = count + 1(非原子操作)
    }
    // 同步代码块
    public void safeIncrement() {
        synchronized(this) {
            count++;
        }
    }
    public synchronized int getCount() {
        return count;
    }
}

原理:synchronized基于对象监视器(monitor)实现,每个对象都有一个监视器。线程进入同步块时需获取monitor,退出时释放monitor。monitor由进入计数器、所有者线程、等待队列等组成。

优化:JDK1.6引入偏向锁、轻量级锁等优化策略,减少无竞争情况下的同步开销。

public class VisibilityDemo {
    private static volatile boolean flag = false;
    private static int data = 0;
    public static void main(String[] args) {
        // 写线程
        new Thread(() -> {
            data = 42; // 写操作
            flag = true; // 写volatile变量
        }).start();
        // 读线程
        new Thread(() -> {
            while (!flag) {
                // 忙等待
            }
            System.out.println("data = " + data); // 保证看到42
        }).start();
    }
}

volatile保证可见性和有序性(禁止指令重排序),但不保证原子性。适用于状态标记、双检锁单例等场景。

注意:volatile不能替代synchronized,例如count++操作仍需同步保护。

import java.util.concurrent.atomic.*;
public class AtomicCounter {
    private final AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet(); // 原子自增
    }
    public int getCount() {
        return count.get();
    }
}

原理:基于CAS(Compare-And-Swap)操作实现,通过CPU的lock前缀指令保证原子性。常见方法包括compareAndSet、getAndIncrement、getAndSet等。

优势:无锁机制,避免线程阻塞,适合高并发计数场景。

局限:ABA问题(可通过AtomicStampedReference解决)、循环时间长开销大、仅支持单变量原子操作。

import java.util.concurrent.locks.*;
public class LockDemo {
    private final ReentrantLock lock = new ReentrantLock();
    private int value = 0;
    public void increment() {
        lock.lock();
        try {
            value++; // 临界区
        } finally {
            lock.unlock();
        }
    }
    public int getValue() {
        lock.lock();
        try {
            return value;
        } finally {
            lock.unlock();
        }
    }
}

ReentrantLock比synchronized更灵活,支持:

  • 可中断锁获取(lockInterruptibly)
  • 超时锁获取(tryLock(timeout))
  • 公平锁/非公平锁选择
  • 条件变量(Condition)实现多路等待/通知

示例:使用Condition实现生产者-消费者模型

class BoundedBuffer {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final Object[] items = new Object[100];
    private int count, putIndex, takeIndex;
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await();
            items[putIndex] = x;
            if (++putIndex == items.length) putIndex = 0;
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await();
            Object x = items[takeIndex];
            if (++takeIndex == items.length) takeIndex = 0;
            --count;
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }
}

〔线程同步最佳实践〕

选择同步机制时应遵循以下原则:

  1. 简单同步用synchronized(JVM优化充分,代码简洁)
  2. 高并发计数用Atomic类(无锁,性能好)
  3. 复杂同步用Lock(需要高级功能时)
  4. 读多写少场景用ReadWriteLock(提升并发性能)

常见陷阱:

  • 锁对象不一致(应使用final修饰的共享对象)
  • 锁范围过大(缩小同步块提高并发度)
  • 死锁(按固定顺序获取多个锁)
  • 忘记释放锁(使用try-finally保证unlock)

⚡ java线程池原理与最佳实践

线程池是java中什么是线程应用的核心组件,通过复用线程减少创建销毁开销,提高系统响应速度和资源利用率。ThreadPoolExecutor是Java线程池的核心实现类,其核心参数包括:

  • corePoolSize:核心线程数(常驻线程数)
  • maximumPoolSize:最大线程数
  • keepAliveTime:非核心线程空闲存活时间
  • workQueue:任务队列(LinkedBlockingQueue、ArrayBlockingQueue等)
  • threadFactory:线程工厂(自定义线程名、优先级等)
  • handler:拒绝策略(AbortPolicy、CallerRunsPolicy等)
参数 作用 常见取值 影响
corePoolSize 核心线程数 CPU核心数+1 决定常驻线程数量
maximumPoolSize 最大线程数 核心数*2或更多 决定资源上限
workQueue 任务队列 LinkedBlockingQueue 缓冲任务,影响延迟
keepAliveTime 非核心线程存活时间 60秒 平衡资源与性能

〔线程池工作流程〕

线程池处理任务的完整流程如下:

  1. 提交任务时,若线程数 < corePoolSize,创建新线程处理(即使有空闲线程)
  2. 线程数 ≥ corePoolSize,任务进入队列等待
  3. 队列满且线程数 < maximumPoolSize,创建新线程处理
  4. 线程数达到maximumPoolSize,执行拒绝策略
  5. 线程空闲超过keepAliveTime,非核心线程被回收

示例:创建适合IO密集型任务的线程池

int cpuCount = Runtime.getRuntime().availableProcessors();
int ioThreads = cpuCount * 2; // IO密集型建议2倍核心数
ExecutorService pool = new ThreadPoolExecutor(
    ioThreads,
    ioThreads * 2,
    60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000),
    new ThreadFactoryBuilder().setNameFormat("io-pool-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

Executors提供便捷的工厂方法,但存在风险:

  • newFixedThreadPool:无界队列(LinkedBlockingQueue),可能导致OOM
  • newCachedThreadPool:最大线程数为Integer.MAX_VALUE,可能创建过多线程
  • newSingleThreadExecutor:单线程,无法利用多核

生产环境建议避免直接使用Executors,改用ThreadPoolExecutor显式配置。

自定义线程池最佳实践:

public class CustomThreadPool {
    private static final int CORE_SIZE = Runtime.getRuntime().availableProcessors();
    private static final int MAX_SIZE = CORE_SIZE * 2;
    private static final int QUEUE_CAPACITY = 1000;
    public static ExecutorService newBusinessThreadPool() {
        return new ThreadPoolExecutor(
            CORE_SIZE,
            MAX_SIZE,
            60L, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadFactoryBuilder().setNameFormat("business-%d").build(),
            new ThreadPoolExecutor.AbortPolicy()
        ) {
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                super.afterExecute(r, t);
                if (t != null) {
                    // 记录异常日志
                    log.error("任务执行异常", t);
                }
            }
        };
    }
}

关键点:

  • 使用ArrayBlockingQueue替代LinkedBlockingQueue(有界队列防OOM)
  • 自定义ThreadFactory(便于问题排查)
  • 重写afterExecute处理异常(避免异常被静默忽略)
  • 合理设置拒绝策略(CallerRunsPolicy适用于低优先级任务)

〔线程池监控与调优〕

生产环境必须监控线程池运行状态,关键指标包括:

  • activeCount:当前活跃线程数
  • queue.size:队列中任务数
  • completedTaskCount:已完成任务数
  • largestPoolSize:历史最大线程数

监控示例:

ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
// 定期监控
ScheduledExecutorService monitor = Executors.newSingleThreadScheduledExecutor();
monitor.scheduleAtFixedRate(() -> {
    System.out.printf("活跃线程: %d, 队列任务: %d, 已完成: %d%n",
        pool.getActiveCount(),
        pool.getQueue().size(),
        pool.getCompletedTaskCount());
}, 1, 1, TimeUnit.SECONDS);

调优建议:

  • IO密集型任务:线程数 = CPU核心数 * (1 + IO耗时/计算耗时)
  • 计算密集型任务:线程数 ≈ CPU核心数
  • 混合型任务:拆分到不同线程池

❓ 网友们还关心的java线程常见问题

基于对开发者社区的调研,以下是java中什么是线程相关问题的深度解答:

1. 如何判断一个类是否线程安全?

线程安全的判断标准:

  • 无状态类(只含局部变量)天然线程安全
  • 不可变对象(final字段+无setter)线程安全
  • 使用线程安全类(如ConcurrentHashMap)
  • 通过同步机制保护共享状态

反例:SimpleDateFormat非线程安全

// 危险写法
private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 安全写法1:每次创建新实例
public String formatDate(Date date) {
    return new SimpleDateFormat("yyyy-MM-dd").format(date);
}
// 安全写法2:使用ThreadLocal
private static final ThreadLocal sdf =
    ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

2. 如何排查死锁问题?

死锁典型场景:两个线程互相等待对方释放锁

class DeadlockDemo {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    public void method1() {
        synchronized(lock1) {
            Thread.sleep(100); // 模拟处理
            synchronized(lock2) {
                // ...
            }
        }
    }
    public void method2() {
        synchronized(lock2) {
            Thread.sleep(100);
            synchronized(lock1) {
                // ...
            }
        }
    }
}

排查步骤:

  1. 使用jps找到Java进程PID
  2. 执行jstack PID > deadlock.txt
  3. 在输出中搜索"Found one Java-level deadlock"

避免死锁技巧:

  • 按固定顺序获取锁(如lock1 → lock2)
  • 使用tryLock设置超时
  • 减少锁的嵌套层次

3. 并发工具类如何选择?

工具类 适用场景 关键方法
CountDownLatch 等待多个任务完成 countDown(), await()
CyclicBarrier 多线程同步点 await(), reset()
Semaphore 控制并发访问数 acquire(), release()
Exchanger 两线程交换数据 exchange()

示例:使用CountDownLatch等待所有子任务完成

int taskCount = 5;
CountDownLatch latch = new CountDownLatch(taskCount);
for (int i = 0; i < taskCount; i++) {
    new Thread(() -> {
        try {
            // 执行任务
            System.out.println("任务完成");
        } finally {
            latch.countDown();
        }
    }).start();
}
latch.await(); // 等待所有任务完成
System.out.println("所有任务已完成");

4. CompletableFuture异步编程怎么用?

CompletableFuture是Java 8引入的异步编程工具,支持链式调用和组合操作:

CompletableFuture future = CompletableFuture
    .supplyAsync(() -> {
        // 异步任务1
        return "Hello";
    })
    .thenApplyAsync(result -> {
        // 异步任务2
        return result + " World";
    })
    .handle((result, ex) -> {
        // 处理结果或异常
        return ex != null ? "Error" : result;
    });
String value = future.get(); // 阻塞等待结果

关键优势:

  • 非阻塞式回调
  • 支持组合多个异步操作
  • 内置异常处理机制
  • 可指定自定义线程池

注意:默认使用ForkJoinPool.commonPool(),生产环境应指定专用线程池避免影响其他任务。

💻 java线程实战案例解析

以下通过三个典型场景展示java中什么是线程的实践应用:

场景1:订单30分钟未支付自动关闭

方案对比:

  • 数据库定时任务:延迟高,资源消耗大
  • Redis过期回调:适合分布式系统
  • 延迟队列DelayQueue:内存友好,单机高效

DelayQueue实现示例:

public class OrderTimeoutService {
    private final DelayQueue queue = new DelayQueue<>();
    // 提交订单任务
    public void submitOrder(Order order) {
        long delay = 30 * 60 * 1000; // 30分钟
        OrderTask task = new OrderTask(order.getId(), delay);
        queue.put(task);
    }
    // 后台线程处理超时订单
    public void startTimeoutChecker() {
        new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    OrderTask task = queue.take(); // 阻塞获取超时任务
                    closeOrder(task.getOrderId());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();
    }
    private void closeOrder(Long orderId) {
        // 关闭订单逻辑
        System.out.println("订单" + orderId + "已超时关闭");
    }
    static class OrderTask implements Delayed {
        private final Long orderId;
        private final long expireTime;
        public OrderTask(Long orderId, long delayMillis) {
            this.orderId = orderId;
            this.expireTime = System.currentTimeMillis() + delayMillis;
        }
        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(expireTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }
        @Override
        public int compareTo(Delayed o) {
            return Long.compare(this.expireTime, ((OrderTask)o).expireTime);
        }
        public Long getOrderId() { return orderId; }
    }
}

优势:内存占用低,支持大量订单任务;天然按超时时间排序。

注意:JVM重启后任务丢失,生产环境需结合持久化方案。

场景2:异步日志收集系统

使用BlockingQueue解耦日志生产和消费:

public class AsyncLogger {
    private final BlockingQueue queue = new ArrayBlockingQueue<>(10000);
    private final ExecutorService consumer = Executors.newSingleThreadExecutor();
    public AsyncLogger() {
        // 启动日志消费者
        consumer.submit(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    LogEvent event = queue.take();
                    writeLog(event); // 异步写入文件/数据库
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
    }
    public void log(String level, String message) {
        // 非阻塞提交(队列满时丢弃日志)
        queue.offer(new LogEvent(level, message, System.currentTimeMillis()));
    }
    private void writeLog(LogEvent event) {
        // 实际写入逻辑
        System.out.println("[" + event.getTimestamp() + "] " +
                          event.getLevel() + ": " + event.getMessage());
    }
    static class LogEvent {
        private final String level;
        private final String message;
        private final long timestamp;
        public LogEvent(String level, String message, long timestamp) {
            this.level = level;
            this.message = message;
            this.timestamp = timestamp;
        }
        // getters...
    }
}

关键设计:

  • 使用ArrayBlockingQueue有界队列防OOM
  • offer()替代put()避免生产者阻塞
  • 单消费者确保日志顺序性

优化:可扩展为多消费者+批处理,提升吞吐量。

场景3:百万级数据批量导入

使用分批+多线程策略:

public class BatchDataImporter {
    private final int batchSize = 1000;
    private final int threadCount = 8;
    public void importData(List allData) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        CountDownLatch latch = new CountDownLatch((allData.size() + batchSize - 1) / batchSize);
        for (int i = 0; i < allData.size(); i += batchSize) {
            List batch = allData.subList(i, Math.min(i + batchSize, allData.size()));
            executor.submit(() -> {
                try {
                    processBatch(batch); // 处理单批数据
                } finally {
                    latch.countDown();
                }
            });
        }
        latch.await(); // 等待所有批次完成
        executor.shutdown();
    }
    private void processBatch(List batch) {
        // 数据校验、转换、入库
        batch.stream().forEach(data -> {
            // 单条处理逻辑
        });
    }
}

优化点:

  • 使用线程池替代直接创建线程
  • CountDownLatch确保主线程等待所有批次完成
  • 合理设置batchSize(通常1000-5000)

进阶:结合数据库批量插入(batch update)进一步提升性能。