1. execute 和 submit 的区别
前面说了还需要介绍多线程中使用 execute 和 submit 的区别（这两个方法都是线程池 ThreadPoolExecutor 的方法）。
1.1 方法来源不同
execute 方法是线程池的顶层接口 Executor 定义的，在 ThreadPoolExecutor 中实现：
void execute(Runnable command);submit()是在ExecutorService接口中定义的，并定义了三种重载方式：
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);在AbstractExecutorService类中有它们的具体实现，而ThreadPoolExecutor继承了AbstractExecutorService类。所以 ThreadPoolExecutor 也有这三个方法。
1.2 接收参数不同
从上面的方法来源中可以看出，二者接收参数类型不同：
-
execute()方法只能接收实现Runnable接口类型的任务 -
submit()方法则既可以接收Runnable类型的任务，也可以接收Callable类型的任务
1.3 返回值不同
由于 Runnable 和 Callable 的区别就是，Runnable 无返回值，Callable 有返回值。
所以 execute 和 submit 的返回值也不同。
execute()的返回值是void，线程提交后不能得到线程的返回值submit()的返回值是Future，通过Future的get()方法可以获取到线程执行的返回值，get()方法是同步的，执行get()方法时，如果线程还没执行完，会同步等待，直到线程执行完成
虽然submit()方法可以提交Runnable类型的参数，但执行Future方法的get()时，线程执行完会返回null，不会有实际的返回值，这是因为Runable本来就没有返回值1.4 异常处理机制不同
- 用
submit提交任务，任务内有异常也不会打印异常信息，而是调用get()方法时，打印出任务执行异常信息 - 用
execute提交任务时，任务内有异常会直接打印出来
后面源码分析中会体现这个不同点！
2. execute 和 submit 源码分析
2.1 submit 源码分析
submit 方法是 ExecutorService 接口定义，由 AbstractExecutorService 抽象类实现，有三个重载方法：
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
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;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}可以看一下上面 submit 的三个重载方法，方法体很相似，都调用了一个方法 newTaskFor(...) ，那么就来看看这个方法，可以看到它有两个重载方法：
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}解释一下上面两个重载方法吧：
- 第一个
newTaskFor(Runnable runnable, T value)：可以看到它应该是将submit方法传进来的Runnable转化成了Callable，并给一个返回值 - 第二个
newTaskFor(Callable<T> callable)：就是submit直接传进了一个Callable，包装成FutureTask返回。
上面代码中可以看一下 RunnableFuture 和 FutureTask 的关系：
先看一下 RunnableFuture：
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
RunnableFuture 实现了 Runnable 和 Future，它的子类就是 FutureTask
public class FutureTask<V> implements RunnableFuture<V> {
// ...
}
到这里就明白了吧，当 submit 传入的参数是 Runnable 的时候，就需要 FutureTask的构造方法将 Runnable 转化成 Callable下面看一下 FutureTask 的两个构造函数：
// 传入Runnable则是执行了一共方法，看一下这个方法，具体转化逻辑就有了
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
// 传入Callable直接赋值给类的成员变量
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}下面看一下当 submit 传入 Runnable 的时候，其实到这里就是调用了 FutureTask(Runnable runnable, V result) 构造函数，看一下这个构造函数中将 Runable 转化成了 Callable，看一下 Executors.callable(runnable, result) 方法：
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
看看这里有创建了一个类，就是 RunnableAdapter，下面再看一下这个内部类：
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
看看这个内部类，实现了 Callable 接口，并在 call 方法中 调用了 task 的 run 方法，就是相当于任务代码直接在 call 方法中了。这里必须说一下线程池中的线程是怎么执行的，这里就不说全部了，直说与这里相关的一部分：
- 看到上面
submit方法最终也是调用了execute方法，经过上main源码分析的一系列转换，submit最终调用了ThreadPoolExecutor的execute方法 -
execute方法里面有一个很关键的方法是addWorker(command, true) - 进入
addWorker方法，可以看到里面 new 了一个Worker。Worker里面有一个属性是Thread，后面直接调用了它的start方法启动了线程 - 可以看一下
Worker类，它实现了Runnable，这里就要看看Worker的run方法了，调用了runWorker - 在
runWorker方法中，有一行是task.run()，调用submit时最终这个run方法就是RunnableFuture中的run()方法。具体实现在FutureTask中
下面就看一下 FutureTask 中实现的 run 方法：
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
//从这里可以看到，调用了call()方法
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
// 看看，这里是将异常放在了一个属性中，所以 submit执行的时候不会抛出异常，只有在调用 get 方法时才会抛出异常
setException(ex);
}
if (ran)
//这里将返回值设置到了outcome，执行完后可以通过get()获取
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}看一下上面两个主要的方法（setException(ex) 和 set(result)）:
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}可以看到两个方法一个是将异常放进了 outcome ，一个是将 call 方法的返回值放进了 outcome。不管是异常还是线程执行的返回值，都会在get 方法中获取到，下面看一下get 方法，方法在 FutureTask 类中：
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
private V report(int s) throws ExecutionException {
Object x = outcome;
if (s == NORMAL)
return (V)x;
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}看看get 方法调用了 report 方法，取到了上面setException(ex) 和 set(result)方法 放进 outcome 的值并返回。
这里如果线程抛出了异常，这个线程会被从线程哈希表中移除，取消强引用，让 GC 回收，并且重新创建一个新的线程。
到这里 submit 方法的源码就分析完了！！！
2.2 execute 源码分析
此方法是线程顶层接口 Executor 定义的，在 ThreadPoolExecutor 有其实现，直接看实现：
其实 submit 方法最终调用了 execute 也是这一段，不同的是最后调用的线程的 run 方法是不同实现类实现的
public void execute(Runnable command) {
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();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}这里主要就是看 submit 和 execute 的区别点，所以线程池的看具体源码就不看了，我之前写的有一篇线程池源码的笔记很详细：线程池源码
上面有个很重要的方法，是将线程加入队列并执行的，就是 addWorker 方法，这里就不copy addWorker 的代码了，只需要知道里面创建了一个 Worker 对象即可。Worker 对象中有一个属性是 Thread，后面获取到了这个 Thread ，并执行了 start 方法。
然而在 Worker 本身是实现了 Runnable 的，所以后面执行的 start 方法，实际是执行了 Worker 中的 run 方法：
public void run() {
runWorker(this);
}看看 Worker 中run 方法调用的 runWorker 方法：
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 {
// 这个地方是重点，run 方法
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);
}
}其实这里的源码就和 submit 一样了，只是上面 task.run() 调用的是不同实现类的 run 方法。
-
execute方法传进来的最终是调用的Runnable或其子类的run方法 -
submit方法进来的最终是调用了FutureTask的run方法
基于上面的区别，再去看 FutureTask 中 run 方法的源码，就可以知道一下结论：
-
execute是没返回值的，submit有返回值 - 用
execute提交任务时，任务内有异常会直接打印出来；用submit提交任务，任务内有异常也不会打印异常信息，而是调用get()方法时，打印出任务执行异常信息
