线程池ThreadPoolExecutor中submit方法和execute方法的区别和关系

ThreadPoolExecutor是线程池，其继承AbstractExecutorService，如下代码：

package java.util.concurrent;

import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadPoolExecutor extends AbstractExecutorService {
	private final AtomicInteger ctl = new AtomicInteger(ctlOf(-536870912, 0));
	private static final int COUNT_BITS = 29;
	private static final int CAPACITY = 536870911;
	private static final int RUNNING = -536870912;
	private static final int SHUTDOWN = 0;
	private static final int STOP = 536870912;
	private static final int TIDYING = 1073741824;
	private static final int TERMINATED = 1610612736;
	private final BlockingQueue<Runnable> workQueue;

	private static int runStateOf(int paramInt) {
		return paramInt & 0xE0000000;
	}

	private static int workerCountOf(int paramInt) {
		return paramInt & 0x1FFFFFFF;
	}

	private static int ctlOf(int paramInt1, int paramInt2) {
		return paramInt1 | paramInt2;
	}

	private static boolean runStateLessThan(int paramInt1, int paramInt2) {
		return paramInt1 < paramInt2;
	}

	private static boolean runStateAtLeast(int paramInt1, int paramInt2) {
		return paramInt1 >= paramInt2;
	}

 

 

AbstractExecutorService实现ExecutorService接口，如下代码：

package java.util.concurrent;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public abstract class AbstractExecutorService implements ExecutorService {
	protected <T> RunnableFuture<T> newTaskFor(Runnable paramRunnable, T paramT) {
		return new FutureTask(paramRunnable, paramT);
	}

	protected <T> RunnableFuture<T> newTaskFor(Callable<T> paramCallable) {
		return new FutureTask(paramCallable);
	}

	public Future<?> submit(Runnable paramRunnable) {
		if (paramRunnable == null) {
			throw new NullPointerException();
		}
		RunnableFuture localRunnableFuture = newTaskFor(paramRunnable, null);
		execute(localRunnableFuture);
		return localRunnableFuture;
	}

	public <T> Future<T> submit(Runnable paramRunnable, T paramT) {
		if (paramRunnable == null) {
			throw new NullPointerException();
		}
		RunnableFuture localRunnableFuture = newTaskFor(paramRunnable, paramT);
		execute(localRunnableFuture);
		return localRunnableFuture;
	}

	public <T> Future<T> submit(Callable<T> paramCallable) {
		if (paramCallable == null) {
			throw new NullPointerException();
		}
		RunnableFuture localRunnableFuture = newTaskFor(paramCallable);
		execute(localRunnableFuture);
		return localRunnableFuture;
	}

接口ExecutorService实现Executor，代码如下：

package java.util.concurrent;

import java.util.Collection;
import java.util.List;

public abstract interface ExecutorService extends Executor {
	public abstract void shutdown();

	public abstract List<Runnable> shutdownNow();

	public abstract boolean isShutdown();

	public abstract boolean isTerminated();

	public abstract boolean awaitTermination(long paramLong, TimeUnit paramTimeUnit) throws InterruptedException;

	public abstract <T> Future<T> submit(Callable<T> paramCallable);

	public abstract <T> Future<T> submit(Runnable paramRunnable, T paramT);

	public abstract Future<?> submit(Runnable paramRunnable);

	public abstract <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> paramCollection)
			throws InterruptedException;

	public abstract <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> paramCollection, long paramLong,
			TimeUnit paramTimeUnit) throws InterruptedException;

	public abstract <T> T invokeAny(Collection<? extends Callable<T>> paramCollection)
			throws InterruptedException, ExecutionException;

	public abstract <T> T invokeAny(Collection<? extends Callable<T>> paramCollection, long paramLong,
			TimeUnit paramTimeUnit) throws InterruptedException, ExecutionException, TimeoutException;
}

 在接口Executor中只定义了一个方法，代码如下：

package java.util.concurrent;

public abstract interface Executor {
	public abstract void execute(Runnable paramRunnable);
}

 如上所示：ThreadPoolExecutor extends AbstractExecutorService　implements ExecutorService　extends Executor，

execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。

　　submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果。

submit()方法中参数可以是Callable类型也可以是Runnable类型，而execute()方法参数只能是Runnable类型。

 参考：https://www.cnblogs.com/dolphin0520/p/3932921.html

参考：https://www.jianshu.com/p/8e93a82197b1

参考：https://blog.youkuaiyun.com/xiaojiahao_kevin/article/details/51735518