Java常用线程池原理及使用方法解析
作者：与李 发布时间：2022-02-22 17:00:23
一、简介
什么是线程池？
池的概念大家也许都有所听闻，池就是相当于一个容器，里面有许许多多的东西你可以即拿即用。java中有线程池、连接池等等。线程池就是在系统启动或者实例化池时创建一些空闲的线程，等待工作调度，执行完任务后，线程并不会立即被销毁，而是重新处于空闲状态，等待下一次调度。
线程池的工作机制？
在线程池的编程模式中，任务提交并不是直接提交给线程，而是提交给池。线程池在拿到任务之后，就会寻找有没有空闲的线程，有则分配给空闲线程执行，暂时没有则会进入等待队列，继续等待空闲线程。如果超出最大接受的工作数量，则会触发线程池的拒绝策略。
为什么使用线程池？
线程的创建与销毁需要消耗大量资源，重复的创建与销毁明显不必要。而且池的好处就是响应快，需要的时候自取，就不会存在等待创建的时间。线程池可以很好地管理系统内部的线程，如数量以及调度。
二、常用线程池介绍
Java类ExecutorService是线程池的父接口，并非顶层接口。以下四种常用线程池的类型都可以是ExecutorService。
单一线程池 Executors.newSingleThreadExecutor()
内部只有唯一一个线程进行工作调度，可以保证任务的执行顺序（FIFO,LIFO）
package com.test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PoolTest {
public static void main(String[] args) {
// 创建单一线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
List<String> list = new ArrayList<String>();
list.add("first");
list.add("second");
list.add("third");
list.forEach(o -> {
// 遍历集合提交任务
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " : " + o);
try {
// 间隔1s
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
});
}
}
执行结果：
pool-1-thread-1 : first
pool-1-thread-1 : second
pool-1-thread-1 : third
可缓存线程池 Executors.newCachedThreadPool()
如果线程池中有可使用的线程，则使用，如果没有，则在池中新建一个线程，可缓存线程池中线程数量最大为Integer.MAX_VALUE。通常用它来运行一些执行时间短，且经常用到的任务。
package com.test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PoolTest {
public static void main(String[] args) {
// 创建可缓存线程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
List<String> list = new ArrayList<String>();
list.add("first");
list.add("second");
list.add("third");
list.forEach(o -> {
try {
// 间隔3s
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 遍历集合提交任务
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " : " + o);
try {
// 间隔1s
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
});
}
}
执行结果：
pool-1-thread-1 : first
pool-1-thread-1 : second
pool-1-thread-1 : third
因为间隔时间长，下一个任务运行时，上一个任务已经完成，所以线程可以继续复用，如果间隔时间调短，那么部分线程将会使用新线程来运行。
把每个任务等待时间从3s调低至1s:
执行结果：
pool-1-thread-1 : first
pool-1-thread-2 : second
pool-1-thread-1 : third
定长线程池 Executors.newFixedThreadPool(int nThreads)
创建一个固定线程数量的线程池，参数手动传入
package com.test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PoolTest {
public static void main(String[] args) {
// 创建可缓存线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
List<String> list = new ArrayList<String>();
list.add("first");
list.add("second");
list.add("third");
list.add("fourth");
list.forEach(o -> {
try {
// 间隔1s
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 遍历集合提交任务
fixedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " : " + o);
try {
// 间隔1s
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
});
}
}
执行结果：
pool-1-thread-1 : first
pool-1-thread-2 : second
pool-1-thread-3 : third
pool-1-thread-1 : fourth
定时线程池 Executors.newScheduledThreadPool(int corePoolSize)
创建一个定长线程池，支持定时及周期性任务执行
package com.test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class PoolTest {
public static void main(String[] args) {
// 创建定长线程池、支持定时、延迟、周期性执行任务
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " : 1秒后每隔3秒执行一次");
}
}, 1, 3, TimeUnit.SECONDS);
}
}
执行结果：
pool-1-thread-1 : 1秒后每隔3秒执行一次
pool-1-thread-1 : 1秒后每隔3秒执行一次
pool-1-thread-2 : 1秒后每隔3秒执行一次
pool-1-thread-2 : 1秒后每隔3秒执行一次
pool-1-thread-2 : 1秒后每隔3秒执行一次
pool-1-thread-2 : 1秒后每隔3秒执行一次
pool-1-thread-2 : 1秒后每隔3秒执行一次
三、自定义线程池
常用构造函数：
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
参数说明：
1、corePoolSize 核心线程数大小，当线程数<corePoolSize ，会创建线程执行runnable
2、maximumPoolSize 最大线程数， 当线程数 >= corePoolSize的时候，会把runnable放入workQueue中
3、keepAliveTime 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。
4、unit 时间单位
5、workQueue 保存任务的阻塞队列
6、threadFactory 创建线程的工厂
7、handler 拒绝策略
任务执行顺序：
1、当线程数小于corePoolSize时，创建线程执行任务。
2、当线程数大于等于corePoolSize并且workQueue没有满时，放入workQueue中
3、线程数大于等于corePoolSize并且当workQueue满时，新任务新建线程运行，线程总数要小于maximumPoolSize
4、当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。
ThreadPoolExecutor默认有四个拒绝策略：
1、new ThreadPoolExecutor.AbortPolicy() 直接抛出异常RejectedExecutionException
2、new ThreadPoolExecutor.CallerRunsPolicy() 直接调用run方法并且阻塞执行
3、new ThreadPoolExecutor.DiscardPolicy() 直接丢弃后来的任务
4、new ThreadPoolExecutor.DiscardOldestPolicy() 丢弃在队列中队首的任务
缓冲队列BlockingQueue：
BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列，允许两个线程同时向队列一个存储，一个取出操作。在保证并发安全的同时，提高了队列的存取效率。
常用的几种BlockingQueue：
ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。
LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。
PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。
SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。
package com.test;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class PoolTest {
public static void main(String[] args) {
// 工作队列
LinkedBlockingDeque<Runnable> workQueue = new LinkedBlockingDeque<Runnable>();
// 拒绝策略
RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 10, 20, TimeUnit.MILLISECONDS, workQueue, handler);
threadPoolExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println("自定义线程池");
}
});
}
}
来源：https://www.cnblogs.com/yl-space/p/13353003.html
0
投稿猜你喜欢
- Groovy 简介Groovy 是构建在 JVM 上的一个轻量级却强大的动态语言，它结合了 Python、Ruby 和 Smalltalk
一、spring-boot-devtools在pom中直接引入依赖<dependency> <groupId&- 一.总体设计1.寻找规律，公式化的生成坐标系。2.将生成坐标系的关键参数设置为可自定义，从而可变的可以生成自己想要的坐标系。3.将需要绘制的
- 引出泛型我们通过如下的示例，引出为什么泛型的概念。public class Test {public static void main(St
- 本文实例为大家分享了OpenGL实现多段Bezier曲线拼接的具体代码，供大家参考，具体内容如下运行程序的交互方式有点类似corelDraw
- 本文实例讲述了C#实现的XML操作类。分享给大家供大家参考。具体如下：这里讲述了C#写的一个XML操作类，包括读取/插入/修改/删除。usi
- 有看过我之前发表过的C#相关文章分享和阅读过我代码的朋友们可能会在我的代码里面经常看到各种各样的λ表达式动态拼接，C#
- 东西不多，但一般项目够用了。public class RegularUtil { //身份证 publi
- 本文简单介绍如何动态创建接口interface的实现实例对象，包含两个知识点：1.如何获取接口interface的所有实现实例对象？2.如何
- [DllImport("User32.dll", CharSet = CharSet.Auto)]
- 话不多说，请看代码：public FileResult GetExcelFile() {
- 本文给大家分享Android里应用版本更新功能这一块的实现。一个好的应用软件都是需要好的维护，从初出版本到最后精品，这个过程需要版本不停的更
- 运行远程主机上的shell脚本下面的例子是教给大家如何通过java程序，运行远程主机上的shell脚本。（我讲的不是一个黑客学习教程，而是使
- 用java来打包文件生成压缩文件，有两个地方会出现乱码：内容的中文乱码问题：修改sun的源码。使用开源的类库org.apache.tools
- 前言为什么用动静态库我们在实际开发中，经常要使用别人已经实现好的功能，这是为了开发效率和鲁棒性（健壮性）；因为那些功能都是顶尖的工程师已经写
- 网上有很多类似的文章，大多数还是继承listview来实现（主要是listview.addHeaderView()和listview.add
- 最近一个项目是一个基于winform的报告系统，根据一系列的查询参数计算出结果，最终生成一个格式规范的word文档，刚开始数据量不大（500
- Double显示转换int static void Main(string[] args) { Console.WriteLine(&quo
- 前言Go语言定义Go（又称 Golang）是 Google 的 Robert Griesemer，Rob Pike 及 Ken Thomps
- 文件复制和文件上传最近在看文件和IO流相关的东西，写了一些代码，发现这个有很多很有趣的地方。特别是对 File 和 IO 流的使用之后，我对
