ThreadPoolExecutor源码笔记(一)父类和实现的接口

public interface Executor {
	// 执行任务
    void execute(Runnable command);
}

public interface ExecutorService extends Executor {
	// 不让再submit新的任务了，但是之前提交的会继续执行完。
    void shutdown();
    // 不让再submit新的任务了，并且尝试去停止线程池里面所有的任务，不管是正在执行的还是没有执行的，并且返回没有执行的任务列表
    List<Runnable> shutdownNow();
    // 线程池是否shut down了
    boolean isShutdown();
    // 线程池是否终止了
    boolean isTerminated();
    // 等待线程池终止，如果在timeout时间之内终止了就返回ture，否则返回false。一般配合shutdown函数使用
    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);
    // 执行tasks里面所有的callable，返回所有的情况结果
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
    // 在timeout时间内执行tasks里面所有的callable，返回所有的情况结果(包括没执行的也会返回)
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
    // 执行tasks里面所有的callable，当有一个处理完了就结束
    <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
    // 在timeout时间内执行tasks里面所有的callable，当有一个处理完了就结束
    <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
/**
 * ThreadPoolExecutor的父类
 */
public abstract class AbstractExecutorService implements ExecutorService {

    /**
	 * 根据传入的runnable及默认返回值value，创建并返回一个FutureTask
	 * runnable，FutureTask的一个成员是callable(任务、默认执行结果)、一个是state(当前task执行状态)
     */
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

    /**
     * 跟上面差不多，只不过传入的是已经封装好的callable，默认返回值是null，其他跟上面方法相同 
	 */
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

    /**
	 * 把传入的runnable封装成FutureTask并调用execute(futureTask)
     */
    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);//根据传入数据封装成FutureTask
        execute(ftask);//执行FutureTask
        return ftask;//返回执行的task
    }
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);//根据传入数据封装成FutureTask
        execute(ftask);//执行FutureTask
        return ftask;//返回执行的task
    }
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);//根据传入数据封装成FutureTask
        execute(ftask);//执行FutureTask
        return ftask;//返回执行的task
    }
	// 执行tasks里面所有的callable，当有一个处理完了就结束
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
        try {
            return doInvokeAny(tasks, false, 0);
        } catch (TimeoutException cannotHappen) {
            assert false;
            return null;
        }
    }
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) ... {
        return doInvokeAny(tasks, true, unit.toNanos(timeout));
    }
	// 执行tasks里面所有的callable，返回所有的情况结果
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
        if (tasks == null) throw new NullPointerException();
        ArrayList<Future<T>> futures = new ArrayList<>(tasks.size());
        try {//把传入的callable(包含runnable、默认result)封装成FutureTask，添加到arraylist中，执行每一个FutureTask，返回arraylist
            for (Callable<T> t : tasks) {
                RunnableFuture<T> f = newTaskFor(t);
                futures.add(f);
                execute(f);// 所有task开始执行任务
            }
            for (int i = 0, size = futures.size(); i < size; i++) {
                Future<T> f = futures.get(i);
                //需要注意的是，这个isDone()只是判断state != NEW，只有状态不是初始化的NEW状态了，那么都返回true
                 if (!f.isDone()) {//遍历所有task，任务未完成的继续执行并等待结果
                    try { 
					// get方法会一直等待，直到拿到执行结果
						f.get();
					} catch (CancellationException ignore) {
					} catch (ExecutionException ignore) {}
                }
            }
            return futures;//返回所有执行过的任务
        } catch (Throwable t) {
            cancelAll(futures);//抛出异常时，取消所有任务
            throw t;
        }
    }
	// 执行tasks里面所有的callable，返回所有的情况结果
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)...{
        if (tasks == null) throw new NullPointerException();
        final long nanos = unit.toNanos(timeout);
        final long deadline = System.nanoTime() + nanos;
        ArrayList<Future<T>> futures = new ArrayList<>(tasks.size());
        int j = 0;
        timedOut: try {// 把传入的callable(包含runnable、默认result)封装成FutureTask，添加到arraylist中，执行每一个FutureTask，返回arraylist
            for (Callable<T> t : tasks) {
                futures.add(newTaskFor(t));
			}
            final int size = futures.size();
            // Interleave time checks and calls to execute in case
            // executor doesn't have any/much parallelism.
            for (int i = 0; i < size; i++) {
                if (((i == 0) ? nanos : deadline - System.nanoTime()) <= 0L) {
                    break timedOut;//超时跳出
				}
                execute((Runnable)futures.get(i));//未超时，所有task开始执行任务
            }

            for (; j < size; j++) {
                Future<T> f = futures.get(j);
                //需要注意的是，这个isDone()只是判断state != NEW，只有状态不是初始化的NEW状态了，那么都返回true
                 if (!f.isDone()) {// 遍历所有任务，未完成的，继续执行，直到超时退出
                    try { f.get(deadline - System.nanoTime(), NANOSECONDS); }
                    catch (CancellationException ignore) {}
                    catch (ExecutionException ignore) {}
                    catch (TimeoutException timedOut) {
                        break timedOut;
                    }
                }
            }
            return futures;
        } catch (Throwable t) {
            cancelAll(futures);//异常，取消所有任务
            throw t;
        }
        // 超时未完成的所有任务，全部取消
        cancelAll(futures, j);
        return futures;
    }

	/**
     * the main mechanics of invokeAny.
     */
    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks, boolean timed, long nanos) ...{
        if (tasks == null) throw new NullPointerException();
        int ntasks = tasks.size();
        if (ntasks == 0) throw new IllegalArgumentException();
        ArrayList<Future<T>> futures = new ArrayList<>(ntasks);//创建一个大小与tasks相同的arrayList
		//this就是本类Executor
        ExecutorCompletionService<T> ecs = new ExecutorCompletionService<T>(this);
        try {
            // Record exceptions so that if we fail to obtain any result, we can throw the last exception we got.
            ExecutionException ee = null;
            final long deadline = timed ? System.nanoTime() + nanos : 0L;
            Iterator<? extends Callable<T>> it = tasks.iterator();
            //ecs.submit(it.next())就是调用本类Executor.execute()执行遍历的每个任务，返回执行的任务，添加到futures中
            futures.add(ecs.submit(it.next()));
            --ntasks;//记录剩余未执行的任务数
            int active = 1;
            for (;;) {//遍历执行tasks中所有任务，并把执行的任务添加到futures中
			/* 查看ExecutorCompletionService.QueueingFuture、FutureTask源码，可知
			 * QueueingFuture执行完之后done()中会把该任务添加到ExecutorCompletionService.completionQueue队列中
			 * 所以下面这个ecs.poll()是取出执行完的任务
			 */
                Future<T> f = ecs.poll();
                if (f == null) {//还没有任何任务执行完毕，继续遍历tasks并执行
                    if (ntasks > 0) {
                        --ntasks;
                        futures.add(ecs.submit(it.next()));
                        ++active;//执行一个任务，active+1
                    } else if (active == 0)//为0说明所有任务都执行完毕了，跳出循环
                        break;
                    else if (timed) {
                        f = ecs.poll(nanos, NANOSECONDS);//超过一定时间，还没有一个任务执行完，抛出超时异常
                        if (f == null) throw new TimeoutException();
                        nanos = deadline - System.nanoTime();
                    } else
                        f = ecs.take();
                }
                if (f != null) {//有任务执行完了
                    --active;//执行完毕一个任务active-1
                    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 {
            cancelAll(futures);//有一个任务执行完毕之后会return，然后到了这里，取消所有请求
        }
    }
	
    private static <T> void cancelAll(ArrayList<Future<T>> futures) {
        cancelAll(futures, 0);
    }

    /**
	 * 索引 >=j 的任务全部取消
	 */
    private static <T> void cancelAll(ArrayList<Future<T>> futures, int j) {
        for (int size = futures.size(); j < size; j++)
            futures.get(j).cancel(true);
    }
}

G

M

T

Detect languageAfrikaansAlbanianArabicArmenianAzerbaijaniBasqueBelarusianBengaliBosnianBulgarianCatalanCebuanoChichewaChinese (Simplified)Chinese (Traditional)CroatianCzechDanishDutchEnglishEsperantoEstonianFilipinoFinnishFrenchGalicianGeorgianGermanGreekGujaratiHaitian CreoleHausaHebrewHindiHmongHungarianIcelandicIgboIndonesianIrishItalianJapaneseJavaneseKannadaKazakhKhmerKoreanLaoLatinLatvianLithuanianMacedonianMalagasyMalayMalayalamMalteseMaoriMarathiMongolianMyanmar (Burmese)NepaliNorwegianPersianPolishPortuguesePunjabiRomanianRussianSerbianSesothoSinhalaSlovakSlovenianSomaliSpanishSundaneseSwahiliSwedishTajikTamilTeluguThaiTurkishUkrainianUrduUzbekVietnameseWelshYiddishYorubaZulu

AfrikaansAlbanianArabicArmenianAzerbaijaniBasqueBelarusianBengaliBosnianBulgarianCatalanCebuanoChichewaChinese (Simplified)Chinese (Traditional)CroatianCzechDanishDutchEnglishEsperantoEstonianFilipinoFinnishFrenchGalicianGeorgianGermanGreekGujaratiHaitian CreoleHausaHebrewHindiHmongHungarianIcelandicIgboIndonesianIrishItalianJapaneseJavaneseKannadaKazakhKhmerKoreanLaoLatinLatvianLithuanianMacedonianMalagasyMalayMalayalamMalteseMaoriMarathiMongolianMyanmar (Burmese)NepaliNorwegianPersianPolishPortuguesePunjabiRomanianRussianSerbianSesothoSinhalaSlovakSlovenianSomaliSpanishSundaneseSwahiliSwedishTajikTamilTeluguThaiTurkishUkrainianUrduUzbekVietnameseWelshYiddishYorubaZulu

Text-to-speech function is limited to 200 characters

Options : History : Feedback : Donate

Close