线程池初探(一)

Executor、ExecutorService、ThreadPoolExecutor介绍
1.Executor
源码非常简单，只有一个execute（Runnable command）回调接口
public interface Executor {

/**
 * Executes the given command at some time in the future.  The command
 * may execute in a new thread, in a pooled thread, or in the calling
 * thread, at the discretion of the <tt>Executor</tt> implementation.
 *
 * @param command the runnable task
 * @throws RejectedExecutionException if this task cannot be
 * accepted for execution.
 * @throws NullPointerException if command is null
 */
void execute(Runnable command);

}
执行已提交的 Runnable 任务对象。此接口提供一种将任务提交与每个任务将如何运行的机制（包括线程使用的细节、调度等）分离开来的方法。通常使用 Executor 而不是显式地创建线程。例如，可能会使用以下方法，而不是为一组任务中的每个任务调用 new Thread(new(RunnableTask())).start()：
Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
…

不过，Executor 接口并没有严格地要求执行是异步的。在最简单的情况下，执行程序可以在调用方的线程中立即运行已提交的任务：
class DirectExecutor implements Executor {
public void execute(Runnable r) {
r.run();
}
}
更常见的是，任务是在某个不是调用方线程的线程中执行的。以下执行程序将为每个任务生成一个新线程。
class ThreadPerTaskExecutor implements Executor {
public void execute(Runnable r) {
new Thread(r).start();
}
}
许多 Executor 实现都对调度任务的方式和时间强加了某种限制。以下执行程序使任务提交与第二个执行程序保持连续，这说明了一个复合执行程序。
class SerialExecutor implements Executor {
final Queue tasks = new LinkedBlockingQueue();
final Executor executor;
Runnable active;

 SerialExecutor(Executor executor) {
     this.executor = executor;
 }

 public synchronized void execute(final Runnable r) {
     tasks.offer(new Runnable() {
         public void run() {
             try {
                 r.run();
             } finally {
                 scheduleNext();
             }
         }
     });
     if (active == null) {
         scheduleNext();
     }
 }

 protected synchronized void scheduleNext() {
     if ((active = tasks.poll()) != null) {
         executor.execute(active);
     }
 }

}