从头认识java-18.2 基本的线程机制（2）-Executors的使用

最新推荐文章于 2025-03-26 22:50:46 发布
原创 最新推荐文章于 2025-03-26 22:50:46 发布 · 1.5k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文详细介绍了Java中的线程管理工具Executors的使用方法，包括如何创建线程池、控制线程数量、测试不同线程运行时间等。通过实例演示，帮助开发者更好地掌握线程管理技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在前面的章节我们都是直接对Thread进行管理，我们这里解释一下另一个管理Thread的类Executors。

1.例子：

package com.ray.ch17;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	public static void main(String[] args) throws InterruptedException {
		long startTime = System.currentTimeMillis();
		ExecutorService executorService = Executors.newCachedThreadPool();
		CountDownLatch countDownLatch = new CountDownLatch(5);
		for (int i = 5; i < 10; i++) {
			DoneMission doneMission = new DoneMission(i, countDownLatch);
			executorService.execute(doneMission);
		}
		executorService.shutdown();
		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println();
		System.out.println(endTime - startTime);
	}
}

class DoneMission implements Runnable {
	private final int id = index++;
	private int count = 0;
	private static int index = 0;
	private CountDownLatch countDownLatch;

	public DoneMission(int count, CountDownLatch countDownLatch) {
		this.count = count;
		this.countDownLatch = countDownLatch;
	}

	public String leftMission() {
		return "#" + id + "(" + count + ") ";
	}

	@Override
	public void run() {
		while (count-- > 0) {
			System.out.print(leftMission());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Thread.yield();
		}
		countDownLatch.countDown();
	}
}


解释：

（1）运行任务的类跟前面的基本一致

（2）使用Executors.newCachedThreadPool()生成线程池，当需要线程驱动的时候，我们可以到里面拿，它生成的线程数是有系统控制的。


2.对线程的数量做出控制

package com.ray.ch17;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	public static void main(String[] args) throws InterruptedException {
		long startTime = System.currentTimeMillis();
		ExecutorService executorService = Executors.newFixedThreadPool(5);//控制线程的数量
		CountDownLatch countDownLatch = new CountDownLatch(5);
		for (int i = 5; i < 10; i++) {
			DoneMission doneMission = new DoneMission(i, countDownLatch);
			executorService.execute(doneMission);
		}
		executorService.shutdown();
		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println();
		System.out.println(endTime - startTime);
	}
}

class DoneMission implements Runnable {
	private final int id = index++;
	private int count = 0;
	private static int index = 0;
	private CountDownLatch countDownLatch;

	public DoneMission(int count, CountDownLatch countDownLatch) {
		this.count = count;
		this.countDownLatch = countDownLatch;
	}

	public String leftMission() {
		return "#" + id + "(" + count + ") ";
	}

	@Override
	public void run() {
		while (count-- > 0) {
			System.out.print(leftMission());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Thread.yield();
		}
		countDownLatch.countDown();
	}
}

上面的代码只是替换了一句，就可以控制线程的数量，但是我们一般还是建议使用cache的那个，因为它对线程池做出来优化。特别是对于短的异步任务它具有明显优势。


3.测试不同线程运行的时间：

package com.ray.ch17;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	public static void main(String[] args) throws InterruptedException {
		long startTime = System.currentTimeMillis();
		ExecutorService executorService = Executors.newCachedThreadPool();
		CountDownLatch countDownLatch = new CountDownLatch(5);
		for (int i = 5; i < 10; i++) {
			DoneMission doneMission = new DoneMission(i, countDownLatch);
			executorService.execute(doneMission);
		}
		executorService.shutdown();
		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println();
		System.out.println("time:"+(endTime - startTime));
	}
}

class DoneMission implements Runnable {
	private final int id = index++;
	private int count = 0;
	private static int index = 0;
	private CountDownLatch countDownLatch;

	public DoneMission(int count, CountDownLatch countDownLatch) {
		this.count = count;
		this.countDownLatch = countDownLatch;
	}

	public String leftMission() {
		return "#" + id + "(" + count + ") ";
	}

	@Override
	public void run() {
		while (count-- > 0) {
			System.out.print(leftMission());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Thread.yield();
		}
		countDownLatch.countDown();
	}
}

输出：

#0(4) #1(5) #2(6) #3(7) #4(8) #0(3) #1(4) #4(7) #3(6) #2(5) #0(2) #1(3) #3(5) #2(4) #4(6) #0(1) #1(2) #4(5) #3(4) #2(3) #0(0) #1(1) #2(2) #4(4) #3(3) #1(0) #2(1) #3(2) #4(3) #4(2) #3(1) #2(0) #3(0) #4(1) #4(0) 
904


控制为3个线程：

package com.ray.ch17;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	public static void main(String[] args) throws InterruptedException {
		long startTime = System.currentTimeMillis();
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		CountDownLatch countDownLatch = new CountDownLatch(5);
		for (int i = 5; i < 10; i++) {
			DoneMission doneMission = new DoneMission(i, countDownLatch);
			executorService.execute(doneMission);
		}
		executorService.shutdown();
		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println();
		System.out.println(endTime - startTime);
	}
}

class DoneMission implements Runnable {
	private final int id = index++;
	private int count = 0;
	private static int index = 0;
	private CountDownLatch countDownLatch;

	public DoneMission(int count, CountDownLatch countDownLatch) {
		this.count = count;
		this.countDownLatch = countDownLatch;
	}

	public String leftMission() {
		return "#" + id + "(" + count + ") ";
	}

	@Override
	public void run() {
		while (count-- > 0) {
			System.out.print(leftMission());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Thread.yield();
		}
		countDownLatch.countDown();
	}
}

输出：

#0(4) #2(6) #1(5) #1(4) #0(3) #2(5) #0(2) #2(4) #1(3) #1(2) #2(3) #0(1) #0(0) #1(1) #2(2) #1(0) #2(1) #3(7) #3(6) #4(8) #2(0) #3(5) #4(7) #3(4) #4(6) #3(3) #4(5) #4(4) #3(2) #4(3) #3(1) #4(2) #3(0) #4(1) #4(0) 
1504


控制为单线程：

package com.ray.ch17;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	public static void main(String[] args) throws InterruptedException {
		long startTime = System.currentTimeMillis();
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		CountDownLatch countDownLatch = new CountDownLatch(5);
		for (int i = 5; i < 10; i++) {
			DoneMission doneMission = new DoneMission(i, countDownLatch);
			executorService.execute(doneMission);
		}
		executorService.shutdown();
		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println();
		System.out.println(endTime - startTime);
	}
}

class DoneMission implements Runnable {
	private final int id = index++;
	private int count = 0;
	private static int index = 0;
	private CountDownLatch countDownLatch;

	public DoneMission(int count, CountDownLatch countDownLatch) {
		this.count = count;
		this.countDownLatch = countDownLatch;
	}

	public String leftMission() {
		return "#" + id + "(" + count + ") ";
	}

	@Override
	public void run() {
		while (count-- > 0) {
			System.out.print(leftMission());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Thread.yield();
		}
		countDownLatch.countDown();
	}
}

输出：

#0(4) #0(3) #0(2) #0(1) #0(0) #1(5) #1(4) #1(3) #1(2) #1(1) #1(0) #2(6) #2(5) #2(4) #2(3) #2(2) #2(1) #2(0) #3(7) #3(6) #3(5) #3(4) #3(3) #3(2) #3(1) #3(0) #4(8) #4(7) #4(6) #4(5) #4(4) #4(3) #4(2) #4(1) #4(0) 
3503

单线程说白了就像直接在main方法里面使用for来运行的一样。


4.关于shutdown（）（下面的这段话摘自http://my.oschina.net/bairrfhoinn/blog/177639，笔者觉得他解释的已经比较清楚，其实关键是笔者比较懒，不喜欢打字）

为了关闭在 ExecutorService 中的线程，你需要调用 shutdown() 方法。ExecutorService 并不会马上关闭，而是不再接收新的任务，一旦所有的线程结束执行当前任务，ExecutorServie 才会真的关闭。所有在调用 shutdown() 方法之前提交到 ExecutorService 的任务都会执行。 
如果你希望立即关闭 ExecutorService，你可以调用 shutdownNow() 方法。这个方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证的，有可能他们真的被关闭掉了，也有可能它会一直执行到任务结束。


总结：这一章节主要介绍Executors的使用。


这一章节就到这里，谢谢。

-----------------------------------

目录


【项目实战】并发编程之多线程任务批处理通用工具类，实战使用线程池（ExecutorService+CountDownLatch）实现批量发送短信，发送完毕后，方法继续向下走
本本本添哥
03-28 313
使用线程池批量发送短信，当短信发送完毕之后，方法继续向下走。
Java异步判断线程池所有任务是否执行完成的方法
m0_72958694的博客
07-11 1134
本文详细介绍了Java异步判断线程池所有任务是否执行完成的方法，分别介绍了使用ExecutorService和CountDownLatch的方法示例、使用ExecutorService的invokeAll方法和Future列表的方法示例、使用ExecutorService来异步执行多个Callable任务方法示例三个例子，并分别给出了详细的代码示例，直观清晰、一目了然。
多线程 ExecutorService CountDownLatch使用
sinat_34338162的博客
03-16 2022
一 Java通过Executors提供四种线程池，分别为： newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。...
并发工具类：ExecutorService、Future、CountDownLatch与Semaphore（第一章）
m0_61635718的博客
04-04 1338
在当今多核处理器普及的背景下，多线程编程已成为提升软件性能、充分利用硬件资源的关键手段。然而，多线程编程也伴随着一系列复杂问题，如线程同步、资源争抢、死锁等，这些问题若处理不当，将严重影响程序的正确性和稳定性。为此，Java平台通过其强大的并发工具类库为开发者提供了高效且易于使用的解决方案，其中ExecutorService、Future、CountDownLatch与Semaphore尤为突出，它们在Java多线程编程中扮演着至关重要的角色。
多线程 ExecutorService CountDownLatch
维度
07-20 280
package com.hbw.model; public class User { public User(){} public User(int id,String name){ this.id=id; this.name=name; } private int id; private String name; public int get...
并发工具类：ExecutorService、Future、CountDownLatch与Semaphore（第三章）
m0_61635718的博客
04-05 371
CountDownLatch是一种基于计数器的线程同步工具类，它是Java并发包java.util.concurrent中的重要组件。其基本原理是通过维护一个共享的计数器，允许一个或多个线程（通常称为“主线程”）等待其他多个线程（“工作线程”）完成各自指定的任务。
CountDownLatch用法详解
.
03-27 3万+
CountDownLatch用法详解 CountDownLatch使用场景 线程计数器 用于线程执行任务,计数 等待线程结束 用法一: 等待所有的事情都做完 //程序计数器 CountDownLatch countDownLatch = new CountDownLatch(2); //2个线程 ExecutorService executorService = Executors.newFixedThreadPool(2);
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 1056
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
Java多线程(ExecutorService), 等待所有线程执行完毕.
张小凡
08-23 3万+
常用的两种方式: 第一种方式:来自大神cletus的回答, 原文链接 ExecutorService taskExecutor = Executors.newFixedThreadPool(4); while(...) { taskExecutor.execute(new MyTask()); } taskExecutor.shutdown(); try { taskExecutor...
Java线程池ExecutorService和CountDownLatch的简单示例
hanshimeng的博客
04-09 1020
一、导读 CountDownLatch可以保证程序在子线程都执行完毕的情况下再执行主线程。 使用方法：对CountDownLatch对象设置初值，每个线程执行完后调用countDown方法，计数器减1， 当所有线程都执行完毕后，计数器为0，继续执行主线程逻辑。 二、代码示例 package com.hanshimeng.other; import java.util.concurrent.Co...
ExecutorService,CountDownLatch应用示例
liman1002的专栏
06-18 247
public void threadDateTimeGetCurData(LinkedList<File> fileParam, Map paramMap, CountDownLatch latch, LinkedHashMap resultls, LinkedHashMap resultlsonetime, Map timeMap) { for (int i = 0; i < fileParam.size(); i++) { int final...
试用concurrent包下的Executors，ExecutorService，CountDownLatch
lkforce
04-14 603
用concurrent包下的Executors，ExecutorService，CountDownLatch类写了一小段程序，研究了研究这几个类的功能，代码如下： package test; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import ja
并发工具类：ExecutorService、Future、CountDownLatch与Semaphore（第二章）
m0_61635718的博客
04-04 618
Future是Java并发包（java.util.concurrent）中的一个重要接口，它代表异步计算的结果。
总结ExecutorService和CountDownLatch的作用、用法和场景
最新发布
A-Itfuture的博客
03-26 512
【代码】总结ExecutorService和CountDownLatch的作用、用法和场景。
线程池的一些使用
weixin_38972910的博客
04-29 1117
ThreadPoolExecutor: https://www.cnblogs.com/dafanjoy/p/9729358.html
线程池以及多线程调用案例，ExecutorService、CountDownLatch、Future、ConcurrentHashMap、Callable
又是重名了
02-23 273
多线程，ExecutorService，CountDownLatch，Future，ConcurrentHashMap，Callable
Java多线程实战-CountDownLatch模拟压测实现
热门推荐
qq_35716689的博客
03-17 25万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
线程池ExecutorService 及CountDownLatch 并发执行查询接口
lesliehu2158的专栏
07-24 821
public static Map<String ,List<Map<String, Object>>> getMaps(List<String> sqlKeys) throws InterruptedException, ExecutionException{ if(CollectionUtils.isEmpty(sqlKeys)) {...
java多线程，CountDownLatch和ExecutorService的简单应用
withme的博客
04-25 3704
CountDownLatch可以保证程序在子线程都执行完毕的情况下再执行主线程使用方法：对CountDownLatch对象设置初值，每个线程执行完后调用countDown方法，计数器减1，所有线程都执行完毕后，计数器为0，继续执行主线程。代码如下：import java.util.concurrent.CountDownLatch; public class CountDownLatchTest...
提升Java线程执行效率：more-executors性能分析
2. **jucThreadPoolExecutor**：Java并发包中的线程池实现，用于管理线程池中线程的执行，提供灵活的线程管理能力。 3. **易失性（Volatile）字段**：在并发编程中用于确保变量的可见性和禁止指令重排序，但过多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值