线程池如何创建线程_创建线程池的七个参数

线程池如何创建线程_创建线程池的七个参数Executors如何创建线程池?Executors类是从JDK1.5开始就新增的线程池创建的静态工厂类,它就是创建线程池的,但是很多的大厂已经不建议使用该类去创建线程池。原因在于,该类创建的很多线程池的内部使用了无界任务队列,在并发量很大的情况下会导致JVM抛出OutOfMemoryError,直接让JVM崩溃,影响严重。但是Executors类究竟是如何使用…

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

Executors如何创建线程池?

Executors 类是从 JDK 1.5 开始就新增的线程池创建的静态工厂类,它就是创建线程池的,但是很多的大厂已经不建议使用该类去创建线程池。原因在于,该类创建的很多线程池的内部使用了无界任务队列,在并发量很大的情况下会导致 JVM 抛出 OutOfMemoryError,直接让 JVM 崩溃,影响严重。

 

但是 Executors 类究竟是如何使用的?

1. newFixedThreadPool,创建定长线程池,每当提交一个任务就创建一个线程,直到达到线程池的最大数量,这时线程数量不再变化,当线程发生错误结束时,线程池会补充一个新的线程。

package constxiong.concurrency.a011;

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

/**
 * 测试创建定长线程池
 * @author ConstXiong
 */
public class TestNewFixedThreadPool {

	public static void main(String[] args) {
		//创建工作线程数为 3 的线程池,每当提交一个任务就创建一个线程,直到达到线程池的最大数量,这时线程数量不再变化,当线程发生错误结束时,线程池会补充一个新的线程
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		//提交 6 个任务
		for (int i = 0; i < 6; i++) {
			final int index = i;
			fixedThreadPool.execute(() -> {
				try {
					//休眠 3 秒
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + " index:" + index);
			});
		}
		
		try {
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("4秒后...");
		
		//关闭线程池后,已提交的任务仍然会执行完
		fixedThreadPool.shutdown();
	}
	
}

打印结果:

pool-1-thread-2 index:1
pool-1-thread-3 index:2
pool-1-thread-1 index:0
4秒后...
pool-1-thread-1 index:4
pool-1-thread-3 index:5
pool-1-thread-2 index:3

 

2. newCachedThreadPool,创建可缓存的线程池,如果线程池的容量超过了任务数,自动回收空闲线程,任务增加时可以自动添加新线程,线程池的容量不限制。

package constxiong.concurrency.a011;

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

/**
 * 测试创建可缓存的线程池
 * @author ConstXiong
 */
public class TestNewCachedThreadPool {
	
	public static void main(String[] args) {
		//创建可缓存的线程池,如果线程池的容量超过了任务数,自动回收空闲线程,任务增加时可以自动添加新线程,线程池的容量不限制
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

		for (int i = 0; i < 6; i++) {
			final int index = i;
			cachedThreadPool.execute(() -> {
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + " index:" + index);
			});
		}
		
		try {
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("4秒后...");
		
		cachedThreadPool.shutdown();
		
	}
	
}

打印结果可以看出,创建的线程数与任务数相等

pool-1-thread-1 index:0
pool-1-thread-3 index:2
pool-1-thread-6 index:5
pool-1-thread-4 index:3
pool-1-thread-5 index:4
pool-1-thread-2 index:1
4秒后...

 

3. newScheduledThreadPool,创建定长线程池,可执行周期性的任务。

package constxiong.concurrency.a011;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 测试创建定长线程池,可执行周期性的任务
 * @author ConstXiong
 */
public class TestNewScheduledThreadPool {

	public static void main(String[] args) {
		//创建定长线程池,可执行周期性的任务
		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
		
		for (int i = 0; i < 3; i++) {
			final int index = i;
			//scheduleWithFixedDelay 固定的延迟时间执行任务; scheduleAtFixedRate 固定的频率执行任务
			scheduledThreadPool.scheduleWithFixedDelay(() -> {
					System.out.println(Thread.currentThread().getName() + " index:" + index);
			}, 0, 3, TimeUnit.SECONDS);
		}
		
		try {
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("4秒后...");
		
		scheduledThreadPool.shutdown();

	}
}

打印结果:

pool-1-thread-1 index:0
pool-1-thread-3 index:2
pool-1-thread-2 index:1
pool-1-thread-1 index:0
pool-1-thread-2 index:1
pool-1-thread-3 index:2
4秒后...

 

4. newSingleThreadExecutor,创建单线程的线程池,线程异常结束,会创建一个新的线程,能确保任务按提交顺序执行。

package constxiong.concurrency.a011;

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

/**
 * 测试单线程的线程池
 * @author ConstXiong
 */
public class TestNewSingleThreadExecutor {
	
	public static void main(String[] args) {
		//单线程的线程池,线程异常结束,会创建一个新的线程,能确保任务按提交顺序执行
		ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
		
		//提交 3 个任务
		for (int i = 0; i < 3; i++) {
			final int index = i;
			singleThreadPool.execute(() -> {
				
				//执行第二个任务时,报错,测试线程池会创建新的线程执行任务三
				if (index == 1) {
					throw new RuntimeException("线程执行出现异常");
				}
				
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + " index:" + index);
			});
		}
		
		try {
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("4秒后...");
		
		singleThreadPool.shutdown();
	}

}

打印结果可以看出,即使任务出现了异常,线程池还是会自动补充一个线程继续执行下面的任务

pool-1-thread-1 index:0
Exception in thread "pool-1-thread-1" 
java.lang.RuntimeException: 线程执行出现异常
	at constxiong.concurrency.a011.TestNewSingleThreadExecutor.lambda$0(TestNewSingleThreadExecutor.java:21)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
4秒后...
pool-1-thread-2 index:2

 

5. newSingleThreadScheduledExecutor,创建单线程可执行周期性任务的线程池。

package constxiong.concurrency.a011;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 测试单线程可执行周期性任务的线程池
 * @author ConstXiong
 */
public class TestNewSingleThreadScheduledExecutor {

	public static void main(String[] args) {
		//创建单线程可执行周期性任务的线程池
		ScheduledExecutorService singleScheduledThreadPool = Executors.newSingleThreadScheduledExecutor();
		
		//提交 3 个固定频率执行的任务
		for (int i = 0; i < 3; i++) {
			final int index = i;
			//scheduleWithFixedDelay 固定的延迟时间执行任务; scheduleAtFixedRate 固定的频率执行任务
			singleScheduledThreadPool.scheduleAtFixedRate(() -> {
				System.out.println(Thread.currentThread().getName() + " index:" + index);
			}, 0, 3, TimeUnit.SECONDS);
		}
		
		try {
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("4秒后...");
		
		singleScheduledThreadPool.shutdown();
	}
	
}

打印机结果可以看出 0-2 任务都被执行了 2 个周期

pool-1-thread-1 index:0
pool-1-thread-1 index:1
pool-1-thread-1 index:2
pool-1-thread-1 index:0
pool-1-thread-1 index:1
pool-1-thread-1 index:2
4秒后...

 

6. newWorkStealingPool,创建任务可窃取线程池,空闲线程可以窃取其他任务队列的任务,不保证执行顺序,适合任务耗时差异较大。

package constxiong.concurrency.a011;

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

/**
 * 测试可任务窃取线程池
 * @author ConstXiong
 */
public class TestNewWorkStealingPool {

	public static void main(String[] args) {
		//创建 4个工作线程的 任务可窃取线程池,如果不设置并行数,默认取 CPU 总核数
		ExecutorService workStealingThreadPool = Executors.newWorkStealingPool(4);
		
		for (int i = 0; i < 10; i++) {
			final int index = i;
			workStealingThreadPool.execute(() -> {
				try {
					//模拟任务执行时间为 任务编号为0 1 2 的执行时间需要 3秒;其余任务200 毫秒,导致任务时间差异较大
					if (index <= 2) {
						Thread.sleep(3000);
					} else {
						Thread.sleep(200);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + " index:" + index);
			});
		}
		
		try {
			Thread.sleep(10000);//休眠 10 秒
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("10秒后...");
	}
	
}

打印结果可以看出,线程 ForkJoinPool-1-worker-0 把3-9的任务都执行完

ForkJoinPool-1-worker-0 index:3
ForkJoinPool-1-worker-0 index:4
ForkJoinPool-1-worker-0 index:5
ForkJoinPool-1-worker-0 index:6
ForkJoinPool-1-worker-0 index:7
ForkJoinPool-1-worker-0 index:8
ForkJoinPool-1-worker-0 index:9
ForkJoinPool-1-worker-1 index:0
ForkJoinPool-1-worker-3 index:2
ForkJoinPool-1-worker-2 index:1
10秒后...

 


【Java面试题与答案】整理推荐

 

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/188760.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • Server.MapPath 的用法说明

    Server.MapPath 的用法说明用法:1.Server.MapPath(“/”)应用程序根目录所在的位置如C:\Inetpub\wwwroot\2.Server.MapPath(“./”)表示所在页面的当前目录3.Server.MapPath(“../”)表示上一级目录4.Server.MapPath(“~/”)表示当前应用级程序的目录,如果是根目录,就是根目录,如果是虚拟目录,就

  • 看完此文,必须明白一致性Hash算法「建议收藏」

    看完此文,必须明白一致性Hash算法「建议收藏」  一致性Hash算法在1997年由麻省理工学院提出的一种分布式哈希(DHT)实现算法,设计目标是为了解决因特网中的热点(HotSpot)问题,初衷和CARP十分相似。一致性Hash修正了CARP使用的简单哈希算法带来的问题,使得分布式哈希(DHT)可以在P2P环境中真正得到应用。  一致性Hash算法提出了在动态变化的Cache环境中,判定哈希算法好坏的四个定义:1、平衡性(Bal…

  • JetBrains Fleet 初体验

    JetBrains Fleet 初体验几天前获得了fleet的体验资格。长话短说,今天就来和你一起看看现在的fleet都有啥先看名字–fleet什么是fleet?n.舰队;捕鱼船队;(一国的)全部军舰,海军看来,JetBrains是想让”OneIDEtocodeitall.”的口号落实,真正的实现一人成军。配合它自带的Distributedmode,前端后端统一管理。或许真正的Monorepo就会来临?再看图标铁灰色底座配合缺了两个缺口和天空蓝淡紫渐变的圆球主体,我猜它…抱歉我看不懂,于是我当场质问了JetBra.

  • linux卸载系统自带jdk_win10自带虚拟机好用吗

    linux卸载系统自带jdk_win10自带虚拟机好用吗注:最小化安装不需要执行!!!rpm-qa|grep-ijava|xargs-n1rpm-e–nodepsrpm-qa:查询所安装的所有rpm软件包grep-i:忽略大小写xargs-n1:表示每次只传递一个参数rpm-e–nodeps:强制卸载软件…

  • 图解Java 垃圾回收机制

    图解Java 垃圾回收机制Java技术体系中所提倡的自动内存管理最终可以归结为自动化地解决了两个问题:给对象分配内存以及回收分配给对象的内存。垃圾回收机制的引入有效地解决了内存的回收问题使得他们在编写程序的时候不再需要考虑内存管理。本文首先着重介绍了判断一个对象是否可以被回收的两种经典算法,并详述了四种典型的垃圾回收算法的基本思想及其直接应用——垃圾收集器,最后结合内存回收策略介绍了内存分配规则。

  • pip源配置

    pip源配置pip源配置1、使用配置文件配置文件[global]trusted-host=mirrors.aliyun.comindex-url=http://mirrors.aliyun.com/pypi/simple/配置文件放置位置Linux下:放在~/.pip/pip.confwindows下:用户文件夹下\pip\pip.ini2、使用命令行临时改变pip源pipinstall-i–trusted-hostpackage例如pipinstall-ihttp://

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号