线程池ThreadPoolExecutor最全实战案例

目录

• 线程池ThreadPoolExecutor
  • 1、创建线程池 ThreadPoolExecutor()
  • 2、工作顺序
  • 3、拒绝策略
  • 4、CompletableFuture异步编排
    • 1）、whenComplete可以处理正常和异常的计算结果，exceptionally处理异常情况。
    • 2）、handle方法执行完成后的处理，与complete一样，可处理异常，也可返回默认值
    • 3）、线程串行化方法
    • 4）、两任务组合，都要完成
    • 5）、两任务组合，一个完成
    • 6）、多任务组合

线程池ThreadPoolExecutor

1、创建线程池 ThreadPoolExecutor()

• corePoolSize：核心线程数[一直存在]。除非设置allowCoreThreadTimeOut，线程池创建以后准备就绪的线程数量。
• maximumPoolSize：最大线程数量，控制资源。
• keepAliveTime：存活时间。如果当前的线程数量大于核心线程数，只要线程空闲时间大于指定的keepAliveTime时间，就释放空闲的线程（maximumPoolSize-corePoolSize）。
• TimeUnit：存活时间单位。
• BlockingQueue：阻塞队列。如果任务很多，就会将多的任务放在队列中，只要有线程空闲，就会去队列中取出新的任务执行。
• ThreadFactory：线程的创建工厂。
• RejectedExecutionHandler：如果队列满了，按照指定的拒绝策略执行任务。

2、工作顺序

• 1）、线程池创建，准备核心线程，准备接受任务；
• 2）、新的任务进来，用空闲的核心线程执行任务；
• 3）、核心线程满了，将再进来的任务放入阻塞队列中，空闲的核心线程会去阻塞队列中获取任务执行；
• 4）、阻塞队列满了，就直接开启新线程执行，最大只能开到max设置的数量；
• 5）、任务执行完成，空闲的线程（最大线程数-核心线程数）会在keepAliveTime指定的时间后自动销毁，最终保持到核心线程数量；
• 6）、如果线程开到了最大线程数，还有新的任务进来，就会使用指定的拒绝策略进行处理。

3、拒绝策略

• DiscardOldestPolicy：丢弃最老的任务；
• CallerRunsPolicy：同步调用；
• AbortPolicy：丢弃新任务并抛出异常；
• DiscardPolicy：丢弃新任务；

4、CompletableFuture异步编排

CompletableFuture提供了四个静态方法创建异步任务：

CompletableFuture.runAsync(Runnable runnable);

CompletableFuture.runAsync(Runnable runnable，Executor executor);

CompletableFuture.supplyAsync(Supplier<U> supplier);

CompletableFuture.supplyAsync(Supplier<U> supplier，Executor executor);

其中runXXX没有返回结果，supplyXXX可以获取返回结果；

都可以传入自定义的线程池，否则使用默认的线程池；

1）、whenComplete可以处理正常和异常的计算结果，exceptionally处理异常情况。

whenComplete获取上任务的结果：

	public static void main(String[] args) {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).whenComplete((result,exception)->{
			System.out.println("异步任务完成了，结果："+result);
			System.out.println("异步任务异常："+exception);
		});
	}
// 执行结果：
-----main start--------1
当前线程12------当前结果5
异步任务完成了，结果：5
异步任务异常：null

whenComplete获取上任务抛出的异常信息：

	public static void main(String[] args) {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 0;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).whenComplete((result,exception)->{
			System.out.println("异步任务完成了，结果："+result);
			System.out.println("异步任务异常："+exception);
		});
	}
// 执行结果：
-----main start--------1
异步任务完成了，结果：null
异步任务异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero

exceptionally捕获异常信息，返回默认值

	public static void main(String[] args) throws Exception {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 0;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).whenComplete((result,exception)->{
			System.out.println("异步任务完成了，结果："+result);
			System.out.println("异步任务异常："+exception);
		}).exceptionally((exception)->{
			System.out.println("捕获异步任务异常："+exception);
			return 10;
		});
		System.out.println("任务结果："+future.get());
	}
// 执行结果：
-----main start--------1
异步任务完成了，结果：null
异步任务异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
捕获异步任务异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
任务结果：10

exceptionally可以捕获到whenComplete的异常

	public static void main(String[] args) throws Exception {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).whenComplete((result,exception)->{
			System.out.println("异步任务完成了，结果："+result);
			System.out.println("异步任务异常："+exception);
			throw new RuntimeException("whenComplete抛出异常");
		}).exceptionally((exception)->{
			System.out.println("捕获异步任务异常："+exception);
			return 10;
		});
		System.out.println("任务结果："+future.get());
	}
// 执行结果：
-----main start--------1
当前线程12------当前结果5
异步任务完成了，结果：5
异步任务异常：null
捕获异步任务异常：java.util.concurrent.CompletionException: java.lang.RuntimeException: whenComplete抛出异常
任务结果：10

exceptionally抛出异常，任务结束

	public static void main(String[] args) throws Exception {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).whenComplete((result,exception)->{
			System.out.println("异步任务完成了，结果："+result);
			System.out.println("异步任务异常："+exception);
			throw new RuntimeException("whenComplete抛出异常");
		}).exceptionally((exception)->{
			System.out.println("捕获异步任务异常："+exception);
			throw new RuntimeException("任务执行失败");
		});
		System.out.println("任务结果："+future.get());
	}
// 执行结果：
-----main start--------1
当前线程12------当前结果5
异步任务完成了，结果：5
异步任务异常：null
捕获异步任务异常：java.util.concurrent.CompletionException: java.lang.RuntimeException: whenComplete抛出异常
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.RuntimeException: 任务执行失败

whenComplete 和 whenCompleteAsync 区别：

• whenComplete：使用当前任务的线程继续执行；
• whenCompleteAsync：把whenCompleteAsync任务继续提交给线程池来进行执行；
• whenComplete：可以获取异常信息，但不能处理异常；
• exceptionally：可以获取异常信息，进行异常处理；

2）、handle方法执行完成后的处理，与complete一样，可处理异常，也可返回默认值

handle捕获异常，返回默认值

	public static void main(String[] args) throws Exception {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 0;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).handle((result,exception)->{
			System.out.println("异步任务完成了，结果："+result);
			System.out.println("异步任务异常："+exception);
			return 20;
		});
		System.out.println("任务结果："+future.get());
	}
//执行结果：
-----main start--------1
异步任务完成了，结果：null
异步任务异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
任务结果：20

handle抛出异常，任务结束

	public static void main(String[] args) throws Exception {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 0;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).handle((result,exception)->{
			System.out.println("异步任务完成了，结果："+result);
			System.out.println("异步任务异常："+exception);
			throw new RuntimeException("handle抛出异常");
		});
		System.out.println("任务结果："+future.get());
	}
//执行结果：
-----main start--------1
异步任务完成了，结果：null
异步任务异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.RuntimeException: handle抛出异常

3）、线程串行化方法

线程串行化thenRun()：不能获取到上一步任务的执行结果，不能捕获上一步异常，上一步异常任务结束

	public static void main(String[] args) throws Exception {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture.supplyAsync(() -> {
			int a = 10 / 0;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).thenRun(()->{
			System.out.println("任务2启动了");
		});
		System.out.println("任务结果：");
	}
// 执行结果：
-----main start--------1
任务结果：

线程串行化thenRun()：不能获取到上一步任务的执行结果，无返回值

	public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).thenRun(()->{
			System.out.println("任务2启动了");
		});
		System.out.println("任务结果：");
	}
// 执行结果：
-----main start--------1
当前线程12------当前结果5
任务2启动了
任务结果：

线程串行化thenRun()：不能获取到上一步任务的执行结果，无返回值，发生异常时不会抛出异常

	public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).thenRun(()->{
			System.out.println("任务2启动了");
			throw new RuntimeException("任务2失败了");
		});
		System.out.println("任务结果：");
	}
// 执行结果：
-----main start--------1
当前线程12------当前结果5
任务2启动了
任务结果：

线程串行化thenAccept()：可以获取上一步结果，异常与thenRun()方法一致

	public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).thenAccept((result)->{
			System.out.println("任务1执行结果"+result);
			System.out.println("任务2启动了");
			throw new RuntimeException("任务2失败了");
		});
		System.out.println("任务结果：");
	}
//执行结果：
-----main start--------1
当前线程12------当前结果5
任务1执行结果5
任务2启动了
任务结果：

线程串行化thenAccept()：可以获取上一步结果，异常与thenRun()方法一致

	public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程"+Thread.currentThread().getId()+"------当前结果" + a);
			return a;
		}).thenAccept((result)->{
			System.out.println("任务1执行结果"+result);
			System.out.println("任务2启动了");
			throw new RuntimeException("任务2失败了");
		});
		System.out.println("任务结果：");
	}
//执行结果：
-----main start--------1
当前线程12------当前结果5
任务1执行结果5
任务2启动了
任务结果：

线程串行化thenApply()：可以获取上一步结果，有返回值

public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程" + Thread.currentThread().getId() + "------当前结果" + a);
			return a;
		}).thenApply((result) -> {
			System.out.println("任务1执行结果" + result);
			System.out.println("任务2启动了");
			return 100;
		});
		Integer result=null;
		try {
			result = future.get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		System.out.println("任务结果："+result);
	}
//执行结果：
-----main start--------1
当前线程12------当前结果5
任务1执行结果5
任务2启动了
任务结果：100

线程串行化thenApply()：可以获取上一步结果，有返回值，可抛出异常，上一步发生异常任务结束

	public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程" + Thread.currentThread().getId() + "------当前结果" + a);
			return a;
		}).thenApply((result) -> {
			System.out.println("任务1执行结果" + result);
			System.out.println("任务2启动了");
			throw new RuntimeException("任务2发生异常了");
		});
		Integer result=null;
		try {
			result = future.get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		System.out.println("任务结果："+result);
	}
//执行结果：
-----main start--------1
当前线程12------当前结果5
任务1执行结果5
任务2启动了
任务结果：null
java.util.concurrent.ExecutionException: java.lang.RuntimeException: 任务2发生异常了

thenApply 、thenAccept、thenRun 区别：

• thenApply：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值；
• thenAccept：消费处理结果。接收任务处理的结果，并消息处理，无返回结果；
• thenRun：只要上面的任务执行完成，就开始执行thenRun，只是处理完任务后，执行thenRun的后续操作；

4）、两任务组合，都要完成

runAfterBoth()无返回结果：任务1和任务2执行完成，执行当前任务；任务1和任务2任一抛出异常，任务3不执行；任一任务不会抛出异常；

	public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程" + Thread.currentThread().getId() + "------任务一结果：" + a);
			return a;
		});

		CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 0;
			System.out.println("当前线程" + Thread.currentThread().getId() + "------任务二结果：" + a);
			return a;
		});

		future1.runAfterBoth(future2,()->{
			int a=1/0;
			System.out.println("任务三开始了"+a);
		});

		System.out.println("任务结果：");
	}
//执行结果：
-----main start--------1
当前线程12------任务一结果：5
任务结果：

runAfterBoth()无返回结果，可得到任务1和任务2结果：任务1和任务2任一抛出异常，任务3不执行；任一任务不会抛出异常；

	public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程" + Thread.currentThread().getId() + "------任务一结果：" + a);
			return a;
		});

		CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程" + Thread.currentThread().getId() + "------任务二结果：" + a);
			return a;
		});

		future1.thenAcceptBothAsync(future2,(f1,f2)->{
			System.out.println("任务一结果："+f1+"---任务二结果："+f2);
			int a=1/0;
			System.out.println("任务三开始了"+a);
		});

		System.out.println("任务结果：");
	}
-----main start--------1
当前线程12------任务一结果：5
当前线程12------任务二结果：5
任务结果：
任务一结果：5---任务二结果：5

runAfterBoth()有返回结果，可得到任务1和任务2结果：任务1和任务2任一抛出异常，任务3不执行；可捕获任务3的异常；

	public static void main(String[] args)  {
		System.out.println("-----main start--------"+Thread.currentThread().getId());
		CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程" + Thread.currentThread().getId() + "------任务一结果：" + a);
			return a;
		});

		CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
			int a = 10 / 2;
			System.out.println("当前线程" + Thread.currentThread().getId() + "------任务二结果：" + a);
			return a;
		});

		CompletableFuture<Integer> future = future1.thenCombineAsync(future2, (f1, f2) -> {
			System.out.println("任务一结果：" + f1 + "---任务二结果：" + f2);
			int a = 1 / 0;
			System.out.println("任务三开始了" + a);
			return a;
		});

		Integer integer = null;
		try {
			integer = future.get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		System.out.println("任务结果："+integer);
	}
-----main start--------1
当前线程12------任务一结果：5
当前线程12------任务二结果：5
任务一结果：5---任务二结果：5
任务结果：null
java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero

thenCombine 、thenAcceptBoth、runAfterBoth 区别：

• thenCombine：组合两个future，获取两个future的返回结果，并返回当前任务的返回值；
• thenAcceptBoth：组合两个future，获取两个future任务的返回结果，然后处理任务，没有返回值；
• runAfterBoth：组合两个future，不需要获取future的结果，只需要两个future处理完任务后，处理该任务；

5）、两任务组合，一个完成

applyToEither 、acceptEither、runAfterEither 区别：

• applyToEither：两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值；
• acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值；
• runAfterEither：两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值；

6）、多任务组合

allOf 、anyOf 区别：

• allOf：等待所有任务完成
• anyOf：只要有一个任务完成