线程池

线程池是在JDK 1.5之后出现的概念，它为我们提供了一个Executor接口用于创建线程池。

在JDK 1.5之前，如果我们在并发编程的过程中需要实现多个线程的话，采用的是多线程计数的方式，而之所以出现了线程池的概念，原因就是因为多线程计数在部分条件下无法满足程序的要求。

多线程计数能够最大限度发挥多核处理器的计算能力，但是对于多线程来说，并不是线程数量越多，程序运行的效率越高，那么如果随意的去创建线程的话，反而会对系统性能带来不利的影响，原因就是因为线程的数量与系统性能不是一个正比的关系，而是一个抛物线的关系。

出现线程池的原因

1、创建和销毁线程也需要时间，导致系统性能低下。 T1线程的创建时间 T2线程的执行时间 T3线程的销毁时间 T1 + T3 >>> T2 2、线程也需要占用内存空间，大量的线程占用的内存资源会比较多，有可能导致OOM异常。3、大量的线程回收也会给GC带来很大的压力。4、大量的线程会抢占CPU的资源，CPU不停的进行各个线程的上下文切换。

线程池的概念

线程池就是会事先创建若干个可执行的线程放入一个池（容器）当中，有任务需要执行时，从池子中获取一个线程去执行任务，不用自行创建，执行完后不需要销毁线程，而是将当前的线程归还到线程池当中，从而减少创建和销毁线程所带来的性能的开销。

线程池的优势

1、降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗。2、提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行。3、方便线程并发数的管控。

因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。

4、线程池可以统一的调优和监控。5、提供更强大的功能，延时定时线程池。

线程池的使用

class RunnableTask implements Runnable { @Override public void run() { System.out.println("任务执行时间：" + new Date().getSeconds()); System.out.println(Thread.currentThread().getName() + " :: hello world"); try { TimeUnit.MILLISECONDS.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " :: hello world, goodBye"); } } public class TestDemo { public static void main(String[] args) { //创建线程池对象 ExecutorService pool = Executors.newFixedThreadPool(2); //包含2个线程对象 //创建任务 RunnableTask task = new RunnableTask(); /** * Thread t = new Thread(task); * t.start(); //启动当前的线程，调用RunnableTask中的run方法 */ //提交当前的任务到线程池 pool.submit(task); //线程池分配一个线程，执行当前的task pool.submit(task); pool.submit(task); //关闭线程池 pool.shutdown(); } }

一个完整的线程池应该具备的要素

1、线程数量管控功能。2、任务队列：用于缓存提交的任务。3、任务拒绝策略：线程数量到达上线并且任务队列已满。（任务队列是一个有界的队列，线程池中线程的数量也是有界的）4、线程工厂：用于加工线程。5、QueueSize：limit数量。

线程池的工作流程

线程池的处理流程

1、判断核心线程池是否已满，没满则创建一个新的工作线程来执行任务。已满则进行第二步。2、判断任务队列是否已满，没满则将新提交的任务添加在工作队列，已满则进行第三步。3、判断整个线程池是否已满，没满则创建一个新的工作线程来执行任务，已满则执行饱和策略。

JDK中所提供的线程池

单一数量的线程池。固定数量的线程池。周期性的线程池。可缓存的线程池。

线程池的创建是用Executors工厂类调用静态方法实现的，而线程任务的提交除了submit()方法之外，还有一个execute()方法。

execute()和submit()方法的区别：

execute(Runnable command)，执行一个任务，没有返回值。submit(Runnable command)，提交一个线程任务，有返回值。

submit(Callable<T> task)能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用。（IntentService中有体现）

submit(Runnable task, T result)，能通过传入的载体 result 间接获得线程的返回值。submit(Runnable task)，则是没有返回值的，就算获取它的返回值也是null。Future.get()方法会使取结果的线程进入阻塞状态，知道线程执行完成之后，唤醒取结果的线程，然后返回结果。

线程池终止的方法

shutdown() ：之前提交的任务继续执行，但是不接受新的任务，无法保证之前的任务执行完毕后关闭。shutdownNow() ：试图停止所有正在执行的任务，暂停处理正在等待的任务，会返回一个等待的任务列表，这个方法不会等待正在执行的任务终止。isShutdown() ：如果已经被shutdown，返回true。isTerminate() ：如果所有任务都已经被终止，返回true。awaitTermination(long timeout, TimeUnit unit) ：如果当前任务执行完毕，或者任务等待时间超过超时时间后关闭。

单一数量的线程池

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

适用：一个任务一个任务执行的场景。 class CallableTask implements Callable<Integer> { @Override public Integer call() { System.out.println("任务执行时间：" + new Date().getSeconds()); System.out.println(Thread.currentThread().getName() + " :: hello world"); try { TimeUnit.MILLISECONDS.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " :: hello world, goodBye"); return (int) (Math.random() * 100); } } public class TestDemo { public static void main(String[] args) { //单一数量的线程池 ExecutorService pool = Executors.newSingleThreadExecutor(); //创建Callable任务 CallableTask task = new CallableTask(); //Future对象接收当前task的返回结果 for (int i = 0; i < 5; i++) { Future<Integer> result = pool.submit(task); try { System.out.println(result.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } //关闭线程池 pool.shutdown(); } }

固定数量的线程池

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

适用：执行长期的任务，性能好很多。 public class TestDemo { public static void main(String[] args) { //固定数量的线程池 ExecutorService pool = Executors.newFixedThreadPool(2); } }

周期性的线程池

创建一个可定期或者延时执行任务的定长线程池，支持定时及周期性任务执行。

适用：周期性执行任务的场景。 public class TestDemo { public static void main(String[] args) { //周期性的线程池 ScheduledExecutorService pool = Executors.newScheduledThreadPool(5); //包含有5个核心线程的线程池 //创建任务 RunnableTask task = new RunnableTask(); //提交任务 System.out.println("任务提交时间：" + new Date().getSeconds()); pool.schedule(task,3,TimeUnit.SECONDS); //关闭线程池 pool.shutdown(); } }

可缓存的线程池

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

适用：执行很多短期异步的小程序或者负载较轻的服务器。 class CallableTask implements Callable<Integer> { private CountDownLatch latch; public CallableTask(CountDownLatch latch) { this.latch = latch; } @Override public Integer call() { System.out.println("任务执行时间：" + new Date().getSeconds()); System.out.println(Thread.currentThread().getName() + " :: hello world"); try { TimeUnit.MILLISECONDS.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " :: hello world, goodBye"); latch.countDown(); return (int) (Math.random() * 100); } } public class TestDemo { public static void main(String[] args) { //可缓存的线程池 /** * 当有任务提交时，优先重复使用线程池中的空闲线程， * 但是如果线程池中没有空闲线程时，则会直接创建新的线程去执行提交的任务 */ ExecutorService pool = Executors.newCachedThreadPool(); CountDownLatch latch = new CountDownLatch(30); for (int i = 0; i < 30; i++) { pool.submit(new CallableTask(latch)); } try { latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("main thread end"); //关闭线程池 pool.shutdown(); } }

线程池原理分析

在JDK当中，为线程池提供了一个Executor框架，它相当于整个线程池继承关系的父接口，它的主要作用是把任务的提交和执行进行解耦，我们只需要定义好任务，然后提交给线程池，而不需要关心线程是如何执行任务，任务被哪个线程执行，以及什么时候执行。

在Executor框架下面，JDK还为我们提供了一个工厂类，即Executors，它是Java线程池的工厂类，我们通过它可以初始化一个线程池。

接下来，我们通过newFixedThreadPool这个线程池来看看线程池的底层究竟是如何来执行的。

//创建线程池对象 ExecutorService pool = Executors.newFixedThreadPool(2); //包含2个线程对象

当我们需要使用一个线程池时，我们可以直接通过Executors工厂类调用相应的静态方法，创建线程池对象。

/** * Creates a thread pool that reuses a fixed number of threads * operating off a shared unbounded queue. At any point, at most * {@code nThreads} threads will be active processing tasks. * If additional tasks are submitted when all threads are active, * they will wait in the queue until a thread is available. * If any thread terminates due to a failure during execution * prior to shutdown, a new one will take its place if needed to * execute subsequent tasks. The threads in the pool will exist * until it is explicitly {@link ExecutorService#shutdown shutdown}. * * @param nThreads the number of threads in the pool * @return the newly created thread pool * @throws IllegalArgumentException if {@code nThreads <= 0} */ public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }

而工厂类中的静态方法实际上是给我们返回了一个ThreadPoolExecutor构造器。事实上底层创建线程池对象时都会需要这个构造器，它存在于ThreadPoolExecutor这个类当中。

/** * Creates a new {@code ThreadPoolExecutor} with the given initial * parameters and default thread factory and rejected execution handler. * It may be more convenient to use one of the {@link Executors} factory * methods instead of this general purpose constructor. * * @param corePoolSize the number of threads to keep in the pool, even * if they are idle, unless {@code allowCoreThreadTimeOut} is set * @param maximumPoolSize the maximum number of threads to allow in the * pool * @param keepAliveTime when the number of threads is greater than * the core, this is the maximum time that excess idle threads * will wait for new tasks before terminating. * @param unit the time unit for the {@code keepAliveTime} argument * @param workQueue the queue to use for holding tasks before they are * executed. This queue will hold only the {@code Runnable} * tasks submitted by the {@code execute} method. * @throws IllegalArgumentException if one of the following holds:<br> * {@code corePoolSize < 0}<br> * {@code keepAliveTime < 0}<br> * {@code maximumPoolSize <= 0}<br> * {@code maximumPoolSize < corePoolSize} * @throws NullPointerException if {@code workQueue} is null */ public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); } int corePoolSize，核心线程数，当提交一个任务，线程池创建一个新线程去执行任务，直到当前线程数等于corePoolSize，继续提交的任务会被缓存到阻塞队列中，等待被执行。int maximumPoolSize，最大线程数，如果当前阻塞队列满了，继续提交任务，需要创建新的线程执行任务，前提是当前线程数小于maximumPoolSize。long keepAliveTime，线程空闲时的存活时间。TimeUnit unit，keepAliveTime的时间单位。BlockingQueue<Runnable> workQueue，用于缓存任务的阻塞队列。ThreadFactory threadFactory，创建线程的工厂。RejectedExecutionHandler handler。拒绝策略。

JDK中线程池的拒绝策略

如果我们在使用线程池执行任务时，当阻塞队列满了，没有空闲的工作线程时，此时如果继续提交任务，那么线程池需要采取一种策略处理当前的任务，JDK为线程池提供了4种策略：

1、AbortPolicy ：直接抛出异常。2、CallerRunsPolicy ：用调用者所在的线程去执行任务。3、DiscardOldestPolicy ：丢弃阻塞队列中最靠前的任务。4、DiscardPolicy ：直接丢弃当前的任务。5、除了JDK提供的这四种拒绝策略之外，我们还可以自定义拒绝策略，需要实现RejectedExecutionHandler接口。

拒绝策略的验证，以AbortPolicy为例：

class Task implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName()); try { TimeUnit.MILLISECONDS.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } public class TestDemo { public static void main(String[] args) { //拒绝策略 - AbortPolicy 直接抛出异常 ExecutorService pool = new ThreadPoolExecutor(2, 3, 0L, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(5), new ThreadPoolExecutor.AbortPolicy()); for (int i = 0; i < 10;i++){ pool.submit(new Task()); } pool.shutdown(); } }

四种线程池的传递参数

newFixedThreadPool ：固定数量的线程池。 /** * Creates a thread pool that reuses a fixed number of threads * operating off a shared unbounded queue. At any point, at most * {@code nThreads} threads will be active processing tasks. * If additional tasks are submitted when all threads are active, * they will wait in the queue until a thread is available. * If any thread terminates due to a failure during execution * prior to shutdown, a new one will take its place if needed to * execute subsequent tasks. The threads in the pool will exist * until it is explicitly {@link ExecutorService#shutdown shutdown}. * * @param nThreads the number of threads in the pool * @return the newly created thread pool * @throws IllegalArgumentException if {@code nThreads <= 0} */ public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }

初始化一个指定数量的线程池，其中corePoolSize == maximumPoolSize == nThreads，使用LinkedBlockingDeque作为阻塞队列，如果当前没有可执行任务，也不会释放线程。

newCachedThreadPool ：可缓存的线程池。 /** * Creates a thread pool that creates new threads as needed, but * will reuse previously constructed threads when they are * available. These pools will typically improve the performance * of programs that execute many short-lived asynchronous tasks. * Calls to {@code execute} will reuse previously constructed * threads if available. If no existing thread is available, a new * thread will be created and added to the pool. Threads that have * not been used for sixty seconds are terminated and removed from * the cache. Thus, a pool that remains idle for long enough will * not consume any resources. Note that pools with similar * properties but different details (for example, timeout parameters) * may be created using {@link ThreadPoolExecutor} constructors. * * @return the newly created thread pool */ public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }

初始化一个可缓存线程的线程池，默认缓存60s，线程池的线程数最大可达到Integer.MAX_VALUE，使用SynchronousQueue作为阻塞队列，一定要注意控制并发的任务数，否则会导致严重系统性能问题。

newSingleThreadExecutor ：单一数量的线程池。 /** * Creates an Executor that uses a single worker thread operating * off an unbounded queue. (Note however that if this single * thread terminates due to a failure during execution prior to * shutdown, a new one will take its place if needed to execute * subsequent tasks.) Tasks are guaranteed to execute * sequentially, and no more than one task will be active at any * given time. Unlike the otherwise equivalent * {@code newFixedThreadPool(1)} the returned executor is * guaranteed not to be reconfigurable to use additional threads. * * @return the newly created single-threaded Executor */ public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }

初始化只有一个线程的线程池，如果该线程异常结束，会重新创建一个新的线程执行任务，使用LinkedBlockingQueue作为阻塞队列。

newScheduledThreadPool ：周期性的线程池。 /** * Creates a thread pool that can schedule commands to run after a * given delay, or to execute periodically. * @param corePoolSize the number of threads to keep in the pool, * even if they are idle * @return a newly created scheduled thread pool * @throws IllegalArgumentException if {@code corePoolSize < 0} */ public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize); }

初始化线程池的时候使用new ScheduledThreadPoolExecutor创建一个线程池对象，可以指定的时间内周期性的执行所提交的执行。

ThreadPoolExecutor类中的属性

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); //利用低位29位表示线程池中的线程数目，通过高位3位表示线程池的运行状态，默认是Running private static final int COUNT_BITS = Integer.SIZE - 3; //29 private static final int CAPACITY = (1 << COUNT_BITS) - 1; //0010 0000 ... - 1 = 0001 1111 ... // runState is stored in the high-order bits private static final int RUNNING = -1 << COUNT_BITS; //高位111 private static final int SHUTDOWN = 0 << COUNT_BITS; //高位000 //该状态的线程池不会接收新任务，但是会处理阻塞队列中的任务 private static final int STOP = 1 << COUNT_BITS; //高位001 //该状态的线程池不会接收新任务，但是不会处理阻塞队列中的任务，还会中断正在执行的任务 private static final int TIDYING = 2 << COUNT_BITS; //高位010 private static final int TERMINATED = 3 << COUNT_BITS; //高位011 // Packing and unpacking ctl private static int runStateOf(int c) { return c & ~CAPACITY; } // c & 1110 0000... 获取高三位（运行状态） private static int workerCountOf(int c) { return c & CAPACITY; } // c & 0001 1111... 获取低29位（线程个数） private static int ctlOf(int rs, int wc) { return rs | wc; } // -1 | 0 private final ReentrantLock mainLock = new ReentrantLock(); //控制新增工作线程的原子性 private final HashSet<Worker> workers = new HashSet<Worker>(); //工作线程的集合

线程池提交任务流程分析

线程池在提交任务的过程中有两种方法，分别是execute()方法和submit()方法。

execute(Runnable command)submit(Runnable task) / submit(Runnable task, T result) / submit(Callable<T> task)

execute底层源码

//execute()提交任务流程 execute() -> addWorker() -> runWorker() 线程池底层的工作线程是worker线程，需要由ReentrantLock保证。 /** * Executes the given task sometime in the future. The task * may execute in a new thread or in an existing pooled thread. * * If the task cannot be submitted for execution, either because this * executor has been shutdown or because its capacity has been reached, * the task is handled by the current {@code RejectedExecutionHandler}. * * @param command the task to execute * @throws RejectedExecutionException at discretion of * {@code RejectedExecutionHandler}, if the task * cannot be accepted for execution * @throws NullPointerException if {@code command} is null */ public void execute(Runnable command) { //任务不允许为null值 if (command == null) throw new NullPointerException(); /* * Proceed in 3 steps: * * 1. If fewer than corePoolSize threads are running, try to * start a new thread with the given command as its first * task. The call to addWorker atomically checks runState and * workerCount, and so prevents false alarms that would add * threads when it shouldn't, by returning false. * * 2. If a task can be successfully queued, then we still need * to double-check whether we should have added a thread * (because existing ones died since last checking) or that * the pool shut down since entry into this method. So we * recheck state and if necessary roll back the enqueuing if * stopped, or start a new thread if there are none. * * 3. If we cannot queue task, then we try to add a new * thread. If it fails, we know we are shut down or saturated * and so reject the task. */ int c = ctl.get(); //获取ctl变量 //线程数量与corePoolSize，如果小于corePoolSize if (workerCountOf(c) < corePoolSize) { //addWorker创建线程 if (addWorker(command, true)) return; //没有成功创建线程，再一次获取ctl变量 c = ctl.get(); } //判断线程池状态是否是Running状态，把当前这个任务放入阻塞队列， //如果是Running状态，同时任务成功放入阻塞队列 if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); //再次去检查线程池的状态，如果是非Running状态， //从阻塞队列中移除当前的任务 if (! isRunning(recheck) && remove(command)) //执行拒绝策略 reject(command); //如果线程池仍旧是Running状态，再次获取线程数量，如果没有线程 else if (workerCountOf(recheck) == 0) //创建线程 addWorker(null, false); } //判断线程池中创建线程是否成功，如果失败 else if (!addWorker(command, false)) //执行拒绝策略 reject(command); }

在execute()方法中，我们会发现对线程的状态进行了两次检查，即double check，那么为什么要对它进行两次检查呢？

原因是在多线程环境下，线程池的状态时刻都会发生改变，而ctl.get()是非原子操作，有可能获取到线程池状态后线程池状态就发生了改变。

由此可知，在使用execute()方法提交任务时，线程池的工作线程通过worker实现，在ReentrantLock锁的保证下，会将worker工作线程加入到workers(HashSet)，并启动Worker当中的线程。

/** * Main worker run loop. Repeatedly gets tasks from queue and * executes them, while coping with a number of issues: * * 1. We may start out with an initial task, in which case we * don't need to get the first one. Otherwise, as long as pool is * running, we get tasks from getTask. If it returns null then the * worker exits due to changed pool state or configuration * parameters. Other exits result from exception throws in * external code, in which case completedAbruptly holds, which * usually leads processWorkerExit to replace this thread. * * 2. Before running any task, the lock is acquired to prevent * other pool interrupts while the task is executing, and then we * ensure that unless pool is stopping, this thread does not have * its interrupt set. * * 3. Each task run is preceded by a call to beforeExecute, which * might throw an exception, in which case we cause thread to die * (breaking loop with completedAbruptly true) without processing * the task. * * 4. Assuming beforeExecute completes normally, we run the task, * gathering any of its thrown exceptions to send to afterExecute. * We separately handle RuntimeException, Error (both of which the * specs guarantee that we trap) and arbitrary Throwables. * Because we cannot rethrow Throwables within Runnable.run, we * wrap them within Errors on the way out (to the thread's * UncaughtExceptionHandler). Any thrown exception also * conservatively causes thread to die. * * 5. After task.run completes, we call afterExecute, which may * also throw an exception, which will also cause thread to * die. According to JLS Sec 14.20, this exception is the one that * will be in effect even if task.run throws. * * The net effect of the exception mechanics is that afterExecute * and the thread's UncaughtExceptionHandler have as accurate * information as we can provide about any problems encountered by * user code. * * @param w the worker */ final void runWorker(Worker w) { Thread wt = Thread.currentThread(); Runnable task = w.firstTask; w.firstTask = null; w.unlock(); // allow interrupts boolean completedAbruptly = true; try { while (task != null || (task = getTask()) != null) { w.lock(); // If pool is stopping, ensure thread is interrupted; // if not, ensure thread is not interrupted. This // requires a recheck in second case to deal with // shutdownNow race while clearing interrupt if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { beforeExecute(wt, task); Throwable thrown = null; try { task.run(); } catch (RuntimeException x) { thrown = x; throw x; } catch (Error x) { thrown = x; throw x; } catch (Throwable x) { thrown = x; throw new Error(x); } finally { afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; w.unlock(); } } completedAbruptly = false; } finally { processWorkerExit(w, completedAbruptly); } }

runWorker() - - 线程执行的过程。它的核心工作流程为：

1、线程启动之后， 通过unlock释放锁，为了允许当前线程可被中断。2、获取任务firstTask，执行任务的run方法，在执行run方法之前，还需要进行加锁操作，任务执行完需要释放锁。3、在执行任务的前后，可以根据业务场景自定义beforeExecute方法和afterExecute方法。

submit底层源码

/** * @throws RejectedExecutionException {@inheritDoc} * @throws NullPointerException {@inheritDoc} */ public Future<?> submit(Runnable task) { if (task == null) throw new NullPointerException(); RunnableFuture<Void> ftask = newTaskFor(task, null); execute(ftask); return ftask; } /** * @throws RejectedExecutionException {@inheritDoc} * @throws NullPointerException {@inheritDoc} */ public <T> Future<T> submit(Runnable task, T result) { if (task == null) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task, result); execute(ftask); return ftask; } /** * @throws RejectedExecutionException {@inheritDoc} * @throws NullPointerException {@inheritDoc} */ public <T> Future<T> submit(Callable<T> task) { if (task == null) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task); execute(ftask); return ftask; } submit()方法存在于AbstractExecutorService抽象类中，通过源码我们可以发现，submit()方法在底层仍然调用的是execute()方法，因此，submit()方法提交任务的流程与execute()方法大体一致。