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

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

1、处理多任务和处理所有结果

实现等待其他任务完成之后再进行

isDone() ：判断线程是否执行完毕

awaitTermination() : 等待所有任务完成之后调用shutdown()方法

例子： 三个任务执行完之后打印结果

package com.jack;

public class Result {

	private String name;
	private int value;
	
	public String getName() {
		return name;
	}
	public int getValue() {
		return value;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setValue(int value) {
		this.value = value;
	}
	
	
}

package com.jack;

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

public class Task implements Callable<Result> {

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


	@Override
	public Result call() {
		System.out.printf("%s : 字符串\n", this.name);
		
		long duration = (long) (Math.random()*10);
		System.out.printf("%s：等待 %d 秒结果\n", this.name,duration);
		try {
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		int value =0;
		for (int i=0; i<5; i++){
			value += (int)(Math.random()*100);
		}
		Result result = new Result();
		result.setName(this.name);
		result.setValue(value);
		System.out.printf(this.name + "： 结果\n");
		
		return result;
	}

	

}


package com.jack;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newCachedThreadPool();
		
		List<Task> taskList = new ArrayList<>();
		for(int i=0; i<3; i++){
			Task task = new Task("Task"+i);
			taskList.add(task);
		}
			
		List<Future<Result>> resultList =null;
		try{
			//等待所有任务执行完毕才往后走
			resultList = executor.invokeAll(taskList);
			
		}catch (InterruptedException e){
			e.printStackTrace();
		}
		executor.shutdown();
		System.out.printf("Main : 打印结果\n");
		for(int i=0; i<resultList.size(); i++){
			Future<Result> future = resultList.get(i);
			try {
				Result result = future.get();
				System.out.printf(result.getName() + "： " + result.getValue()+"\n");
				
			} catch (InterruptedException | ExecutionException e){
				e.printStackTrace();
			}
		}
	}
}
日志： 

Task0 : 字符串
Task2 : 字符串
Task1 : 字符串
Task0：等待 9 秒结果
Task1：等待 0 秒结果
Task2：等待 9 秒结果
Task1： 结果
Task0： 结果
Task2： 结果
Main : 打印结果
Task0： 273
Task1： 276
Task2： 132


总结：

  • 1、创建一个ExecutorService
  • 2、创建任务List集合
  • 3、创建接受结果List<Future<Result>> 集合
  • 4、executor.invokeAll(taskList) 执行所有任务完成之后才继续后面的代码
  • 5、最后打印结果

2、executor的延迟操作

ScheduledThreadPoolExecutor 周期执行任务

package com.jack;

import java.util.Date;
import java.util.concurrent.Callable;

public class Task implements Callable<String> {

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

	@Override
	public String call() throws Exception {
		System.out.printf("%s: 开始于： %s\n", name, new Date());
		return "Hello, world";
	}

}

package com.jack;

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
	public static void main(String[] args) {
		ScheduledThreadPoolExecutor executor = 
				(ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(1);
		System.out.printf("Main : 开始于 ： %s\n", new Date());
		for (int i=0; i<5; i++){
			Task task = new Task ("Task " + i);
			executor.schedule(task, i+2, TimeUnit.SECONDS);
		}
		executor.shutdown();
		
		try {
			executor.awaitTermination(1, TimeUnit.DAYS);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("Main : 结束于：%s\n", new Date());
	}
}

日志： 

Main : 开始于 ： Wed Aug 16 11:28:19 CST 2017
Task 0: 开始于： Wed Aug 16 11:28:21 CST 2017
Task 1: 开始于： Wed Aug 16 11:28:22 CST 2017
Task 2: 开始于： Wed Aug 16 11:28:23 CST 2017
Task 3: 开始于： Wed Aug 16 11:28:24 CST 2017
Task 4: 开始于： Wed Aug 16 11:28:25 CST 2017
Main : 结束于：Wed Aug 16 11:28:25 CST 2017
总结：

  • 1、创建ScheduledThreadPoolExecutor对象
  • 2、执行executor.schedule(task, i+2, TimeUnit.SECONDS); （第一个参数是任务（不一定是Callable接口，Runnable接口亦可以），第二参数，数值（延迟多少），第三参数单位，（上面显示的秒，也可以是天，小时等等））
  • 3、executor.shutdown();关闭executor

  • 4、executor.awaitTermination(1, TimeUnit.DAYS); 防止Main线程提前退出
  • 5、executor.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);会在没有执行完就直接关闭了executor

3、周期性运行任务

package com.jack;

import java.util.Date;

public class Task implements Runnable {

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

	@Override
	public void run() {
		System.out.printf("%s: 开始于： %s\n", name, new Date());
	}

}
总结：实现Runnable接口而不是Callable接口 

package com.jack;

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
	public static void main(String[] args) {
		ScheduledThreadPoolExecutor executor = 
				(ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(1);
		
		System.out.printf("Main : 开始于 ： %s\n", new Date());
			Task task = new Task ("Task ");
		ScheduledFuture<?> result=	executor.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);
		for (int i=0; i<20; i++){
			System.out.printf("Main: 延迟: %d\n", result.getDelay(TimeUnit.MILLISECONDS));
			try {
				TimeUnit.MILLISECONDS.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		executor.shutdown();
		
		try {
			TimeUnit.SECONDS.sleep(5);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("Main : 结束于：%s\n", new Date());
	}
}

日志：


总结：

  • 1、ScheduledFuture<?> result=executor.scheduleAtFixedRate(task,1, 2, TimeUnit.SECONDS);
  • 第一个参数：实现Runnable的实例
  • 第二个参数：表示初始化延迟
  • 第三个参数：表示延迟的间隔时间
  • 第四个参数：单位（上面实例代表是秒）
  • 2、result.getDelay(TimeUnit.MILLISECONDS) 获取对象的延迟时间值
  • 3、如果你取消executor.shutdown(); 会一直按照周期执行下去

4、在executor取消任务

使用Future的cancel() 方法实现

package com.jack;

import java.util.concurrent.Callable;

public class Task implements Callable<String> {


	@Override
	public String call() throws Exception {
		while (true){
			System.out.printf("Task: Test\n");
			Thread.sleep(100);
		}
	}

	
}


package com.jack;

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

public class Main {
	public static void main(String[] args) {
		ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
		Task task = new Task();
		System.out.printf("Main : 执行任务\n");
		Future<String> result = executor.submit(task);
		
		try{
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("Main : 取消这个任务");
		result.cancel(true);
		System.out.printf("Main : 取消了吗？： %s\n", result.isCancelled());
		System.out.printf("Main 完成了：%s\n", result.isDone());
		executor.shutdown();
		System.out.printf("Main : 执行已经完成了\n");
	}
}

日志：


总结：

result.cancel(true)；

往前的
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第7章-JUC多线程v1.1.pdf
02-21
(传入的对象实现了Runnable接口, 这就解释了: 为什么实现多线程的方式中继承Thread类不能使用线程池了) 执行过程: 首先判断任务是否为空, 为空抛出空指针异常, 否则执行下一个判断: 当前线程数量是否小于核心...
线程池ThreadExecutors
Mr_su_9726的博客
09-13 589
import android.os.Handler; import android.os.Looper; import android.support.annotation.NonNull; import android.util.Log; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.LinkedBlockingQueue; i.
第四章 Thread Executors(Executors多线程架构)【上】
往前的娘娘
08-16 386
本章涉及内容： 创建一个executor线程创建一个固定大小executor执行executor任务返回一个结果处理多任务和处理第一个结果处理多任务和处理所有结果延迟之后运行executor周期地运行任务的executor在executor取消任务在executor控制任务完成在executor分开task启动和处理结果控制executor的拒绝的任务 简介： executor是
第四章 Thread Executors(Executors多线程架构)【下】
往前的娘娘
08-16 628
本章涉及内容： 创建一个executor线程创建一个固定大小executor执行executor任务返回一个结果处理多任务和处理第一个结果处理多任务和处理所有结果延迟之后运行executor周期地运行任务的executor在executor取消任务在executor控制任务完成在executor分开task启动和处理结果控制executor的拒绝的任务 1、在executor控制任务完成之
ThreadPoolExecutor
菜鸟爱学习的博客
05-09 342
总结：ThreadPoolExecutor是一个基于池概念的线程执行框架，在并发编程中，合理的配置构造函数中的参数，可以提高应用程序计算能力。
java进阶-线程池 - C - 1 - ThreadPoolExecutor类
qq_33199919的博客
02-17 258
先把图拿出来 这个类想看懂要花点时间： 1.基础知识：位运算，automicInteger概念，volatile意义，基本设计模式 2.里面有几个内部类 CallerRunsPolicy AbortPolicy DiscardPolicy DiscardOldestPolicy ，这几个类呢叫做线程池的饱和策略 3.还有一个worker内部私有类，这个类就厉害了...
[Java]多线程:共享资源同步——不认真看你会后悔的
12-21
在进行多线程开发时最令人头痛的问题估计就是对共享资源的控制了吧，今天就让我们谈一谈这个问题吧。 共享资源顾名思义就是需要被多个线程使用的资源，但是很多情况下我们是不能允许多个线程同时使用这个资源的。这...
ThreadTest.zip
05-17
系统的描述了 Java 中多线程的一些 API 的用法，并且给出对应的代码实例
Java 7 Concurrency Cookbook
09-23
Chapter 4, Thread Executors will teach the readers to delegate the thread management to executors. They allow running, managing, and getting the results of concurrent tasks. Chapter 5, Fork/Join ...
java 线程Sample
03-22
ExecutorService exec=Executors.newFixedThreadPool(2); Thread1 th1 = new Thread1("CRTA"); th1.setDaemon(true); th1.setPriority(MIN_PRIORITY); th1.start(); Thread1 th2 = new Thread1("CRTB");
多线程之线程池ThreadPoolExecutor 源码解析
qq_41050869的博客
06-15 129
线程池 源码 看不懂 顺着网线来打我，ThreadPoolExecutor
线程池原理，创建，实例，Executor和ThreadExecutor的不同
sfjsww66的博客
02-03 198
线程池 为什么要用线程池？ 线程池提供了一种限制和管理资源（包括执行一个任务）。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。 使用线程池的好处： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 线程池中任务实现的接口， Runnable 接口和 C
ThreadPoolExecutor详解，包括工作原理、注意事项、代码演示
菜鸟不会飞
09-17 457
创建线程池的方式：  Executors工厂类     newFixedThreadPool、newSingleThreadExecutor、newCachedThreadPool等 ThreadPoolExecutor   推荐 ScheduledThreadPoolExecutor  阿里JAVA开发手册：        【强制】线程池不允许使用 Executors 去创建，而是通过 ...
ThreadPoolExecutor任务提交与停止流程及底层实现
热门推荐
如何心安理得的在老板眼皮下摸鱼
03-09 1万+
ThreadPoolExecutor底层源码剖析，执行过程、停止过程中所涉及的函数执行过程，如excutor、线程池、Worker、task、shutdown等
Java中的线程池——3种常用的ThreadPoolExecutor
惟愿无事
12-24 7477
在Executor框架下，利用Executors的静态方法可以创建三种类型的常用线程池。他们可分别对应不同的应用场景，下面来看看这三个线程池。 1 FixedThreadPool 这个线程池可以创建固定线程数的线程池。它的构造源码如下： public static ExecutorService newFixedThreadPool(int nThreads) { r
Java线程Executor框架详解与使用
路漫漫，水迢迢
05-26 9506
在HotSpot VM的线程模型中，Java线程被一对一映射为本地操作系统线程。Java线程启动时会创建一个本地操作系统线程；当该Java线程终止时，这个操作系统线程也会被回收，在JVM中我们可以通过-Xss设置每个线程的大小。操作系统会调度所有线程并将它们分配给可用的CPU。 在上层，Java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（Executor框架）将这些任务映射为固定
多线程学习四、线程池概念初步理解代码
北方的木的博客
08-10 199
线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。 using System; using System.Diagnostics; using System.Threading; namespace
ThreadPoolExecutor参数工作方式
踏浪行的博客
06-03 785
corePoolSize 线程池中核心线程数的最大值 maximumPoolSize 线程池中能拥有最多线程数 keepAliveTime 表示空闲线程的存活时间 TimeUnitunit 表示keepAliveTime的单位 workQueue 用于缓存任务的阻塞队列 ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元...
Executors 与 Thread 比较
坐看云起时
04-11 1142
1. new Thread的弊端如下：a. 每次new Thread新建对象性能差。b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机。c. 缺乏更多功能，如定时执行、定期执行、线程中断。2. Executors 优势：a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。...
用Executors.newFixedThreadPool写一段可执行的多线程程序
最新发布
05-12
好的，以下是一个可执行的多线程程序，它使用`Executors.newFixedThreadPool()`方法创建一个固定大小的线程池： ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值