java基础-Executor

 

java.util.concurrent.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 {@code Executor} implementation.
 * execute方法屏蔽了command如何被执行的具体机制，
 * 比如command可以在当前线程中串行执行、可以在线程池中执行、可以总是创建一个新的线程来执行等等。
 * //串行执行
 * class DirectExecutor implements Executor {
 *   public void execute(Runnable r) {
 *     r.run();
 *   }
 * }
 * //新建线程执行
 * class ThreadPerTaskExecutor implements Executor {
 *   public void execute(Runnable r) {
 *     new Thread(r).start();
 *   }
 * }
 */
public interface Executor {
    void execute(Runnable command);
}

 

java.util.concurrent.ExecutorService

/**
 * An {@link Executor} that provides methods to manage termination and
 * methods that can produce a {@link Future} for tracking progress of
 * one or more asynchronous tasks.
 * ExecutorService是Executor的一种增强，提供了一些管理方法，
 * 包括终止Executor（可能是多个线程）、获得代表任务执行进度的Future。
 */
public interface ExecutorService extends Executor {

    void execute(Runnable command);

    Future<?> submit(Runnable task);

    <T> Future<T> submit(Callable<T> task);

    void shutdown();
    //返回未得到执行的任务
    List<Runnable> shutdownNow();

    //......
}

 

java.util.concurrent.ThreadPoolExecutor

//jdk中ExecutorService的一个标准实现就是ThreadPoolExecutor
public class ThreadPoolExecutor extends AbstractExecutorService {
    /**
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * 可以认为corePoolSize是最小线程数，除非设置了allowCoreThreadTimeOut；
     * workQueue即任务队列。
     */
  public ThreadPoolExecutor(int corePoolSize,
                            int maximumPoolSize,
                            long keepAliveTime,
                            TimeUnit unit,
                            BlockingQueue<Runnable> workQueue,
                            ThreadFactory threadFactory) {
      this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
           threadFactory, defaultHandler);
  }
  
  public void execute(Runnable command) {
      //任务不能为null
    if (command == null)
        throw new NullPointerException();
    //ctl即control state，前3位表示runState，后29位表示workerCount
    int c = ctl.get();
    //如果线程数未达到corePoolSize则增加线程（不允许大于corePoolSize），并将command作为该线程的第一个任务执行（不入队）
    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);
        //此时可能线程数减少至0，仍然需要增加线程（否则就没有线程执行command了）
        //允许大于corePoolSize，corePoolSize是允许为0的，maximumPoolSize必须大于0
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))//尝试以maximumPoolSize为上限添加worker，比如cachedThreadPool，其workQueue是一个SynchronousQueue（同步队列，该队列并没有真正的空间来存放插入的元素），当core数量的线程都有任务执行时，就会执行这里。
        reject(command);
    }
    
    
  public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    //将task包装为一个FutureTask实例，重点来看这个FutureTask
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    //仍然是执行execute
    execute(ftask);
    return ftask;
    }
}

 

ThreadPoolExecutor的核心部件就是workQueue和workers，workQueue用于存放提交的任务，workers用于存放工作线程，workers模型是固定的。我们使用Executors可以创建cached、fixed等线程池，cached线程池的思路就是每个提交的任务都会有独立的线程来执行，而不会进入队列等待被执行（cached线程池所持有的workQueue是一个没有实际容量的队列），当线程数大于max阈值时，就会reject（默认策略是抛运行时异常，再对异常做出相应的处理）。fixed线程池由于线程数量固定，故需要将暂时无法处理的任务存入workQueue，如果workQueue也满了，则reject。

java.util.concurrent.FutureTask

//通过FutureTask的run、set、cancel三个方法可以一窥FutureTask的原理
public class FutureTask<V> implements RunnableFuture<V> {
    //......
    
  public void run() {
      if (state != NEW ||
          !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                       null, Thread.currentThread()))
        return;
      try {
        Callable<V> c = callable;
        //由于状态限制，一个FutureTask只能运行一次，这与Runnable不同，Thread是只能start一次
        if (c != null && state == NEW) {
          V result;
          boolean ran;
          try {
              //执行自定义逻辑
            result = c.call();
            ran = true;
          } catch (Throwable ex) {
            result = null;
            ran = false;
            setException(ex);
          }
          if (ran)
              //设置返回值，设置后就可以通过get得到返回值了
            set(result);
        }
      } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
          handlePossibleCancellationInterrupt(s);
      }
  }
  
  protected void set(V v) {
      //只有在NEW状态才会设置返回值
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
      outcome = v;
      UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
      //唤醒阻塞在Future上的线程
      finishCompletion();
    }
  }
  
  public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
      return false;
    try {    // in case call to interrupt throws exception
      if (mayInterruptIfRunning) {
        try {
          Thread t = runner;
          if (t != null)
              //如果mayInterruptIfRunning为true，则中断当前任务。
              //注意，中断并不意味任务一定会就此结束。
            t.interrupt();
        } finally { // final state
            //设置状态为INTERRUPTED（被中断）
          UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
        }
      }
    } finally {
        //唤醒阻塞在Future上的线程
        //执行到这里并不意味着任务中断结束，任务仍然可能在执行，只不过不会设置返回值了，
        //即便任务仍在执行，此后get也不会阻塞了，get返回null。
      finishCompletion();
    }
    return true;
    }
    //......
}

 

java.util.concurrent.Executors

//Executors提供了一系列ThreadPoolExecutor实现的工厂方法
public class Executors {
    //......
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
    }
    //......
}