Java线程池的几种实现方式

线程池的实现方式是通过Executors类创建几种不同类型的线程池，常用的有newFixedThreadPool（int nThreads），构造方法如下：

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

第一个参数代表corePoolSize，第二个代表maximumPoolSize，第三个代表keepAliveTime存活时间，最后一个是用队列保存超出的任务。
具体代码：

ExecutorService ec = Executors.newFixedThreadPool(2);
ec.submit(new Runnable(){
    public void run() {
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }
});

ec.submit方法调用的是抽象类AbstractExecutorService中的submit方法

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    FutureTask<Object> ftask = new FutureTask<Object>(task, null);
    execute(ftask);
    return ftask;
}

该方法创建一个未来任务FutureTask

public FutureTask(Runnable runnable, V result) {
    sync = new Sync(Executors.callable(runnable, result));
}

Executors.callable方法如下：

public static <T> Callable<T> callable(Runnable task, T result) {
    if (task == null)
        throw new NullPointerException();
    return new RunnableAdapter<T>(task, result);
}

static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable  task, T result) {
    this.task = task; 
    this.result = result;
}
public T call() { 
    task.run(); 
    return result; 
}

未来任务FutureTask创建完毕之后， 执行execute(ftask)方法，调用ThreadPoolExecutor类。

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    for (;;) {
        if (runState != RUNNING) {
        reject(command);
        return;
        }
        if (poolSize < corePoolSize && addIfUnderCorePoolSize(command))
        return;
        if (workQueue.offer(command))
        return;
        Runnable r = addIfUnderMaximumPoolSize(command);
        if (r == command)
        return;
        if (r == null) {
        reject(command);
        return;
        }
        // else retry
    }
}

会先执行if (poolSize < corePoolSize && addIfUnderCorePoolSize(command))，因为目前线程数量还小于设定的核心数量。addIfUnderCorePoolSize(command)代码如下：

private boolean addIfUnderCorePoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < corePoolSize)
        t = addThread(firstTask);
    } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}
private Thread addThread(Runnable firstTask) {
    Worker w = new Worker(firstTask);
    Thread t = threadFactory.newThread(w);
    if (t != null) {
        w.thread = t;
        workers.add(w);
        int nt = ++poolSize;
        if (nt > largestPoolSize)
        largestPoolSize = nt;
    }
    return t;
}

Worker是ThreadPoolExecutor一个内部类，将要执行的任务包装进Worker中，之后执行t.start()，调用Worker中的run方法。

public void run() {
    try {
    Runnable task = firstTask;
    firstTask = null;
    while (task != null || (task = getTask()) != null) {
        runTask(task);
        task = null; // unnecessary but can help GC
    }
    } catch(InterruptedException ie) {
    // fall through
    } finally {
    workerDone(this);
    }
}

执行一次后，进入while循环，getTask方法如下：

Runnable getTask() throws InterruptedException {
    for (;;) {
        switch(runState) {
        case RUNNING: {
        if (poolSize <= corePoolSize)   // untimed wait if core
            return workQueue.take();

        long timeout = keepAliveTime;
        if (timeout <= 0) // die immediately for 0 timeout
            return null;
        Runnable r =  workQueue.poll(timeout, TimeUnit.NANOSECONDS);
        if (r != null)
            return r;
        if (poolSize > corePoolSize) // timed out
            return null;
        // else, after timeout, pool shrank so shouldn't die, so retry
        break;
        }

        case SHUTDOWN: {
        // Help drain queue 
        Runnable r = workQueue.poll();
        if (r != null)
            return r;

        // Check if can terminate
        if (workQueue.isEmpty()) {
            interruptIdleWorkers();
            return null;
        }

        // There could still be delayed tasks in queue.
        // Wait for one, re-checking state upon interruption
        try {
            return workQueue.take();
        } catch(InterruptedException ignore) {}
        break;
        }

        case STOP:
        return null;
        default:
        assert false; 
        }
    }
}

newFixedThreadPool创建的数量一直是poolSize 小于等于corePoolSize，所以从队列中获取下一条任务，如果没有则等待，workQueue.take();

下面开始讲newCachedThreadPool，该类的创建方式：Executors.newCachedThreadPool()；

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

内部生成一个corePoolSize为0，poolSize 为整形最大数，存活时间为60s的线程池。他的执行任务方式和newFixedThreadPool一样，也是ec.submit。我们关心的是如何做到60s后自动回收的。主要在Worker中的getTask方法里。

while (task != null || (task = getTask()) != null) {
   runTask(task);
    task = null; // unnecessary but can help GC
}
 switch(runState) {
   case RUNNING: {
    if (poolSize <= corePoolSize)   // untimed wait if core
        return workQueue.take();

    long timeout = keepAliveTime;
    if (timeout <= 0) // die immediately for 0 timeout
        return null;
    Runnable r =  workQueue.poll(timeout, TimeUnit.NANOSECONDS);
    if (r != null)
        return r;
    if (poolSize > corePoolSize) // timed out
        return null;
    // else, after timeout, pool shrank so shouldn't die, so retry
    break;
    }

getTask方法中，由于corePoolSize为0，所以直接走下面，获取超时时间keepAliveTime，然后从队列中Runnable r = workQueue.poll(timeout, TimeUnit.NANOSECONDS);根据超时时间获取任务，超过时限则break。之后外面run方法的循环结束，线程关闭。

public void run() {
    try {
    Runnable task = firstTask;
    firstTask = null;
    while (task != null || (task = getTask()) != null) {
        runTask(task);
        task = null; // unnecessary but can help GC
    }
    } catch(InterruptedException ie) {
    // fall through
    } finally {
        workerDone(this);
    }
}

最后再讲一下定时及延时执行的线程newScheduledThreadPool，创建方式：ScheduledExecutorService ec = Executors.newScheduledThreadPool(int corePoolSize);

  public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,new DelayedWorkQueue());
}

执行任务为：

ec1.scheduleAtFixedRate(new Runnable(){
    public void run() {
        System.out.println("i:"+j+" ********");
    }
},10, 2, TimeUnit.SECONDS);

10代表首次执行延时10秒执行，之后每2秒执行一次。接着看他们的实现原理。方法如下：

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, 
                      long initialDelay,  
                      long period, 
                      TimeUnit unit) {
    if (command == null || unit == null)
        throw new NullPointerException();
    if (period <= 0)
        throw new IllegalArgumentException();
    if (initialDelay < 0) initialDelay = 0;
    long triggerTime = now() + unit.toNanos(initialDelay);
    ScheduledFutureTask<?> t = 
        new ScheduledFutureTask<Object>(command, 
                        null,
                        triggerTime,
                        unit.toNanos(period));
    delayedExecute(t);
    return t;
}

ScheduledFutureTask(Runnable r, V result, long ns,  long period) {
    super(r, result);
    this.time = ns;
    this.period = period;
    this.sequenceNumber = sequencer.getAndIncrement();
}

创建任务大体相同，将延时时间设置为time，将每次执行时间设置为period。之后执行delayedExecute(t);方法。

private void delayedExecute(Runnable command) {
    if (isShutdown()) {
        reject(command);
        return;
    }
    // Prestart a thread if necessary. We cannot prestart it
    // running the task because the task (probably) shouldn't be
    // run yet, so thread will just idle until delay elapses.
    if (getPoolSize() < getCorePoolSize())
        prestartCoreThread();

    super.getQueue().add(command);
}

该方法比较目前的线程数量是否小于设置的核心数量，如果小于，则创建线程，否则加入队列。当我们第一次进入时，肯定是小于的。执行prestartCoreThread（）方法。

public boolean prestartCoreThread() {
    return addIfUnderCorePoolSize(null);
}

该方法执行addIfUnderCorePoolSize（）方法，和newFixedThreadPool相同，只不过传入的Runnable任务为null，表明只创建个线程被Worker包装，之后将该Runnable任务放入队列中。接着执行Worker的run方法，从getTask中获取任务。

  Runnable getTask() throws InterruptedException {
        for (;;) {
            switch(runState) {
            case RUNNING: {
                if (poolSize <= corePoolSize)   // untimed wait if core
                    return workQueue.take();

                long timeout = keepAliveTime;
                if (timeout <= 0) // die immediately for 0 timeout
                    return null;
                Runnable r =  workQueue.poll(timeout, TimeUnit.NANOSECONDS);
                if (r != null)
                    return r;
                if (poolSize > corePoolSize) // timed out
                    return null;
                // else, after timeout, pool shrank so shouldn't die, so retry
                break;
            }

这是workQueue.take()的实现类是DelayQueue队列，

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
        E first = q.peek();
        if (first == null) {
            available.await();
        } else {
            long delay =  first.getDelay(TimeUnit.NANOSECONDS);
            if (delay > 0) {
            long tl = available.awaitNanos(delay);
            } else {
            E x = q.poll();
            assert x != null;
            if (q.size() != 0)
                available.signalAll(); // wake up other takers
            return x;

            }
        }
        }
    } finally {
        lock.unlock();
    }
}

先获取time，第一次设置的10秒，等待10s后返回开始执行任务。执行的run方法是ScheduledThreadPoolExecutor中的run方法。

public void run() {
    if (isPeriodic())
    runPeriodic();
    else 
    ScheduledFutureTask.super.run();
}

runPeriodic（）方法内容：

private void runPeriodic() {
    boolean ok = ScheduledFutureTask.super.runAndReset();
    boolean down = isShutdown();
    // Reschedule if not cancelled and not shutdown or policy allows
    if (ok && (!down ||
           (getContinueExistingPeriodicTasksAfterShutdownPolicy() && 
        !isTerminating()))) {
    long p = period;
    if (p > 0)
        time += p;
    else
        time = now() - p;
    ScheduledThreadPoolExecutor.super.getQueue().add(this);
    }
    // This might have been the final executed delayed
    // task.  Wake up threads to check.
    else if (down) 
    interruptIdleWorkers();
}

方法在runAndReset中执行完毕，之后获取每次间隔多少时间执行的参数period，将time设为time+p。这样当再次循环从队列中找任务的时候， long delay = first.getDelay(TimeUnit.NANOSECONDS);

public long getDelay(TimeUnit unit) {
    long d = unit.convert(time - now(), TimeUnit.NANOSECONDS);
    return d;
}

就是等待2S后执行了。
以上就是newFixedThreadPool、newScheduledThreadPool、newCachedThreadPool的实现原理。