Java多线程系统概述

1.Executor

异步执行框架，其实就是一个接口且只有一个方法：

public interface Executor {
    void execute(Runnable command);
}

它的出现是为了将任务的提交与任务如何被执行解耦开。
举个例子：

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

就是说我提交了两个任务，这两个任务如何被执行我并不知道，如何被执行是由具体的anExecutor决定的。
这样的思想就是：用户只需要提交任务就行了，任务的执行、线程的调度不是我关心的。这种思想也就成就了线程池的思想。

2.ExecutorService

public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;//阻塞等待所有任务执行完成
    //上面几个是对整个线程池的操作。
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    //可以提交一个任务，并且得到Future--即得到这个任务的控制权。
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
    //对一批任务的提交操作, 堵塞等待所有任务执行完成(或超时),并获得这些任务的执行结果
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
    //对一批任务的提交操作, 堵塞等待任意一任务执行完成(或超时),并获得这个任务的执行结果,此时其他任务会被取消
}

继承了Executor，因为Executor只有一个方法，且方法的参数还只能是Runnable。
ExecutorService提供了更多的功能：

1. 对Callable的支持
2. 对异步任务的进度的控制与追踪(shutdown与isTerminated)
3. 对异步任务的结果的获取支持

3. Future

Future简单地说就是提供了对异步任务的管理：取消、等待执行结果、判断状态等。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

4. 多线程异常的控制

问题：如果我们提交的异步任务中有些任务发生异常了怎么办？

1. Thread原生的异常机制

首先我们先来看一下Thread原生的异常机制：

    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                throw new RuntimeException("dsadsa");
            }
        });
//        thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
//            @Override
//            public void uncaughtException(Thread t, Throwable e) {
//                System.out.println("uncaughtException:" + e.getMessage());
//            }
//        });
        thread.start();
        thread.join();
        System.out.println("here");
    }

Thread原生的只支持Runnable的任务，Runnable是不允许抛出Checked Exception的，但如果抛Unchecked Exception异常，则默认是直接输出异常堆栈信息，并不会将异常抛给主线程。

上面的代码中：输出的是RuntimeException的堆栈信息且会输出here。

我们可以覆盖uncaughtException方法来自定义得到异常后该如何做。这个方法的参数是Throwable，所以如果出现Error，这个方法是解决不了的。

而如果使用ExecutorService框架，就不一样了。

2. ExecutorService框架的异常机制

先说一下结论：无论是Callable任务还是Runnable任务，抛出任何异常都会被ExecutorService框架捕获。并且封装成ExecutionException交给Future。

我们知道ExecutorService中任务的提交都会返回Future(即使是Runnable)，我们看看Future中的get方法，它会返回两个异常InterruptedException, ExecutionException，其中ExecutionException就是封装异步任务的异常。

问题：如果不调用get方法，异常怎么办？
答：异常就会被忽略掉。

5. 总结一下如何对任务的提交

Thread原生的就不说了，只能提交Runnable任务。
ExecutorService对任务的提交：

• 对一批Runnable任务的提交：

ExecutorService.execute(Runnable command);
Future = ExecutorService.submit(Runnable task);

即for循环里单个对Runnable任务提交。

• 对一批Callable任务的提交：

ExecutorService.submit(Callable<T> task);
List<Future> = ExecutorService.List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)

即可以for循环里单个对Callable任务提交，也可以提交一个Callable的list。

• trick
  Runnable的任务都可以先变成Callable任务，只是返回值设为void就可以了。

6. 一些题外话

然后ThreadPoolExecutor就是ExecutorService真正的实现者。内部原理我们在另一篇文章已经说过了。
然后Executors就是一个工具类，可以返回一些简单的ExecutorService的实现类。

ExecutorService executorService = Executors.newSingleThreadExecutor();