使用Executors工厂类创建线程池

最新推荐文章于 2025-03-21 23:29:39 发布
最新推荐文章于 2025-03-21 23:29:39 发布
阅读量1.5k 收藏
点赞数
分类专栏： 并发 多线程 线程池 文章标签： 线程池 Executors
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ApatheCrazyFan/article/details/65968086
版权

接口Executor仅仅是一种规范，是一种声明，是一种定义，并没有实现任何的功能，所以大多数的情况下，需要使用接口的实现类来完成指定的功能，比如ThreadPoolExecutor类就是Executor的实现类，但ThreadPoolExecutor在使用上并不是那么方便，在实例化时需要传入很多歌参数，还要考虑线程的并发数等与线程池运行效率有关的参数，所以官方建议使用Executors工程类来创建线程池对象。

Executors工厂类的结构如下图所示：

类Executors中的方法如下图所示：

TP_1：使用newCachedThreadPool（）方法创建无界线程池

使用Executors类的newCachedThreadPool（）方法创建的是无界线程池，可以进行线程自动回收。所谓的“无界线程池”就是池中存放线程个数是理论上的Integer.MAX_VALUE最大值。

创建实验用的项目Executors_1,类ThreadPool2NewCachedThreadPoolTest.java如下：

package com.yc.semephore_7;

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

public class ThreadPool2NewCachedThreadPoolTest {
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newCachedThreadPool();
		
		executorService.execute(new Runnable(){
			@Override
			public void run() {
				try {
					System.out.println("ThreadA begin:" + System.currentTimeMillis());
					Thread.sleep(1000);
					System.out.println( "A");
					System.out.println("ThreadA end:" + System.currentTimeMillis());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		
		executorService.execute(new Runnable(){
			@Override
			public void run() {
				try {
					System.out.println( "ThreadB begin:" + System.currentTimeMillis());
					Thread.sleep(1000);
					System.out.println("B");
					System.out.println( "ThreadB end:" + System.currentTimeMillis());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
	}


}

运行的某一次结果如下：
从打印的时间来看，A和B几乎是在相同的时间开始begin的，也就是创建了2个线程，2个线程之间是异步运行的。继续 实验，创建新类ThreadPool2NewCachedThreadPoolForTest.java如下： 


package com.yc.semephore_7;

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

public class ThreadPool2NewCachedThreadPoolForTest {
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newCachedThreadPool();
		for(int i = 0; i < 4; i ++){
			executorService.execute(new Runnable(){
				@Override
				public void run() {
					System.out.println( "run ->");
				}
			});
		}
	}
}

运行结果如下：


TP_2：验证newCachedThreadPool（）创建为Thread池

前面的实验都没有验证newCachedThreadPool（）方法创建的是线程池。在本测试中将得到验证。
创建项目Executors_2,类MyThread.java代码如下： 
package com.yc.executors;

public class MyThread implements Runnable{
	private String userName;
	
	public MyThread(String userName){
		this.userName = userName;
	}
	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName() + "userName=" + userName + "  begin->  " + System.currentTimeMillis());
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName() + "userName=" + userName + "  end->  " + System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}

}


类ThreadPool2NewCachedThreadPoolIsTest.java代码如下： 
package com.yc.executors;

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

public class ThreadPool2NewCachedThreadPoolIsTest {
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newCachedThreadPool();
		
		for(int i = 0; i < 8; i ++){
			executorService.execute(new MyThread( ""+(i+1) ) );
		}
	}
}

测试结果如下： 
pool-1-thread-1userName=1  begin->  1490516211122
pool-1-thread-3userName=3  begin->  1490516211122
pool-1-thread-4userName=4  begin->  1490516211122
pool-1-thread-7userName=7  begin->  1490516211122
pool-1-thread-8userName=8  begin->  1490516211123
pool-1-thread-2userName=2  begin->  1490516211123
pool-1-thread-5userName=5  begin->  1490516211123
pool-1-thread-6userName=6  begin->  1490516211123
pool-1-thread-1userName=1  end->  1490516212122
pool-1-thread-7userName=7  end->  1490516212122
pool-1-thread-4userName=4  end->  1490516212122
pool-1-thread-3userName=3  end->  1490516212122
pool-1-thread-8userName=8  end->  1490516212123
pool-1-thread-2userName=2  end->  1490516212123
pool-1-thread-5userName=5  end->  1490516212123
pool-1-thread-6userName=6  end->  1490516212123

说明线程池对象创建是完全成功的，但还没有达到池中线程对象可以服用的效果哟，下面要实现这样的效果。
将ThreadPool2NewCachedThreadPoolIsTest.java代码改成如下所示： 
package com.yc.executors;

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

public class ThreadPool2NewCachedThreadPoolIsTest {
	public static void main(String[] args) throws InterruptedException {
		ExecutorService executorService = Executors.newCachedThreadPool();
		
		for(int i = 0; i < 4; i ++){
			executorService.execute(new MyThread( ""+(i+1) ) );
		}
		
		Thread.sleep(2 * 1000);
		System.out.println("\n\n");
		
		for(int i = 0; i < 4; i ++){
			executorService.execute(new MyThread( ""+(i+1) ) );
		}
	}
}

测试结果如下所示： 
pool-1-thread-1userName=1  begin->  1490516619860
pool-1-thread-4userName=4  begin->  1490516619861
pool-1-thread-2userName=2  begin->  1490516619861
pool-1-thread-3userName=3  begin->  1490516619860
pool-1-thread-3userName=3  end->  1490516620861
pool-1-thread-2userName=2  end->  1490516620861
pool-1-thread-4userName=4  end->  1490516620861
pool-1-thread-1userName=1  end->  1490516620861



pool-1-thread-3userName=1  begin->  1490516621861
pool-1-thread-4userName=2  begin->  1490516621861
pool-1-thread-2userName=4  begin->  1490516621861
pool-1-thread-1userName=3  begin->  1490516621861
pool-1-thread-3userName=1  end->  1490516622861
pool-1-thread-1userName=3  end->  1490516622861
pool-1-thread-4userName=2  end->  1490516622861
pool-1-thread-2userName=4  end->  1490516622861


TP_3:使用newCachedThreadPool（ThreadFactory）定制线程工厂

无界线程池中的Thread类还可以有程序员自己定制，方法newCachedThreadPool（ThreadFactory）就是解决这个问题。
创建项目Executors_3，创建MyThreadFactory,java线程工厂类代码如下： 
package com.yc.executors;

import java.util.concurrent.ThreadFactory;

public class MyThreadFactory implements ThreadFactory{

	@Override
	public Thread newThread(Runnable r) {
		Thread rThread = new Thread(r);
		rThread.setName("定制池中的线程->" + Math.random());
		return rThread;
	}
}

类MyThreadFactoryTest.java代码如下： 
package com.yc.executors;

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

public class MyThreadFactoryTest {
	public static void main(String[] args) {
		MyThreadFactory myThreadFactory = new MyThreadFactory();
		ExecutorService executorService = Executors.newCachedThreadPool(myThreadFactory);
		
		for(int i = 0; i < 8; i ++){
			executorService.execute(new Runnable(){
				@Override
				public void run() {
					System.out.println("我在使用 - " + Thread.currentThread().getName());
				}
			});
		}
	}
}
测试某一次的结果为： 
我在使用 - 定制池中的线程->0.7251183137194371
我在使用 - 定制池中的线程->0.7895540239349206
我在使用 - 定制池中的线程->0.055382936386370485
我在使用 - 定制池中的线程->0.7251183137194371
我在使用 - 定制池中的线程->0.4625204924896881
我在使用 - 定制池中的线程->0.5101540668259192
我在使用 - 定制池中的线程->0.7895540239349206
我在使用 - 定制池中的线程->0.8130499478281913
通过使用自定义的ThreadFactory接口实现类，实现了线程对象的定制型。




TP_4：使用newFixedThreadPool（int）方法创建有界线程池

方法newFixedThreadPool（int）创建的是有界线程池，也就是池中的线程个数可以指定最大数量。
创建项目Executors_3。类MyRunnable.java代码如下： 
package com.yc.executors_1;

public class MyRunnable implements Runnable{
	private String userName;
	
	public MyRunnable(String userName){
		this.userName = userName;
	}
	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName() + " - userName=" + userName + " - begin:" + System.currentTimeMillis());
			Thread.sleep(2 * 1000);
			System.out.println(Thread.currentThread().getName() + " - userName=" + userName + " - end:" + System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

类TPNewFixedThreadPooIntTest.java代码如下： 
package com.yc.executors_1;

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

public class TPNewFixedThreadPoolIntTest {
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		for(int i = 0; i < 5; i ++){
			executorService.execute(new MyRunnable( (i+1) + ""));
		}
	}
}

测试结果如下： 
pool-1-thread-1 - userName=1 - begin:1490520507288
pool-1-thread-3 - userName=3 - begin:1490520507288
pool-1-thread-2 - userName=2 - begin:1490520507288
pool-1-thread-2 - userName=2 - end:1490520509289
pool-1-thread-3 - userName=3 - end:1490520509289
pool-1-thread-2 - userName=4 - begin:1490520509289
pool-1-thread-3 - userName=5 - begin:1490520509289
pool-1-thread-1 - userName=1 - end:1490520509289
pool-1-thread-3 - userName=5 - end:1490520511289
pool-1-thread-2 - userName=4 - end:1490520511289

可以看到池中最多可允许有三个线程同时在线，当thread-2和thread-3 end后立马接着运行。




TP_5：使用newFixedThreadPool（int, ThreadFactory）定制线程工厂

有界线程池中的Thread类还可以有程序员自己定制，方法newFixedThreadPool（int  nThread,  ThreadFactory threadFactory）就是解决这个问题的。
创建项目newFixedThreadPoolFactory，创建MyThreadFactory.java线程工厂类代码如下： 
package com.yc.executors_2;

import java.util.concurrent.ThreadFactory;

public class MyThreadFactory implements ThreadFactory{
	
	@Override
	public Thread newThread(Runnable r) {
		Thread mThread = new Thread(r);
		mThread.setName("定制的有界线程工厂->" + Math.random());
		return mThread;
	}

}
测试类TPNewFixedThreadPoolFactoryTest.java 代码如下： 
package com.yc.executors_2;

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

public class TPNewFixThreadPoolFactoryTest {
	public static void main(String[] args) {
		MyThreadFactory threadFactory = new MyThreadFactory();
		
		ExecutorService executorService = Executors.newFixedThreadPool(3, threadFactory);
		
		for(int i = 5; i > 0; i --){
			executorService.execute(new Runnable(){
				@Override
				public void run() {
					System.out.println("我正在运行-" +Thread.currentThread().getName() );
				}
			});
		}
	}
}


得到某一次的测试结果如下： 
我正在运行-定制的有界线程工厂->0.34551172025115573
我正在运行-定制的有界线程工厂->0.7745731609040991
我正在运行-定制的有界线程工厂->0.6848389479731579
我正在运行-定制的有界线程工厂->0.7745731609040991
我正在运行-定制的有界线程工厂->0.34551172025115573



TP_6：使用newSingleThreadExecutor（）方法创建单一线程池

使用newSingleThreadExecutor（）方法可以创建单一线程池。单一线程池可以实现以队列的方式来执行任务。
创建项目Executors_4，类MyRunnable.java代码如下： 
package com.yc.executors_3;

public class MyRunnable implements Runnable{
	private String StringName;
	
	public MyRunnable(String StringName){
		this.StringName = StringName;
	}
	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName() + " and - StringName=" + StringName + " -begin-> " + System.currentTimeMillis());
			Thread.sleep(1* 1000);
			System.out.println(Thread.currentThread().getName() + " and - StringName=" + StringName + " -end-> " + System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}
类TPNewSingleThreadExecutorTest.java代码如下： 
package com.yc.executors_3;

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


public class TPNewSingleThreadExecutorTest {
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		
		for(int i = 0; i < 3; i ++){
			executorService.execute(new MyRunnable( "" + (i + 1)));
		}
	}
}
测得某一次的结果如下： 
pool-1-thread-1 and - StringName=1 -begin-> 1490522664356
pool-1-thread-1 and - StringName=1 -end-> 1490522665356
pool-1-thread-1 and - StringName=2 -begin-> 1490522665356
pool-1-thread-1 and - StringName=2 -end-> 1490522666356
pool-1-thread-1 and - StringName=3 -begin-> 1490522666356
pool-1-thread-1 and - StringName=3 -end-> 1490522667356
最多只有一个线程在运行！！！。




TP7：使用newSingleThreadExecutor（ThreadFactory）定制线程工厂单一线程池


此方法的使用和前面的newFixedThreadPool（int ,  ThreadFactory）相似。


【异常】使用Executors创建线程池时SonarLint提示异常，Executors.newFixedThreadPool提示手动创建线程池，效果会更好哦。
本本本添哥
07-10 235
由于公司的代码检测平台检测到使用下面这种方式创建线程，从而提示“手动创建线程池，效果会更好哦”
Java高并发编程实战14，强制禁止，线程池不允许使用Executors创建
学Java，找哪吒
10-16 1588
大家好，我是哪吒。在程序开发中，高并发场景越来越多，线程池首当其冲。简单回顾一下：《阿里巴巴 Java 开发手册》强制禁止，线程池不允许使用Executors创建，而是通过ThreadPoolExecutor的方式创建，这样的处理方式能让编写代码的工程师更加明确线程池的运行规则，避免资源耗尽的风险。Executors返回的线程池对象的弊端如下：好吧，昨天，我还通过创建了一个线程池，看来以后要注意了。具体分析以下【说明】中的内容，以FixedThreadPool为例，允许的请求队列长度为Integer.MAX
智能家居项目开发: 设计模式（工厂模式）+ 线程池 + Socket (持续更新中)
weixin_44278698的博客
05-05 4324
智能家居项目开发一、智能家居功能细节拆分控制区：外设区：面向对象类和对象的该概念结构体新玩法二、工厂模式1. 工厂模式的概念2. 工厂模式的实现3. 工厂模式使用及功能验证 一、智能家居功能细节拆分 控制区： 语音识别模块，socket客户端 外设区： 继电器组控制灯，远程终端子系统控制灯，窗帘等，火灾报警，摄像头。 面向对象类和对象的该概念 类：是一种用户定义的引用的数据类型，也称类类型，（结构体） 对象：类的一种具象 struct Animal { char name[128];
JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池
weixin_44715154的博客
04-25 207
JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池 线程池的构造方法： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, Block
通过 Executors 创建线程池
最新发布
ShiYueMemo37329的博客
03-21 440
Executors工厂类：是创建常见线程池的简便方法，包括和等。：提供了更灵活的配置，允许你直接指定核心线程数、最大线程数、任务队列等参数，适用于需要定制化线程池的场景。通过线程池，你可以高效地管理线程，避免频繁的线程创建和销毁，提高应用程序的性能和响应速度。
Executors创建线程池
bigbao_1993
02-25 396
在jdk1.8版本加入WorkStealingPool线程后，通过Executors共可创建5种线程池 newSingleThreadExecutor是创建一个单任务线程池，串行执行所有任务。它只会用唯一的工作线程来执行任务，任务执行顺序按照先进先出（FIFO），如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。 newCachedThreadPool是创建一个缓存线程池，只有非核...
【JavaEE】Executors中常见线程池工厂方法及其使用
p_fly的博客
07-19 995
本文将介绍Executors中常见一些工厂方法。Executors中的工厂方法其实就是对ThreadPoolExecutor的封装，方便使用。
为什么不推荐使用Executors创建线程池？（面试常问）
A_diligent_man的博客
07-15 757
因此，为了更好地控制和管理线程池，推荐使用**ThreadPoolExecutor**类来手动创建线程池，它可以自定义线程名称，还可以根据具体的需求自己设置线程池的参数：例如核心线程数、最大线程数、队列类型、线程工厂等、以及自定义拒绝策略来处理任务无法执行的情况。
【名企大厂面试必问的线程池】---Executors工厂创建线程池【方便你我他】知识总结没有最好只有更好
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
04-21 336
【名企大厂面试必问的线程池】---Executors工厂创建线程池【方便你我他】知识总结没有最好只有更好
线程池---Executors类创建线程池
nn1__2970的博客
05-08 437
Executors静态工厂创建几种常用线程池 Executors类： 提供工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口； 1.创建了一个固定线程数量的线程池，可以控制线程最大并发数，超出的线程会在队列中等待。 它是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是在线程池空闲时，即线程池中没有可运行任务时，它也不会释放工作线...
Executors线程池创建
yygApplication的博客
12-23 197
线程池的理解 ```使用Executors创建线程池的常用3中方式 newFixedThreadPool(int nThreads) 创建固定大小的线程池 newSingleThreadExecutor() 创建只有一个线程的线程池 newCachedThreadPool() 创建一个不限线程数上限的线程池，任何提交的任务都将立即执行 其实底层都是调用ThreadPoolExecutor的构造方...
Java 使用Executors创建线程池
laomei
03-16 519
1.newCachedThreadPool: 返回一个缓存线程池; 如果处理的任务超过线程池中的线程数，并且没有可用的线程时，线程池会创建一个新的线程给一个任务。它会回收旧的线程，为之后使用。ExecutorService service = Executors.newCachedThreadPool();2.newFixedThreadPool: 固定大小的线程池。线程池内线程的数目是固定的，如果
通过Executors静态工厂构建线程池
03-11
可以使用Executors静态工厂构建线程池，例如： ExecutorService executorService = Executors.newFixedThreadPool(10); 这将创建一个固定大小为10的线程池。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值