异步多线程----执行器(Executor)

  如果程序中创建了大量的生命期很短的线程，应该使用线程池(thread pool)。一个线程池中包含许多准备运行的空线程。将Runnable对象交给线程池，就会有一个线程调用run方法。当run方法退出时，线程不会死亡，而是在池中准备为下一个请求提供服务。
  另一个使用线程池的理由是减少并发线程的数目。创建大量线程会大大降低性能甚至使虚拟机崩溃。如果有一个会创建许多线程的算法，应该使用一个线程数“固定的”线程池以限制并发线程的总数。

  执行器(Executor)类有许多静态工厂方法用来构建线程池。

newCachedThreadPool      |       必要时创建新线程；空闲线程会被保留60秒
newFixedThreadPool       |       该池包含固定数量的线程；空闲线程会一直被保留。
newSingleThreadExecutor  |       只有一个线程的“池”，该线程顺序执行每一个提交的任务
newScheduledThreadPool   |       用于预定执行而构建的固定线程池，替代java.util.Timer
newSingleThreadScheduledExecutor 用于预定执行而构建的单线程“池”

1.线程池

• newCachedThreadPool方法构建了一个线程池，对于每个任务，如果有空线程可用，立即让它执行任务，如果没有可用的空线程，则创建一个新线程。
• newFixedThreadPool方法构建一个具有固定大小的线程池。如果提交的任务数多于空闲的线程数，那么把得不到服务的任务放置到队列中。
• newSingleThreadExecutor是一个退化了的大小为1的线程池：由一个线程执行提交的任务，一个接着一个。

  上面3个方法返回实现了ExecutorService接口的ThreadPoolExecutor类的对象。

  
  可以使用下面的方法将一个Runnable对象或Callable对象提交给ExecutorService：

//提交指定的任务去执行
Future<?> submit(Runnable task)
Future<T> submit(Runnable task, T result)
Future<T> submit(Callable<T> task)

  该线程池会在方便的时候尽早执行提交的任务。调用submit时，会得到一个Future对象，可用来查询该任务的状态。
  第一个submit方法返回一个Future<?>。可以使用这样一个对象来调用isDone、cancel或isCancelled。但是，get方法在完成的时候只是简单地返回null。
  第二版本的Submit也提交一个Runnable，并且Future的get方法在完成的时候返回指定的result对象。
  第三个版本的Submit提交一个Callable，并且返回的Future对象将在计算结构准备好的时候得到它。

  当用完一个线程池的时候，调用shutdown。该方法启动该池的关闭序列。被关闭的执行器不再接受新的任务。当所有任务都完成以后，线程池中的线程死亡。另一种方法是调用shutdownNow。该池取消尚未开始的所有任务并试图中断正在运行的线程。

  总结在使用线程池时应该做的事：

1.调用Executors类中静态的方法newCachedThreadPool或newFixedThreadPool。
2.调用submit提交Runnable或Callable对象。
3.如果想要取消一个任务，或如果提交Callable对象，那就要保存好返回的Future对象。
4.当不再提交任何任务时，调用shutdown。

  继续以一个计算匹配的文件数目程序为例：

class MatchCounter implements Callable<Integer>
{
    private File directory;
    private String keyword;
    private ExecutorService pool;
    private int count;

    public MatchCounter(File directory, String keyword, ExecutorService pool) {
          this.directory = directory;
          this.keyword = keyword;
          this.pool = pool;
}

    public Integer call() {
          count = 0;
          try {
                File [] files = directory.listFiles();
                List<Future<Integer>> results = new ArrayList<>();

                for ( File file : files) {
                    if ( file.isDirectory()) {
                        MatchCounter counter = new MatchCounter(file, keyword， pool);
                        Future<Integer> result = pool.submit(counter);
                        results.add(result);
                    }
                    else {
                        if( search(file)) count++;
                    }
                }

                for (Future<Integer> result : results) {
                    try{
                            count += result.get();  
                        }
                    catch (ExecutionException e) {
                            e.printStackTrace();
                        }
                 }
          }
          catch (InterruptedException e) {}    

          return count;

      }

}

public boolean search(File file) {...}

public class FutureTest {
      public static void main(String[] args) {
          MatchCounter counter = new MatchCounter(new File(directory), keyword, pool);
          Future<Integer> result = pool.submit(counter);
          ...
          pool.shutdown();
      }
}

2.预定执行

  ScheduledExecutorService接口具有为预定执行(Scheduled Execution)或重复执行任务而设计的方法。它是一种允许使用线程池机制的java.util.Timer的泛化。Executors类的newScheduledThreadPool和newSingleThreadScheduledExecutor方法将返回实现了ScheduledExecutorService接口的对象。
  可以预定Runnable或Callable在初始的延迟之后只运行一次。也可以预定一个Runnable对象周期性地运行。详见API。