1、为什么要使用线程池
线程池能有效管控线程,统一分配任务,优化资源使用。
2、线程池的参数
创建线程池,在构造一个新的线程池时,必须满足下面的条件:
corePoolSize(线程池基本大小)必须大于或等于0;
maximumPoolSize(线程池最大大小)必须大于或等于1;
maximumPoolSize必须大于或等于corePoolSize;
keepAliveTime(线程存活保持时间)必须大于或等于0;
workQueue(任务队列)不能为空;
threadFactory(线程工厂)不能为空,默认为DefaultThreadFactory类(可以通过线程工厂对不同线程池的线程名称进行设置,以区分产生bug的线程是哪个池的)
handler(线程饱和策略)不能为空,默认策略为ThreadPoolExecutor.AbortPolicy。
线程池参数围绕两个核心,线程和任务。
线程相关的参数:核心线程数,最大线程数,线程存活保持时间,线程饱和策略,线程工厂。
任务相关的参数:任务队列。
3、线程池执行过程
1、创建核心线程处理任务,失败则继续
2、将任务添加到任务队列
3、创建非核心线程处理任务
4、线程饱和策略
4、核心参数分析
4.1 任务队列
4.1.1 直接提交队列SynchronousQueue
设置为SynchronousQueue队列,SynchronousQueue是一个特殊的BlockingQueue,它没有容量,每执行一个插入操作就会阻塞。一般使用SynchronousQueue都会要求为无界(maximumPoolSize=Integer.MAX_VALUE)。
public class PoolTask implements Runnable{
public int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
}
public PoolTask(int i) {
this.i = i;
}
}
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new SynchronousQueue<>());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
threadPoolExecutor.execute(poolTask);
}
threadPoolExecutor.shutdown();
}
执行结果:
4.1.2 有界的任务队列ArrayBlockingQueue
一般使用ArrayBlockingQueue来实现。使用ArrayBlockingQueue有界任务队列,若有新的任务需要执行时,线程池会创建新的线程,直到创建的线程数量达到corePoolSize时,会将新的任务加入到等待队列中。这里等待队列的任务数量设置为2,若等待队列已满,即超过ArrayBlockingQueue初始化的容量,则继续创建线程,直到线程数量达到maximumPoolSize设置的最大线程数量,若大于maximumPoolSize,则执行拒绝策略。
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2));
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
threadPoolExecutor.execute(poolTask);
}
threadPoolExecutor.shutdown();
}
执行结果:
4.1.3 无界的任务队列LinkedBlockingQueue
一般使用LinkedBlockingQueue来实现。使用无界的任务队列,线程池的任务队列可以无限制添加新任务,而线程池创建的最大线程数就是corePoolSize设置的数量,这种情况下maximumPoolSize设置的值是不会生效的,就算等待队列中有许多未执行的任务,线程池的数量达到了corePoolSize的值后也不会增加新的线程。
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
threadPoolExecutor.execute(poolTask);
}
threadPoolExecutor.shutdown();
}
运行结果:
4.1.4 优先任务队列PriorityBlockingQueue
一般使用PriorityBlockingQueue来实现。任务需要实现comparable接口,根据任务的优先级执行任务。
public class PoolTask implements Runnable, Comparable<PoolTask>{
public int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
}
public PoolTask(int i) {
this.i = i;
}
@Override
public int compareTo(PoolTask o) {
//升序排序
return o.getI() - this.getI();
}
}
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new PriorityBlockingQueue<>());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
threadPoolExecutor.execute(poolTask);
}
threadPoolExecutor.shutdown();
}
运行结果:
4.2 线程饱和策略
4.2.1 ThreadPoolExecutor.AbortPolicy
线程池默认的阻塞策略。不执行此任务,而且抛出一个运行时异常(未检查的异常RejectedExecutionException)。
切记:ThreadPoolExecutor.execute需要try catch,否则程序会直接退出。
ThreadPoolExecutor.DiscardPolicy
不执行此任务,而且不抛异常。(是个空方法)
public class PoolTask implements Runnable, Comparable<PoolTask>{
public int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public PoolTask(int i) {
this.i = i;
}
@Override
public int compareTo(PoolTask o) {
//升序排序
return o.getI() - this.getI();
}
}
public class PoolTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
try {
threadPoolExecutor.execute(poolTask);
} catch (Exception e) {
e.printStackTrace();
}
}
threadPoolExecutor.shutdown();
}
}
运行结果:
4.2.2 ThreadPoolExecutor.DiscardOldestPolicy
从队列里删除最老的任务(头部的一个任务),并再次execute 此task。
public class PoolTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
try {
threadPoolExecutor.execute(poolTask);
} catch (Exception e) {
e.printStackTrace();
}
}
threadPoolExecutor.shutdown();
}
}
运行结果:
4.2.3 ThreadPoolExecutor.CallerRunsPolicy
让调用execute方法的线程执行此command,会阻塞入口。
这是个调节机制,既不抛弃任务也不抛出异常,而是将某些任务回退到调用者,让调用者所在的线程去执行。
public class PoolTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
try {
threadPoolExecutor.execute(poolTask);
} catch (Exception e) {
e.printStackTrace();
}
}
threadPoolExecutor.shutdown();
}
}
运行结果:
4.2.4 用户自定义拒绝策略(最常用)
实现RejectedExecutionHandler,并自己定义策略模式
package com.example.dyc.mythreadpool;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
public class MyThreadPolicy implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
if (r instanceof PoolTask){
PoolTask poolTask = (PoolTask) r;
if (poolTask.getI() != 6){
return;
}
System.out.println("获取到六号任务,试图放入队列");
BlockingQueue<Runnable> queue = executor.getQueue();
while (true) {
if (queue.remainingCapacity() > 0) {
queue.add(poolTask);
System.out.println("放入队列成功");
break;
} else {
try {
System.out.println("放入队列失败,继续试图放入");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class PoolTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new MyThreadPolicy());
for (int i = 0; i < 10; i++) {
PoolTask poolTask = new PoolTask(i);
try {
threadPoolExecutor.execute(poolTask);
} catch (Exception e) {
e.printStackTrace();
}
}
threadPoolExecutor.shutdown();
}
}
运行结果:
5 常用线程池类型
java通过Executors提供四种线程池,分别为:
5.1 newCachedThreadPool
newCachedThreadPool创建一个可缓存的无界线程池,如果线程池长度超过处理需要,可灵活回收空线程,若无可回收,则新建线程。当线程池中的线程空闲时间超过60s,则会自动回收该线程,当任务超过线程池的线程数则创建新的线程,线程池的大小上限为Integer.MAX_VALUE,可看作无限大。
5.2 newFixedThreadPool
newFixedThreadPool创建一个指定大小的线程池,可控制线程的最大并发数,超出的线程会在LinkedBlockingQueue阻塞队列中等待。
5.3 newScheduledThreadPool
newScheduledThreadPool线程池支持定时以及周期性执行任务,创建一个corePoolSize为传入参数,最大线程数为整形的最大数的线程池文章来源:https://www.toymoban.com/news/detail-846721.html
5.4 newSingleThreadExecutor
newSingleThreadExecutor创建一个单线程化的线程池,它只有一个线程,用仅有的一个线程来执行任务,保证所有的任务按照指定顺序(FIFO,LIFO,优先级)执行,所有的任务都保存在队列LinkedBlockingQueue中,等待唯一的单线程来执行任务。文章来源地址https://www.toymoban.com/news/detail-846721.html
到了这里,关于Java 线程池 参数的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!