J.U.C之Executor框架入门指引

一、Executor接口

This interface provides a way of decoupling task submission from the mechanics of how each task will be run, including details of thread use, scheduling, etc.  An {@code Executor} is normally used instead of explicitly creating threads. 
For example, rather than invoking {@code new Thread(new(RunnableTask())).start()} for each of a set of tasks

executor框架是jdk1.5时引入的一个接口，主要目的是解耦任务的建立和任务的执行，在jdk1.5以前，咱们用线程建立一个任务时，一般是这样 new Thread(new(RunnableTask())).start() ，当引入executor后咱们这样来建立执行任务:

Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());

但因为executor接口只定义了方法void execute(Runnable command) 而没有定义具体的实现，于是对于executor的不一样实现，execute多是建立一个新的线程并当即启动，有多是使用已有的工做线程运行，或者可能将任务放入等待队列等待可用的工做线程。好比:

• 同步执行

  class DirectExecutor implements Executor {
     public void execute(Runnable r) {
       r.run();
     }
   }}

• 异步执行

  class ThreadPerTaskExecutor implements Executor {
     public void execute(Runnable r) {
       new Thread(r).start();
     }
   }}

• 排队执行

  class SerialExecutor implements Executor {
     final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
     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);
       }
     }
   }}

二、ExecutorService接口

除了继承Executor接口的功能外，还提供了关闭执行器的方法，更加通用的submit方法(除了能够接收runnable接口任务还能够接收callable接口任务,使用callable接口任务一般是须要获取执行结果的任务，它经过返回的Future来获取callable任务的执行结果)和批量运行Callable接口任务。

三、ScheduledExecutorService接口

除了继承ExecutorService接口功能外，还提供了延时执行和间隔执行的功能(scheduleWithFixedDelay,scheduleAtFixedRate)

class BeeperControl {
   private final ScheduledExecutorService scheduler =
     Executors.newScheduledThreadPool(1);

   public void beepForAnHour() {
     final Runnable beeper = new Runnable() {
       public void run() { System.out.println("beep"); }
     };
     final ScheduledFuture<?> beeperHandle =
       scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
     scheduler.schedule(new Runnable() {
       public void run() { beeperHandle.cancel(true); }
     }, 60 * 60, SECONDS);
   }
 }}

四、Executors 工厂

对于上述3个接口,jdk1.5 都提供了默认的实现，可是若是用户本身去建立这些个默认实现的实例，就必需要了解这些默认实例的实现细节，而Executors 至关于就是一个简单工厂，经过提供一些简单的参数就能够建立出来咱们想要的执行器。Executors为咱们提供了五类执行器的建立:

• 建立固定线程数的Executor,返回ThreadPoolExecutor类型实例

  public static ExecutorService newFixedThreadPool(int nThreads)
  public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

• 单个线程的Executor,返回FinalizableDelegatedExecutorService或DelegatedScheduledExecutorService类型实例

  public static ExecutorService newSingleThreadExecutor() 
  public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)
  public static ScheduledExecutorService newSingleThreadScheduledExecutor()
  public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)

• 可缓存的Executor

  public static ExecutorService newCachedThreadPool()
  public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)

• 延时、周期性的Executor

  public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
  public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

• fork/join Executor,返回ForkJoinPool类实例

  public static ExecutorService newWorkStealingPool(int parallelism)//并行级别
  public static ExecutorService newWorkStealingPool()