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

拼搏现实的明天。 2022-01-29 22:27 239阅读 0赞

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.cnblogs.com_dolphin0520_p_3932921.html]

参考：[https://www.jianshu.com/p/8e93a82197b1][https_www.jianshu.com_p_8e93a82197b1]

参考：[https://blog.csdn.net/xiaojiahao\_kevin/article/details/51735518][https_blog.csdn.net_xiaojiahao_kevin_article_details_51735518]

[https_www.cnblogs.com_dolphin0520_p_3932921.html]: https://www.cnblogs.com/dolphin0520/p/3932921.html
[https_www.jianshu.com_p_8e93a82197b1]: https://www.jianshu.com/p/8e93a82197b1
[https_blog.csdn.net_xiaojiahao_kevin_article_details_51735518]: https://blog.csdn.net/xiaojiahao_kevin/article/details/51735518