那可以做网站,接广告的平台,自己做的网站突然打不开,兼容模式网站错位前言
ThreadPoolExecutor提供了两种方法来执行异步任务#xff0c;分别是execute和submit#xff0c;也是日常开发中经常使用的方法#xff0c;那么它俩有什么区别呢#xff1f;
语义不同
首先是语义上的不同。execute声明在Executor接口#xff0c;它接受一个Runnable…前言
ThreadPoolExecutor提供了两种方法来执行异步任务分别是execute和submit也是日常开发中经常使用的方法那么它俩有什么区别呢
语义不同
首先是语义上的不同。execute声明在Executor接口它接受一个Runnable类型的入参且没有返回值代表它可以异步执行一个没有返回结果的异步任务你甚至不知道这个任务什么时候执行完毕。
public interface Executor {void execute(Runnable command);
}而submit声明在ExecutorService且有多个重载方法最明显的区别就是submit方法均有Future返回值。Future代表未来结果的一个占位符可以通过它拿到异步任务的执行结果如果异步任务执行失败也可以通过它拿到异常信息。 所以下面三个方法的区别是方法1的入参是Runnable没有返回结果所以返回的Future是也拿不到结果的只能判断异步任务是否执行完毕以及是否执行异常方法2返回的Future可以拿到结果值是第二个入参方法3也可以拿到结果值就是入参Callable返回的结果。
public interface ExecutorService extends Executor {[1] Future? submit(Runnable task);[2] T FutureT submit(Runnable task, T result);[3] T FutureT submit(CallableT task);
}综上所述execute和submit最明显的一个区别就是语义上的不同。execute用来执行没有返回结果的异步任务且调用方不关心任务的执行结果而submit用来执行有返回结果的异步任务适用于调用方关心执行结果和异步任务执行有返回值的场景。
异常处理不同
execute和submit第二个区别是异步任务执行异常时的处理不同。execute遇到异常会直接抛出来而submit会默默吃掉异常。 如下示例execute会把除0异常的堆栈打印出来而submit则没有打印任何信息。
public static void main(String[] args) throws Exception {ThreadPoolExecutor executor new ThreadPoolExecutor(2, 2, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue());executor.execute(() - {System.err.println(execute result:);System.err.println(1 / 0);});executor.submit(() - {System.err.println(submit result:);System.err.println(1 / 0);});}execute result:
Exception in thread pool-1-thread-1 java.lang.ArithmeticException: / by zeroat ExecutorDemo2.lambda$main$0(ExecutorDemo2.java:18)at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1136)at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635)at java.base/java.lang.Thread.run(Thread.java:840)
submit result:你可能会觉得疑惑submit凭什么要默默吃掉异常任务执行出错为什么不通知调用方呢 事实上submit针对异常的处理方式正和它的语义有关它并没有吃掉异常而是它认为方法执行异常也是结果的一部分别忘了它是有Future返回值的只不过它并没有粗暴的直接抛出异常而是把异常记录在了Future返回值里面。如果要关心submit提交的异步任务的执行情况可以通过下面这种方式
Future? future executor.submit(() - {System.err.println(submit result:);System.err.println(1 / 0);
});
try {future.get();System.err.println(正常执行);
} catch (Exception e) {System.err.println(原来执行异常了: e.getMessage());
}异常线程销毁重建
execute和submit第三个区别是execute面对异常线程会销毁重建而submit会继续复用异常线程。 看下面的例子创建一个固定3个线程的线程池先分别execute执行2个正常的任务和1个异常任务sleep一会再次执行三个任务我们发现3号线程因为执行异常被销毁了线程池重新启动了4号线程。如果调用submit则始终是一开始创建的三个线程在工作不会出现线程的销毁和重建情况。
public static void main(String[] args) throws Exception {ThreadPoolExecutor executor new ThreadPoolExecutor(3, 3, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue(), new ThreadPoolExecutor.CallerRunsPolicy());executor.execute(new Task(false));executor.execute(new Task(false));executor.execute(new Task(true));Thread.sleep(1000);System.err.println();for (int i 0; i 3; i) {executor.execute(new Task(false));}
}static class Task implements Runnable {private boolean throwException;public Task(boolean throwException) {this.throwException throwException;}SneakyThrowsOverridepublic void run() {if (throwException) {System.err.println(error: Thread.currentThread().getName());throw new RuntimeException();}Thread.sleep(1);System.err.println(task: Thread.currentThread().getName());}
}error:pool-1-thread-3
task:pool-1-thread-2
task:pool-1-thread-1
Exception in thread pool-1-thread-3 java.lang.RuntimeExceptionat ExecutorDemo$Task.run(ExecutorDemo.java:36)at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1136)at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635)at java.base/java.lang.Thread.run(Thread.java:840)task:pool-1-thread-1
task:pool-1-thread-4
task:pool-1-thread-2源码浅析
最后从源码层面看看导致execute和submit区别的原因。 execute方法道尽了线程池的工作流程如果工作线程数小于核心线程数面对提交的任务会创建新线程去执行否则尝试入队队列满则继续创建线程直到最大线程数。
public void execute(Runnable command) {if (command null)throw new NullPointerException();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);
}在线程池里线程会被封装成Worker对象它的run方法是个while循环不停的从任务队列workQueue里面取出异步任务并执行不过它在执行任务时如果遇到异常会直接抛出来。并且在finally里面会把异常线程从workers里面移除后续当工作线程数小于核心线程数时又会继续创建新的线程。
final void runWorker(Worker w) {Thread wt Thread.currentThread();Runnable task w.firstTask;w.firstTask null;w.unlock();boolean completedAbruptly true;try {while (task ! null || (task getTask()) ! null) {w.lock();if ((runStateAtLeast(ctl.get(), STOP) ||(Thread.interrupted() runStateAtLeast(ctl.get(), STOP))) !wt.isInterrupted())wt.interrupt();try {beforeExecute(wt, task);try {task.run();afterExecute(task, null);} catch (Throwable ex) {afterExecute(task, ex);throw ex; // 直接抛出异常}} finally {task null;w.completedTasks;w.unlock();}}completedAbruptly false;} finally {processWorkerExit(w, completedAbruptly);}
}而submit之所以不会抛出异常是因为它对提交的任务进行了一层封装Runnable封装成了FutureTask
public Future? submit(Runnable task) {if (task null) throw new NullPointerException();RunnableFutureVoid ftask newTaskFor(task, null);execute(ftask);return ftask;
}FutureTask就是Future的实现类它重写了run方法对异常进行了捕获如果发生异常会把异常记录下来而不是直接抛出调用者可以通过Future来获得异常信息。
public void run() {if (state ! NEW ||!RUNNER.compareAndSet(this, null, Thread.currentThread()))return;try {CallableV c callable;if (c ! null state NEW) {V result;boolean ran;try {result c.call();ran true;} catch (Throwable ex) {// 捕获异常result null;ran false;setException(ex);// 记录异常}if (ran)set(result);}} finally {runner null;int s state;if (s INTERRUPTING)handlePossibleCancellationInterrupt(s);}
}尾巴
execute和submit都可以执行异步任务但是有三大区别分别是1.语义上的区别是否关心任务的执行情况和返回结果2.遇到遇到是直接抛出还是先记录下来3.异常线程是销毁重建还是继续复用。在源码层面本质上submit只是针对提交的任务又做了一层包装FutureTask重写了run()捕获了异常信息并记录了下来方便调用者从Future里面拿到执行结果。
