对象池和线程池

实际开发中，并发和多线程的情景处处存在。今天我们来聊聊对象池和线程池这个两个日常开发用的比较多，但是又很容易混淆的两个概念。

对象池

首先我们来说说对象池。对象池利用了串行封闭的概念：将对象O“借给”一个请求线程T1，T1使用完之后再交还给对象池，并保证“未擅自发布该对象”且“以后不再使用”；对象池收回对象O之后，等T2来借的时候再把他借给T2，完成对象所用权的传递。

下面是一个简化版的对象池

public abstract class AbstractObjectPool<T> {
    protected final int min;
    protected final int max;
    protected final List<T> usings = Lists.newLinkedList();
    protected final List<T> buffer = Lists.newLinkedList();
    private volatile boolean inited = false;

    public AbstractObjectPool(int min, int max) {
        this.min = min;
        this.max = max;
        if (this.min < 0 || this.min > this.max) {
            throw new IllegalArgumentException(String.format("need 0<=min<=max<=Integer.MAX_VALUE,given min%s,max:%s", this.min, this.max));
        }
    }

    public void init() {
        for (int i = 0; i < min; i++) {
            buffer.add(newObject());
        }
        inited = true;
    }

    public void checkInited() {
        if (!inited) {
            throw new IllegalStateException("not inited");
        }
    }

    abstract protected T newObject();

    public synchronized T getObject() {
        checkInited();
        if (usings.size() == max) {
            return null;
        }
        if (buffer.size() == 0) {
            T newObject = newObject();
            usings.add(newObject);
            return newObject;
        }

        T oldObject = buffer.remove(0);
        usings.add(oldObject);
        return oldObject;
    }

    public synchronized void freeObject(T object) {
        checkInited();
        if (!usings.contains(object)) {
            throw new IllegalArgumentException(String.format("object not in using queue:%s", object));
        }
        usings.remove(usings.indexOf(object));
        buffer.add(object);
    }
}

AbstractObjectPool具有以下特性：

• 支持设置最小最大容量
• 对象一旦申请就不再释放，避免了GC

虽然简单，但是大可以用于一些时间敏感、资源充裕的场景。如果时间进一步敏感，可将getObject()、freeObject()改写为并发程度更高的版本，但是记得得保证安全发布安全回收；如果资源不那么充裕，可以适当增加对象的回收策略。

可以看到，一个对象池的基本行为包括：

• 创建对象newObject()
• 借取对象getObject()
• 归还对象freeObject()

典型的对象池有各种连接池（如数据库连接池）、常量池等。那对象池和线程是之间有什么区别呢，线程池的核心原理是不是对象池，下面我们来追溯一下java源码。

线程池

首先摆出结论：线程池糅合了对象池模型，但是核心原理是生产者-消费者模型。

继承结构如下：

用户可以将Runnable(或Callables)实例提交给线程池，线城池会异步执行该任务，返回响应的结果（完成/返回值）。

我最喜欢的是submit(Callable<T> task)方法。我们从该方法入手，逐步深入函数栈，探究线程池的实现原理。

submit()

submit()方法在ExecutorService接口中定义，在抽象类AbstractExecutorService实现，ThreadPoolExecutor直接继承。

public abstract class AbstractExecutorService implements ExecutorService {

    ...

    /**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }
}

AbstractExecutorService #newTaskFor()创建一个RunnableFutrue类型的FutureTask。核心是execute()方法

execute()方法

execute()方法在接口Executor定义，在ThreadPoolExecutor实现。

public class ThreadPoolExecutor extends AbstractExecutorService {
    ...
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();

        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        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);
   }
   ...
}

我们暂且忽略线程池的池化策略。关注一个最简单的场景，看看线程池中任务是怎样执行的。

核心是addWorker()方法。以第8行为例，此时，线程池中线程数未达到最小线程池的大小corePoolSize,通常可以直接在第9行返回。

addWorker()

addWorker()方法是ThreadPoolExecutor的私有方法。

public class ThreadPoolExecutor extends AbstractExecutorService {
    ....
    private boolean addWorker(Runnable firstTask, boolean core) {
        ...
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {                    
                    int rs = runStateOf(ctl.get());
                    if (rs < SHUTDOWN){                       
                        workers.add(w);                       
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }
    ....
}

这里去掉了很多用于管理线程池、维护线程安全的代码。假设线程池未关闭，worker（即w，下同）添加成功，则必然将worker添加至workers中。workers是一个HashSet：

    /**
     * Set containing all worker threads in pool. Accessed only when
     * holding mainLock.
     */
    private final HashSet<Worker> workers = new HashSet<Worker>();

哪里是对象池

如果说与对象池有关，那么只有workers及相当于对象池实例代码中的using，应用了对象池模型；只不过这里的using是一直增长的，直到打到最大线程池的大小maximumPoolSize。

但是很明显，线程池并没有将线程发布出去，workers仅仅是完成using保存线程的作用。那么线程池中的任务是怎样执行的呢？跟线程池有没有关系呢？

哪里又不是对象池？

注意上面addWorker()代码中的第9、17、24行代码

• 9行将我们提交到线程池的firstTask封装入一个worker.
• 17行将worker加入到workers维护起来
• 24行启动了worker中的线程t

核心就在这三行，线程池没有直接在addWorker()中启动我们传进来的firstTask，代之以启动 一个worker，最终任务必然被启动，那么我们继续看Worker是怎样启动我们这个任务的。

Worker

Worker实现了Runnable接口：

private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
    ...
    /**
     * Creates with given first task and thread from ThreadFactory.
     * @param firstTask the first task (null if none)
     */
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

    /** Delegates main run loop to outer runWorker  */
    public void run() {
        runWorker(this);
    }
    ...
}

为什么要将构造Worker时的参数命名为firstTask？因为当且仅当需要建立新的Worker以执行任务task时，才会调用构造函数。因此，任务task对于新Worker而言，是第一个任务firstTask。

Worker的实现非常简单：将自己作为Runable实例，构造时在内部创建并持有一个线程thread。Thread和Runable的使用大家很熟悉了，核心是Worker的run方法，它直接调用了runWorker()方法。

runWorker()

重点来了。简化如下：

public class ThreadPoolExecutor extends AbstractExecutorService {
    ...
    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                 try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }
    ...
}

我们在前面将要执行的任务赋值给firstTask，5-6行首先取出任务task，并将firstTask置为null。因为接下来要执行task，firstTask字段就没有用了。

重点是10-31行的while循环。下面分情况讨论。

case1：第一次进入循环，task不为null

case1对应前面所有假设，程序正常运行进入到这个while循环。

第一次进入循环时，task==firstTask，不为null，直接进入循环体；从而执行16行的firstTask的run()方法；
异常处理我们在这里先不考虑；最后，在finally代码块中，task被置为null，导致下一轮循环会进入case2。

case2：非第一次进入循环体，task为null

case2是更为普遍的情况，是线程池的核心。

case1中，task被置为null，使得第10行的布尔表达式执行第二部分：(task = getTask()) != null) （注：getTask()方法稍后再讲，它返回一个用户已提交的任务）。假设task得到一个已提交的任务，从而16行执行的是新获得的新任务的run()方法。后面通case1，最后task也会被置为null，以后循环都进入case2。

getTask()

case2中每次循环都要获取一个新的已提交的任务，那任务从哪来呢？简化如下

public class ThreadPoolExecutor extends AbstractExecutorService {
    ...
    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
        for (;;) {
            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }
    ...
}

我们先看简单的7-11行。

首先，workQueue是一个线程安全的BlockingQueue，大部分时候使用的实现类是LinkedBlockingQueue。

private final BlockingQueue<Runnable> workQueue;

假设timed为 false，则调用阻塞的take()方法，返回的一定不是null，从而在11行return退出，将获取到的task交给某个worker线程去执行。

workQueue中的元素从哪来呢 ？这就要回到最初的execute()方法了。

execute()

public class ThreadPoolExecutor extends AbstractExecutorService {
    ...
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();

        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        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);
   }
   ...
}

前面以8行的参数为例，此时，线程池中的线程数未达到最小线程池的大小corePoolSize，通常这个时候直接在第10行返回。

如果不满足8行的条件，则会执行到13行的。isRunning(c)判断线程池是否未关闭，这里我们只关注未关闭的情况；接下来就会执行布尔表达式的第二部分workQueue.offer(command)，尝试将任务放入到队列workQueue中。

workQueue.offer()的行为取决于线程池持有的BlockingQueue实例。
Executors.newFixedThreadPool()、Executors.newSingleThreadExecutor()创建的线程池使用LinkedBlockingQueue，而Executors.newCachedThreadPool()创建的线程池则使用SynchronousQueue。

public class Executors {
    ...
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
}

以LinkedBlockingQueue为例，创建时不配置容量，即创建为无界队列，则LinkedBlockingQueue#offer()永远返回true，从而进入execute()13-19行。

当workQueue.offer()返回true时，已经将任务command放入队列workQueue中。当未来某个时刻，某worker完成一个任务后，会通过getTask()从workerQueue在获取一个任务继续执行，直到线程池关闭，直到海枯石烂。

case2小结

可以看到，实际上，线程池的核心原理与对象池模型无关，而是生产者-消费者模型。

• 生产者（调用submit()或者execute()方法）将任务Task放入队列
• 消费者（worker线程）循环从任务队列中取出任务处理（执行task.run()）

钩子方法

回到runWorker()方法，在执行任务的过程中，线程池保留了一些钩子方法，如beforeExecute()、afterExecute()。用户可以在实现自己的线程池时，可以通过覆写钩子方法为线程池添加功能。

总结

对象池和线程池关系不大，但是经常会混淆。线程池的实现很有意思。在追溯源码之前，我一直以为线程池就是把线程存起来，用的时候取出一个执行任务；看了源码才知道它实现如此之妙，简洁优雅效率高。源码才是最好的老师。