线程池

原创

兰亭集

发布于 2026-04-26 10:10:35

220

文章被收录于专栏：软件工程软件工程

线程 - Thread

一个Thread对象是一个用户态线程，对应着一个操作系统内核态线程。一个线程的所有状态：

NEW: 新建的Thread对象，start()执行之前都处于这个状态。
RUNNABLE: start()之后正在运行中的状态。
BLOCKED: synchronized获取锁时等待锁会进入这个状态。
WAITING: 调用如下方法会进入该状态 1. 条件不满足调用Object.wait()方法 2. Thread.join() 3. LockSupport.park()。
TIMED_WAITING: 调用如下方法会进入该状态 1. Thread.sleep() 2. 调用Object.wait()、Thread.join()方法时传入了等待时间 3. LockSupport.parkNanos(), LockSupport.parkUntil()
TERMINATED: 线程执行完成后进入该状态。

线程池 - ThreadPool

线程池的使用

public void useThreadPool() throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        executor.submit(() -> System.out.println("Executing a Runnable"));
        Future<String> result = executor.submit(() -> "Executing a Callable");
        System.out.println(result.get());

        executor.shutdown();
        boolean normallyTerminated = executor.awaitTermination(1, TimeUnit.MINUTES);
        System.out.println(normallyTerminated);
    }

线程池的机制 - ThreadPoolExecutor

主要参数

corePoolSize：核心线程数量，最小线程数量
maximumPoolSize：最大线程数量
workQueue：任务队列

任务提交及执行流程

submit()方法提交Runnable/Callable任务
若线程数量少于corePoolSize，则添加新工作线程-Worker，提交的任务作为新线程的第一个待执行的任务-FirstTask，启动线程执行
若线程数量等于corePoolSize，则添加任务到workQueue中，线程池中线程执行完一个任务后会从任务队列拉取任务继续执行
若任务队列已满
1. 若线程数量少于maximumPoolSize，则添加新工作线程启动执行
2. 否则在默认策略下抛出异常拒绝执行
若任务队列为空，线程等待keepAliveTime后仍未拉取到新任务
1. 若当前线程数量多于核心线程数量，则退出任务拉取循环，并从线程池中移除当前线程。线程run()方法执行完成后进入终止态，线程对象无对象引用被GC垃圾回收
2. 否则默认状态下保留核心线程数量的线程继续拉取等待新任务（如果要移除空闲的核心线程，需设置allowCoreThreadTimeOut为true）

任务提交：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {  // 线程数量少于corePoolSize
        if (addWorker(command, true))  // 添加新工作线程
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) {  // 添加任务到workQueue中
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))  // 若线程数量少于maximumPoolSize，则添加新工作线程
        reject(command);  // 默认策略下抛出异常拒绝执行
}

任务执行：

private Runnable getTask() {
    ...
    for (;;) {
        ...
        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();  // 从workQueue中拉取任务
            if (r != null)
                return r;
            ...
        } catch (InterruptedException retry) {
            ...
        }
    }
}

final void runWorker(Worker w) {
    Runnable task = w.firstTask;
    ...
    try {
        while (task != null || (task = getTask()) != null) {  // 循环拉取任务
            ...
            try {
                beforeExecute(wt, task);
                try {
                    task.run();  // 执行任务
                    afterExecute(task, null);
                } catch (Throwable ex) {
                    afterExecute(task, ex);
                    throw ex;
                }
            } finally {
                task = null;
                ...
            }
        }
    } finally {
        processWorkerExit(w, completedAbruptly);  // 退出执行，从线程池中移除当前线程
    }
}

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java