ThreadPoolExecutor　是如何做到线程重用的

关注

转载最新推荐文章于 2026-03-11 00:03:16 发布 1.3k 阅读 AI 写同款· GEO 优化 ›

Android-S无线模块前瞻 WiFi - mainlane非强制 S 采用反射的方法直接加载wifiservice，直接hook在systemserver上，无编译依赖。gms可以动态替换wifi服务。 R 采用直接启动service的方式,wifiservice仍然map在systemserver上。 WiFi - 11ad接口支持 11ad被wifi联盟商业化为WIGIG，提供短距的60GHZ载波，理论速度为当前5G 11ac的6倍。市面上基本没有手机支持，需要独立的芯片支撑此功能。传输距离为3m以内，外界d. 阅读详情

前言：

看关于ThreadPoolExecutor参数时，看到了keepaliveTime这个参数，这个参数的意思是：“当线程数大于CorePoolSize时，如果有没有等到新的Task，到了keepaliveTime时间后，就自动终止掉”。那么如果在这个时间之前，等到了新的Task，就可以重用这个线程。到底是怎么重用线程的呢？

线程重用的核心是，我们知道，Thread.start()只能调用一次，一旦这个调用结束，则该线程就到了stop状态，不能再次调用start。

则要达到复用的目的，则必须从Runnable接口的run()方法上入手，可以这样设计这个 Runnable.run() 方法（就叫外面的run()方法）：

它本质上是个无限循环，跑的过程中不断检查我们是否有新加入的子Runnable对象（就叫内部的runnable:run()吧，它就是用来实现我们自己的任务），有就调一下我们的run()，其实就一个大run()把其它小run()#1,run()#2,...给串联起来了，基本原理就这么简单
不停地处理我们提交的Runnable任务。

它把Thread.start()给屏蔽起来了（一定不要重复调用），然后它自己有一个Runnable.run()，循环在跑，跑的过程中不断检查我们是否有新加入的子Runnable对象，有就调一下我们的run()，其实就一个大run()把其它小run()#1,run()#2,...给串联起来了，基本原理就这么简单。

JDK代码节选
        /**
         * Main run loop
         */
        public void run() {
            try {
                Runnable task = firstTask;
                firstTask = null;
                while (task != null || (task = getTask()) != null) {
                    runTask(task);//这里最终会调用task.run()
                    task = null;
                }
            } finally {
                workerDone(this);
            }
        }
    }

正文：

原理如下：

前提条件：假如coreSize=3，maxSize=10，当前存在线程数是5。
（注意，存在的这5个线程，并不是你执行ExecuteService.execute/submit时的参数，而是为了执行execute/submit的参数所启动的“内部线程”。这个“内部线程”其实是通过ThreadPoolExecutor的ThreadFactory参数生成的线程，而“execute/submit的参数”是执行在这些“内部线程”里面的。）

存在这5个“内部线程”，都访问同一个队列，从队列中去取任务执行（任务就是通过execute/submit提交的Runnable参数），当任务充足时，5个“内部线程”都持续执行。重点是没有任务时怎么办？
没有任务时，这5个“内部线程”都会做下面判断：

如果poolSize > coreSize，那就从队列里取任务，当过了keepaliveTime这么长时间还没有得到任务的话，当前这个“内部线程”就会结束（使用的是BlockingQueue.poll方法）。
如果poolSize <= coreSize，那就以“阻塞”的方式，去从队列里取任务，当得到任务后，就继续执行。这样的话，这个线程就不会结束掉。

如果没有任务可以继续执行了，最后只剩下coreSize那么多的“内部线程”留在线程池里，等待重用。

相关代码如下：

1，从ExecuteService.execute方法开始说，execute方法代码如下：

int c = ctl.get();
// 当“内部线程”数 < coreSize的话，就新建一个“内部线程”
if (workerCountOf(c) < corePoolSize) {
    if (addWorker(command, true))
        return;
    c = ctl.get();
}
// 能执行到这里，说明“内部线程”数 >= coreSize。这样的话，就把任务加入队列。
// 这个队列，就是上面说的所有“内部线程”访问的那个队列。
if (isRunning(c) && workQueue.offer(command)) {
    int recheck = ctl.get();
    if (! isRunning(recheck) && remove(command))
        reject(command);
    else if (workerCountOf(recheck) == 0)
        addWorker(null, false);
}
else if (!addWorker(command, false))
    reject(command);

2，下面再看一下addWorker方法，看看“内部线程”是如何建立的。

// 上面一部分代码省略
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
    // 创建一个Worker实例，把我们提交的任务（也就是firstTask）传入到Worker里。
    // 然后，取得Worker里的thread的属性，并在下面运行这个thread。
    // （其实这个thread属性，就是通过ThreadFactory生成的Thread，也就是所说的“内部线程”）
    // 接下来我们看看Worker类
    w = new Worker(firstTask);
    final Thread t = w.thread;
    if (t != null) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // Recheck while holding lock.
            // Back out on ThreadFactory failure or if
            // shut down before lock acquired.
            int rs = runStateOf(ctl.get());

            if (rs < SHUTDOWN ||
                (rs == SHUTDOWN && firstTask == null)) {
                if (t.isAlive()) // precheck that t is startable
                    throw new IllegalThreadStateException();
                workers.add(w);
                int s = workers.size();
                if (s > largestPoolSize)
                    largestPoolSize = s;
                workerAdded = true;
            }
        } finally {
            mainLock.unlock();
        }
        if (workerAdded) {
            t.start();
            workerStarted = true;
        }
    }
} finally {
    if (! workerStarted)
        addWorkerFailed(w);
}
return workerStarted;

下面我们看看Worker类，其中和本次说明没有什么关系的代码省略。

Worker(Runnable firstTask) {
    setState(-1); // inhibit interrupts until runWorker
    // 这里把提交的任务保存到Worker里，在后面执行的时候，从Worker里取得这个任务执行。
    this.firstTask = firstTask;
    // 下面就是生成“内部线程”的代码
    this.thread = getThreadFactory().newThread(this);
}

public void run() {
    // 这个方法，是“内部线程”实际上执行的方法。原理是这样的：
    // 上面构造函数在生成“内部线程”时，把Worker本身，当做参数传给了“内部线程”
    // “内部线程”在自己的run方法里，执行的是worker的run方法，而worker的run方法执行的是runWorker这个方法。
    // runWorker方法是ThreadPoolExectuor的方法，也就是说，线程池里的“内部线程”在调用run方法时，都是执行的这个方法
    //（所以这个方法要注意同步）
    runWorker(this);
}

3，最后我们看看runWorker方法。

Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
    // task!=null是为了运行“内部线程”启动时，提交的给它的那个线程。
    // (task = getTask()) != null) 是当提交给他的任务执行完后，看看队列里还有没有任务可以执行。
    // 如果有的话，这个“内部线程”就可以重用了。
    // 而“内部线程都会做的判断”，就是getTask()方法里面做的，下面看一下getTask()方法
    while (task != null || (task = getTask()) != null) {
        w.lock();
        if ((runStateAtLeast(ctl.get(), STOP) ||
             (Thread.interrupted() &&
              runStateAtLeast(ctl.get(), STOP))) &&
            !wt.isInterrupted())
            wt.interrupt();
        try {
            beforeExecute(wt, task);
            Throwable thrown = null;
            try {
                task.run();
            } catch (RuntimeException x) {// 省略异常处理
            } finally {
                afterExecute(task, thrown);
            }
        } finally {
            task = null;
            w.completedTasks++;
            w.unlock();
        }
    }
    completedAbruptly = false;
} finally {
    processWorkerExit(w, completedAbruptly);
}

getTask()方法原代码如下

// 这个语句后半部分来判断“内部线程数 > coreSize”
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

if ((wc > maximumPoolSize || (timed && timedOut))
    && (wc > 1 || workQueue.isEmpty())) {
    if (compareAndDecrementWorkerCount(c))
        return null;
    continue;
}
try {
    // 下面的判断，就是上面说的“内部线程都会做的判断”
    Runnable r = timed ?
        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
        workQueue.take();
    if (r != null)
        return r;
    timedOut = true;
} catch (InterruptedException retry) {
    timedOut = false;
}

最后

如果要测试看看线程是不是被重用的话，可以通过自己实现ThreadFactory，加个打印语句，来查看newThread方法被调用的次数。下面的代码是参考Executors的代码，加了一条打印语句

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                poolNumber.getAndIncrement() +
                "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                namePrefix + threadNumber.getAndIncrement(),
                0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        // 通过查看调用的次数，可以来判断new了几个内部线程
        System.out.println(namePrefix + threadNumber.get() + " is created " + "  hashcode:" + t.hashCode());
        return t;
    }
}