第四章 Thread Executors(Executors多线程架构)【下】

最新推荐文章于 2022-07-09 22:33:41 发布
最新推荐文章于 2022-07-09 22:33:41 发布
阅读量659 收藏
点赞数
分类专栏： Java 7 Concurrency Cookbook 文章标签： Callable Executor Future 多线程 RejectedExecutionHan
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37355951/article/details/77246464
版权
本章涉及内容：
  • 创建一个executor线程
  • 创建一个固定大小executor
  • 执行executor任务返回一个结果
  • 处理多任务和处理第一个结果
  • 处理多任务和处理所有结果
  • 延迟之后运行executor
  • 周期地运行任务的executor
  • 在executor取消任务
  • 在executor控制任务完成
  • 在executor分开task启动和处理结果
  • 控制executor的拒绝的任务

1、在executor控制任务完成之后继续做一些事情

重写FutureTask类来改写它们默认的行为

package com.jack;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class ExecutableTask implements Callable<String> {

	private String name;
	
	
	public String getName() {
		return name;
	}

	public ExecutableTask(String name) {
		super();
		this.name = name;
	}



	@Override
	public String call() throws Exception {
		try{
			long duration = (long) (Math.random()*10);
			System.out.printf("%s: 等待 %d 秒\n", this.name, duration);
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e){
			
		}
		return "Hello, world, I'm " + name;
	}

}


package com.jack;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ResultTask extends FutureTask<String>{

	private String name;
	
	public ResultTask(Callable<String> callable) {
		super(callable);
		this.name = ((ExecutableTask)callable).getName();
	}

	@Override
	protected void done() {
		if (isCancelled()){
			System.out.printf("%s： 已经取消了\n", name);
		} else {
			System.out.printf("%s: 已经完成了\n", name);
		}
	}
	

}


package com.jack;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newCachedThreadPool();
		ResultTask resultTasks[] = new ResultTask[5];
		for (int i=0; i<5; i++){
			ExecutableTask executableTask = new ExecutableTask("Task " + i);
			resultTasks[i] = new ResultTask(executableTask);
			executor.submit(resultTasks[i]);
		}
		try{
			TimeUnit.SECONDS.sleep(5);
		}catch (InterruptedException e){
			e.printStackTrace();
		}
		for (int i=0; i<resultTasks.length; i++){
			resultTasks[i].cancel(true);
		}
		for (int i=0; i<resultTasks.length; i++){
			try{
				if(!resultTasks[i].isCancelled()){
					System.out.printf("%s\n", resultTasks[i].get());
				}
			} catch(InterruptedException | ExecutionException e){
				e.printStackTrace();
			}
		}
		executor.shutdown();
	}
}

日志： 

Task 0: 等待 7 秒
Task 1: 等待 2 秒
Task 3: 等待 5 秒
Task 2: 等待 0 秒
Task 4: 等待 4 秒
Task 2: 已经完成了
Task 1: 已经完成了
Task 4: 已经完成了
Task 0： 已经取消了
Task 3： 已经取消了
Hello, world, I'm Task 1
Hello, world, I'm Task 2
Hello, world, I'm Task 4


总结：

  • 1、首先创建一个执行者。ExecutorService
  • 2、创建继承FutureTask<V>的类的数组，并重写了done()方法
  • 3、将会实现Callable接口任务注入到FutureTask数组中。
  • 4、executor进行执行
  • 5、休眠5秒，如果能在5秒执行完都会执行完，其他都会取消
  • 6、执行取消命令
  • 7、对于没有取消获取返回的字符串也就是“Hello world”

2、分开处理启动任务和他们的结果

这里采用的是CompletionService类进行处理

package com.jack;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class ReportGenerator implements Callable<String>{

	private String sender;
	private String title;
	
	public ReportGenerator(String sender, String title) {
		super();
		this.sender = sender;
		this.title = title;
	}

	@Override
	public String call() throws Exception {
		try{
			Long duration = (long) (Math.random()*10);
			System.out.printf("%s_%s: ReportGenerator：生成一个报告持续了%d 秒\n", this.sender, this.title, duration);
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		String ret = sender+": "+ title;
		return ret;
	}

}


package com.jack;

import java.util.concurrent.CompletionService;

public class ReportRequest implements Runnable{

	private String name;
	
	private CompletionService<String> service;
	
	public ReportRequest(String name, CompletionService<String> service) {
		super();
		this.name = name;
		this.service = service;
	}

	@Override
	public void run() {
		ReportGenerator reportGenerator = new ReportGenerator(name, "Report");
		service.submit(reportGenerator);
	}

}


package com.jack;

import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class ReportProcessor implements Runnable {

	private CompletionService<String> service;
	private boolean end;
	
	
	public ReportProcessor(CompletionService<String> service) {
		super();
		this.service = service;
		end = false;
	}


	@Override
	public void run() {
		while (!end){
			try{
				Future<String> result = service.poll(20, TimeUnit.SECONDS);
				if(result!=null){
					String report = result.get();
					System.out.printf("ReportReceiver: 报告已经接收：%s\n", report);
					
				} 
			}catch (InterruptedException | ExecutionException e) {
					e.printStackTrace();
			}
			System.out.printf("ReportSender: 结束\n");
		}
	}


	public void setEnd(boolean end) {
		this.end = end;
	}
	
}


package com.jack;

import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newCachedThreadPool();
		CompletionService<String> service = new ExecutorCompletionService<>(executor);
		ReportRequest faceRequest = new ReportRequest("Face " , service);
		ReportRequest onlineRequest = new ReportRequest("Online", service);
		Thread faceThread = new Thread(faceRequest);
		Thread onlineThread = new Thread(onlineRequest);
		ReportProcessor processor = new ReportProcessor(service);
		Thread senderThread = new Thread(processor);
		System.out.printf("Main: 开启线程\n");
		faceThread.start();
		onlineThread.start();
		senderThread.start();
		try{
			System.out.printf("Main: 等待报道生成\n");
			faceThread.join();
			onlineThread.join();
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		
		System.out.printf("Main : 关闭executor\n");
		executor.shutdown();
		try{
			executor.awaitTermination(1, TimeUnit.DAYS);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		processor.setEnd(true);
		System.out.printf("Main: 结束了");
	}
}

日志： 

Main: 开启线程
Main: 等待报道生成
Main : 关闭executor
Face _Report: ReportGenerator：生成一个报告持续了7 秒
Online_Report: ReportGenerator：生成一个报告持续了9 秒
ReportReceiver: 报告已经接收：Face : Report
ReportSender: 结束
ReportReceiver: 报告已经接收：Online: Report
ReportSender: 结束
Main: 结束了
总结：

  • 1、创建一个执行线程ExecutorService executor
  • 2、创建一个CompletionService<String> 包装executor的类
  • 3、创建两个请求的线程，service.submit() 来说生成报告
  • 4、创建一个线程发送线程，其中里面有个主要的方法Future<String> result = service.poll(20, TimeUnit.SECONDS); 
  • 这句话的意思就是：两个请求产生结果将会放置到一个队列，而发送线程在该队列中取用，参数意思是等待时间20秒，如果20秒没有结果不在等待继续下面执行
  • 5、faceThread.join()和onlineThread.join()表示这两个线程插队，先执行完。最后关闭executor
  • 6、executor.awaitTermination(1,TimeUnit.DAYS)防止Main线程提前退出

扩展：

  • 1、poll() 另个一个方法就是不会等待，直接去Future队列中取对象，没有返回立即null
  • 2、take() 这个方法就是一直等到拿到对象，否则一直阻塞。

3、如何在executor拒绝执行任务

类似：打烊了不接客了（。。。。。。）

当执行shutdown()并不会立即关闭，因为有线程没有执行完，如果你这时候重新请求执行新任务，应该是拒绝的。

例子：采用实现RejectedExecutionHandler来实现这个功能

package com.jack;

import java.util.concurrent.TimeUnit;

public class Task implements Runnable {

	private String name;

	public Task(String name) {
		super();
		this.name = name;
	}

	@Override
	public void run() {
		System.out.printf("Task " + name + ": 开始了\n");
		try{
			long duration = (long) (Math.random()*10);
			System.out.printf("Task %s: ReportGenerator : 生成一个报告持续了%d 秒\n", name, duration);
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("任务 %s : 结束中'''\n", name);

	}

	public String toString(){
		return name;
	}



}

package com.jack;

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class RejectTaskController implements RejectedExecutionHandler {

	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

		System.out.printf("RejectedTaskController: 任务 %s 已经被拒绝了\n", r.toString());
		System.out.printf("RejectedTaskController： %s\n", executor.toString());
		System.out.printf("RejectedTaskController: 终结中。。:%s\n", executor.toString());
		System.out.printf("RejectedTasksController: 终结了：%s\n", executor.isTerminated());
	}
	
	
}


package com.jack;

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class Main {
	public static void main(String[] args) {
		RejectTaskController controller = new RejectTaskController();
		ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
		executor.setRejectedExecutionHandler(controller);
		System.out.printf("Main : 开始中...\n");
		for (int i=0; i<3; i++){
			Task task = new Task("Task" +i);
			executor.submit(task);
		}
		System.out.printf("Main: 关闭这个Executor.\n");
		executor.shutdown();
		System.out.printf("Main : 发送其他任务\n");
		Task task = new Task("RejectedTask");
		executor.submit(task);
		System.out.printf("Main : 结束了\n");
	}
}

日志： 
Main : 开始中...
Task Task0: 开始了
Main: 关闭这个Executor.
Task Task2: 开始了
Task Task1: 开始了
Main : 发送其他任务
RejectedTaskController: 任务 java.util.concurrent.FutureTask@7f31245a 已经被拒绝了
Task Task2: ReportGenerator : 生成一个报告持续了4 秒
Task Task1: ReportGenerator : 生成一个报告持续了3 秒
Task Task0: ReportGenerator : 生成一个报告持续了8 秒
RejectedTaskController： java.util.concurrent.ThreadPoolExecutor@6d6f6e28[Shutting down, pool size = 3, active threads = 3, queued tasks = 0, completed tasks = 0]
RejectedTaskController: 终结中。。:java.util.concurrent.ThreadPoolExecutor@6d6f6e28[Shutting down, pool size = 3, active threads = 3, queued tasks = 0, completed tasks = 0]
RejectedTasksController: 终结了：false
Main : 结束了
任务 Task1 : 结束中'''
任务 Task2 : 结束中'''
任务 Task0 : 结束中'''


总结：

  • 1、实现RejectedExecutionHandler接口的实现类RejectTaskController, 重写rejectedExecution方法
  • 2、创建执行线程的ThreadPoolExecutor executor 
  • 3、设置executor拒绝方法 setRejectedExecutionHandler();
  • 4、开启三个任务，然后关闭shutdown()方法，发现线程还在运行
  • 5、此时再创建任务让executor执行将会被拒绝了
  • 6、如果没有有拒绝处理类，将会抛出异常RejectedExecutionExeption。（它运行时异常，你可以不用捕获它）

第四章完。。。。。。。。

往前的
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
细讲Java线程池Executor
Java_ttcd的博客
08-06 717
CPU密集型 ：线程池的大小推荐为CPU数量 + 1，CPU数量可以根据Runtime.availableProcessors方法获取CPU数量 * CPU利用率 * (1 + 线程等待时间/线程CPU时间)将任务分为CPU密集型和IO密集型，然后分别使用不同的线程池去处理，从而使每个线程池可以根据各自的工作负载来调整推荐使用有界队列，有界队列有助于避免资源耗尽的情况发生。...
【并发编程二】线程池Executor创建线程的简单分析
weixin_43213641的博客
03-29 304
路漫漫其修远兮，吾将上下而求索 线程池的使用 继承Thread类和实现Runnable接口分别提供了单个线程的创建方法，但是线程的创建和销毁是很消耗性能的一种操作，Executor提供了线程池的功能，避免了频繁创建和销毁线程的操作，Executor大体框架如下： Executor只是一个基础的接口，其下ThreadPoolExecutor提供了不同的构造方法来创建线程池，以及Executoes提...
Java线程池ThreadPoolExecutor详细介绍与使用
qq_27480007的博客
07-09 1万+
文章目录 前言 一、线程池基础 1、什么是线程池 2、为什么使用线程池 3、线程池有那些优势 二、线程池使用 1、Java内置线程池：ThreadPoolExecutor 2、通过Executor工厂类中的静态方法获取线程池对象 第一种、通过newCachedThreadPool获取线程池对象 第二种、通过newFixedThreadPool获取线程池对象 第三种、通过newSingleThreadExecutor获取线程池对象 关闭线程方法：shutdown和shutdownNow的区别 三种创建线程池的
java中用Executor代替Thread的四大理由
s_156的博客
04-02 387
在组建java程序时候关于任务执行方面第一个要考虑的就是任务边界的划分，即把执行的程序分成合理的任务，理想的情况是这些任务的状态，结果不会影响到其它任务。 以java最擅长的服务器端开发为例子，服务器端要做到两点：高并发（good throughput）、低延迟（good responsiveness）。高并发是服务提供者的需要，我们想让我们的程序承载更多的用户来分担服务器开销；低延迟是用户的需求，用户想尽快的看到服务器对请求的响应结果。同样服务器的任务划分也是比较清晰和明确的：我们可以把用户的一个请求，.
Java多线程:线程池ThreadPoolExecutor和Executors详解(六)
weixin_46204877的博客
05-16 2010
线程池的创建有两种：ThreadPoolExecutor 和 Executors。 线程池不是一个提高系统的并发能力的策略，是一个更好的管理线程的方案。 另外，线程池也提供了许多可调参数和可扩展性接口，以满足不同情境的需要，可以使用更方便的Executors的工厂方法，比如newCachedThreadPool (缓冲线程池，线程池线程个数最多可达Integer.MAX_ VALUE,线程自动回收)、newFixedThreadPool (固定大小的线程池)、newSingleThreadExecutor
Java并发编程中使用Executors类创建和管理线程的用法
09-02
Java并发编程中，`java.util.concurrent.Executors` 类是一个至关重要的工具类，它提供了一系列静态方法，用于创建和管理线程池以及相关的...通过熟练掌握这些用法，开发者可以编写出更加高效和健壮的多线程应用程序。
Java多线程之多线程异常捕捉
09-03
在Java多线程编程中，异常处理是一项关键的机制，特别是在多线程环境下，由于线程的并发执行，处理异常的方式与单线程有所不同。本文将深入探讨Java多线程中的异常捕捉，以及如何有效地在多线程环境中处理异常。 ...
JAVA语言程序设计-第十四章 多线程
03-21
在JAVA语言程序设计中，第十四章主要探讨的是多线程这一核心概念。多线程是Java编程中不可或缺的一部分，它允许程序同时执行多个独立的任务，从而提高应用程序的效率和响应性。在Java中，多线程是通过实现Runnable...
Java多线程详解及示例
最新发布
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
ThreadPoolExecutor详解
weixin_33755554的博客
05-07 357
一、源码分析（基于JDK1.6） 　　ThreadExecutorPool是使用最多的线程池组件，了解它的原始资料最好是从从设计者（Doug Lea）的口中知道它的来龙去脉。在Jdk1.6中，ThreadPoolExecutor直接继承了AbstractExecutorService, 并层级实现了ExecutorService和Executor接口。 1.Executor 　　Execut...
idea 多线程debugger调试并发的方法
thankna的博客
11-25 3073
我是从eclipse迁移到idea，自己摸索多线程调试方法。 1.在断点上【右键】选Thread。 2.开两个线程发送请求（可以从画面上，分别使用两个用户发请求）。 下图中Threads标签下exec-10和exec-5就是两个线程。 如果看不到Threads标签，请参看下面设置。 debugger最右侧小方块按钮点击，下拉勾选Threads。 3.切换线程执行。 现在执行的是红色√的kjqjJs=8这个线程 点击下来列表选择●的线程。 切换成kjqjJs=7的线程。...
Java多线程-Thread、Runnable、Executor
ShermyWang的博客
06-26 782
一、线程与进程进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当程序进入内存运行时，即为线程。进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。    ① 进程是系统进行资源分配的最小单位，也是系统进行资源调度的基本执行单元。    ② 它是程序的一次执行过程。简单点的说“进程是正在运行的程序的实例”。    ③ 每个进程运行在受保护的独...
Executor的三种线程的区别
成长之路
12-16 1299
Java多线程一直是java基础中非常重要的一环，最近自己在复习时，发现对其又有了新的了解，Executor可以很方方便的管理多线程，在这把它的三种不同的线程池贴出来做一个记录，有兴趣的可以看看  Executor package chapter21.task; import java.util.concurrent.ExecutorService; import java.util.co...
java中Executor、ExecutorService、ThreadPoolExecutor介绍
热门推荐
linghu_java的专栏
12-04 11万+
源码非常简单，只有一个execute（Runnable command）回调接口  public interface Executor {     /**      * Executes the given command at some time in the future.  The command      * may execute in a new thread, in
Java中的线程池——3种常用的ThreadPoolExecutor
惟愿无事
12-24 7537
在Executor框架下，利用Executors的静态方法可以创建三种类型的常用线程池。他们可分别对应不同的应用场景，下面来看看这三个线程池。 1 FixedThreadPool 这个线程池可以创建固定线程数的线程池。它的构造源码如下： public static ExecutorService newFixedThreadPool(int nThreads) { r
Java之ThreadPoolExcutor和四种常见的线程池
码莎拉蒂
12-05 4970
一、ThreadPoolExcutors的作用 java提供了ThreadPoolExcutors来创建一个线程池，我们为什么要用线程池呢? 1.降低资源的消耗：通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗 2.提高响应速度：因为线程池中的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行 3.提高线程的可管理性 二、ThreadPoolExecuto...
Java并发包：ExecutorService和ThreadPoolExecutor
charming的专栏
07-12 1万+
文章译自：http://tutorials.jenkov.com/java-util-concurrent/index.html 抽空翻译了一下这个教程的文章，后面会陆续放出，如有不妥，请批评指正。 转自请注明出处。 ExecutorServiceJava.util.concurrent.ExecutorService接口代表一种异步执行机制，它能够在后台执行任务。因此ExecutorSer
java 多线程（ThreadPoolExecutor）
Fred's Note
04-15 101
ThreadPoolExecutor是常用的java线程池实现，之前的项目中也一直有用到，本文记录两个基本的例子和参数设置。 例子1： public class Thread1 { public void ThreadOperation(){ BlockingQueue queue = new LinkedBlockingQueue(); Thread...
Java多线程实现：继承Thread与实现Runnable
`Thread`类的构造函数接受一个`Runnable`对象，这样就可以在不修改`Thread`类的情况下实现多线程。 无论是继承`Thread`还是实现`Runnable`，在运行结果中，你会看到两个线程交替执行，这是因为Java的线程调度策略...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值