java并发编程

  Exexctor 常用类关系图

Executor 接口

Excutor 接口定义如下

ExecutorService 

ExecutorService 是一个比 Executor 使用更广泛的子类接口，其提供了生命周期管理的方法，以及可跟踪一个或多个异步任务执行状况返回Future的方法

AbstractExecutorService

ExecutorService执行方法的默认实现

ScheduledExecutorService

一个可定时调度任务的接口

 

ScheduledThreadPoolExecutor

ScheduledExecutorService的实现，一个可定时调度任务的线程池

ScheduledExecutorService 的一个构造函数如下

ThreadPoolExecutor

线程池，可以通过调用Executors 的静态工厂方法来创建线程池并返回一个 ExecutorService 对象

ThreadPoolExecutor 的一个构造函数如下

 参数说明

corePoolSize：核心线程数，如果运行的线程少于corePoolSize，则创建新线程来执行新任务，即使线程池中的其他线程是空闲的

maximumPoolSize:最大线程数，可允许创建的线程数，

 corePoolSize 和 maximumPoolSize 设置的边界自动调整池大小：
   -  corePoolSize  < 运行的线程数 < maximumPoolSize ：仅当队列满时才创建新线程
   -  corePoolSize = 运行的线程数 = maximumPoolSize ：创建固定大小的线程池
keepAliveTime  ：如果线程数多于 corePoolSize ，则这些多余的线程的空闲时间超过keepAliveTime时将被终止
unit  ：keepAliveTime参数的时间单位
workQueue ：保存任务的阻塞队列，与线程池的大小有关：
  -  运行的线程数 <   corePoolSize 时，在有新任务时直接创建新线程来执行任务而无需再进队列
  -  运行的线程数 >= corePoolSize 时，在有新任务添加时则选加入队列，不直接创建线程
  -  当队列满时，在有新任务时就创建新线程
threadFactory ：使用 ThreadFactory 创建新线程，默认使用 defaultThreadFactory 创建线程
handle ：定义处理被拒绝任务的策略，默认使用 ThreadPoolExecutor.AbortPolicy，任务被拒绝时将抛出 RejectExecutorException

Executor的生命周期

ExecutorService 提供了管理 Eecuto r生命周期的方法，ExecutorService的生命周期包括了：运行  关闭和终止三种状态。

ExecutorService 在初始化创建时处于运行状态。

 - shutdown 方法等待提交的任务执行完成并不再接受新任务，在完成全部提交的任务后关闭

 - shutdownNow 方法将强制终止所有运行中的任务并不再允许提交新任务

 

ExecutorCompletionService

实现了CompletionService，它将 BlockingQueue 和 Executor 封装起来。然后使用 ExecutorCompletionService.submit() 方法提交任务。

将执行完成的任务放到阻塞队列中，通过 take 或 poll 方法来获得执行结果。

 

 submit 方法如下：

 public Future<V> submit(Callable<V> task) {
        if (task == null) throw new NullPointerException();
 
        // RunnableFuture封装了任务，使得任务既能run 也能get()
        RunnableFuture<V> f = newTaskFor(task);
        // 使用一个继承Runnable类的QueueingFutue 再次封装了我们的任务
        executor.execute(new QueueingFuture(f));
        return f;
   }

QueueingFuture：

 private class QueueingFuture extends FutureTask<Void> {
        QueueingFuture(RunnableFuture<V> task) {
            super(task, null);
            this.task = task;
        }
        // 实现了FutureTask 的done 方法，在任务处理完毕或者抛异常后将封装成Future的任务加入到队列。这样我们就能在队列中取到处处理完的任务，并通过Future.get()方法去取得处理完后的结果。不用自己去判断任务是否处理完毕了
        protected void done() { completionQueue.add(task); }
        private final Future<V> task;
} 

实例：

// 启动10条线程，谁先执行完成就返回谁
ExecutorService executor = Executors.newFixedThreadPool(10);        //创建含10.条线程的线程池
CompletionService service = new ExecutorCompletionService(executor);
for (int i = 1; i <= 10; i++)
{
    final int result = i;
    service.submit(new Callable<String>()
    {
        public String call() throws Exception
        {
            Thread.sleep(new Random().nextInt(5000));   //让当前线程随机休眠一段时间
            return "task done " + result;
        }
    });
}
System.out.println(service.take().get());   //获取执行结果