Java常用线程池体系（一）

常用线程池体系结构

Executor:线程池顶级接口
ExecutorService:线程池次级接口，对Executor做了一些扩展，增加了一些功能
ScheduledExecutorService:对ExecutorService做了一些找展，增加一些定时任务相关的功能
AbstractExecutorService:抽象类，运用模板方法设计模式实现了一部分方法；
ThreadPoolExecutor：普通线程池类，包含最基本的一些线程池操作相关的方法实现;
ScheduledThreadPoolExecutor：定时任务线程池类，用于实现定时任务相关功能；
ForkJoinPool：新型线程池类，java7中新增的线程池类，基于工作窃取理论实现，运用于大任务拆小任务，任务无限多的场景;
Excutors：线程池工具类，定义了一些快速实现线程池的方法

Executor

线程池顶级接口，定义了一个执行无返回值任务的方法
public interface Executor {

    /**
     * 执行无返回值任务
     * 根据Executor的实现判断，可能是在新线程、线程池，线程调用中执行
     */
    void execute(Runnable command);
}
复制代码

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);
    //批量执行任务，只有当这些任务都完成这个方法才会返回
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    /**
    * 在指定时间内批量执行任务，未执行完成的任务将被取消
    * 这里的timeout是所有任务的总时问，不是单个任务的时问
    */
    <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;
}
复制代码

AbstractExecutorService

AbstractExecutorService实现了ExecutorService接口看几个主要方法的实现：

submit

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    //把Runnable封装成RunnableFuture，ftask相当于要执行任务的代理
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    //执行任务
    execute(ftask);
    //返回任务的代理
    return ftask;
}
复制代码

invokeAll

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
    throws InterruptedException {
    if (tasks == null)
        throw new NullPointerException();
    //要执行多少任务就会返回多少任务对应的Future
    ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
    boolean done = false;
    try {
        //封装任务并执行
        for (Callable<T> t : tasks) {
            RunnableFuture<T> f = newTaskFor(t);
            futures.add(f);
            execute(f);
        }
        //等待所有任务执行完成，忽略CancellationException、ExecutionException异常
        for (int i = 0, size = futures.size(); i < size; i++) {
            Future<T> f = futures.get(i);
            if (!f.isDone()) {
                try {
                    f.get();
                } catch (CancellationException ignore) {
                } catch (ExecutionException ignore) {
                }
            }
        }
        done = true;
        return futures;
    } finally {
        //如果有其他运行时异常，取消所有的任务
        if (!done)
            for (int i = 0, size = futures.size(); i < size; i++)
                futures.get(i).cancel(true);
    }
}
复制代码

InvokeAny

private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                          boolean timed, long nanos)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (tasks == null)
        throw new NullPointerException();
    int ntasks = tasks.size();
    if (ntasks == 0)
        throw new IllegalArgumentException();
    ArrayList<Future<T>> futures = new ArrayList<Future<T>>(ntasks);
    ExecutorCompletionService<T> ecs =
        new ExecutorCompletionService<T>(this);

    try {
        ExecutionException ee = null;
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        Iterator<? extends Callable<T>> it = tasks.iterator();

        // 先提交一个任务
        futures.add(ecs.submit(it.next()));
        --ntasks;
        int active = 1;

        for (;;) {
            Future<T> f = ecs.poll();
            // 提交的第一个任务未执行完成
            if (f == null) {
                //如果还有任务，把剩下的任务依次提交
                if (ntasks > 0) {
                    --ntasks;
                    futures.add(ecs.submit(it.next()));
                    ++active;
                }
                else if (active == 0)
                    break;
                else if (timed) {
                    f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
                    if (f == null)
                        throw new TimeoutException();
                    nanos = deadline - System.nanoTime();
                }
                //等待任务完成
                else
                    f = ecs.take();
            }
            // 提交的第一个任务已执行完成
            if (f != null) {
                --active;
                try {
                    //直接返回第一个任务执行的结果
                    return f.get();
                } catch (ExecutionException eex) {
                    ee = eex;
                } catch (RuntimeException rex) {
                    ee = new ExecutionException(rex);
                }
            }
        }

        if (ee == null)
            ee = new ExecutionException();
        throw ee;

    } finally {
        for (int i = 0, size = futures.size(); i < size; i++)
            futures.get(i).cancel(true);
    }
}
复制代码

Java常用线程池体系（一）

常用线程池体系结构

Executor

ExecutorService

AbstractExecutorService

猜你喜欢