线程池的使用_线程池使用-CSDN博客

本文链接：https://blog.csdn.net/Z_DOUBLE_Y/article/details/142351735

一、什么是线程池？

线程池是一种并发处理机制，它预先创建并维护一定数量的工作线程，在接收到任务时，从线程池中分配一个线程去执行，任务完成后线程并不会立即结束，而是返回到线程池中等待下一次任务。这种设计可以避免频繁地创建和销毁线程，提高系统性能，降低资源消耗，并且能够更好地管理线程间的协作。

二、线程池的创建

Executors：创建线程池工具类，创建出几种不同风格的线程池

ExecutorService：标识一个线程池示例

ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制

实例一、


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.atomic.AtomicInteger;

public class Test03 {
	static AtomicInteger counter=new AtomicInteger();
	public static void main(String[] args) {
	
		//固定数目的线程池
		//ExecutorService executorService = Executors.newFixedThreadPool(10);
		
		//动态数目的线程池
		//ExecutorService executorService = Executors.newCachedThreadPool();

        //实现定时周期性任务的线程池
        //ScheduledExecutorService executorService=Executors.newScheduledThreadPool(2);		

		//单线程的线程池
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		
		for (int i = 1; i < 100000; i++) {
			executorService.execute(()->{
				System.out.printf("%s-->执行任务%d\n",Thread.currentThread().getName(),counter.incrementAndGet());
			});
		}
		executorService.shutdown();
	}
}

实例二、


import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test03 {
	public static void main(String[] args) throws InterruptedException {
		ThreadPoolExecutor tPoolExecutor=new ThreadPoolExecutor(10, 10, 0, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>());
		
		//1W次累加
		for(int i=0;i<10000;i++) {
			tPoolExecutor.execute(()->{
				Ops.add();
			});
		}
		//1W次累减
		for(int i=0;i<10000;i++) {
			tPoolExecutor.execute(()->{
				Ops.dec();
			});
		}
		//线程池启动关闭操作
		tPoolExecutor.shutdown();
		//判断线程池是否已经关闭
		if(!tPoolExecutor.awaitTermination(1, TimeUnit.SECONDS)) {
			System.out.println("线程池尚未关闭！");
		}
		System.out.println(Ops.ret);
	}
}

class Ops{
	public static int ret=0;
	
	public static void add() {
		ret =ret+1;
	}
	public static void dec() {
		ret =ret-1;
	}
}

三、线程池的执行流程

首先提交一个新线程任务，线程池中如果有空闲线程，则分配线程任务给空闲线程

如果没有空闲线程，线程池会判断池中“存活线程数量”（keepAliveTime）是否超过核心线程数corePoolSize，

如果没有超过，创建一个新线程（核心线程）来执行新线程任务，

如果超过，线程池会检查任务队列（BlockingQueue）是否满，

如果没满，则将该线程任务放入工作对列进行等待，线程池如果出现空闲线程，将从工作对列中按照先进先出的规则取出一个线程任务并分配执行

如果满了，检查线程数量是否达到最大线程数maximumPoolSize，

没达到，就创建一个新线程（非核心线程）来执行新线程任务，

如果当前“存活线程数”达到最大线程数maximumPoolSize，线程池就直接执行拒绝策略（RejectedExecutionHandler）处理新线程任务

四、线程池的类型

Java核心类库提供的几种常用的线程池，创建方法被封装在Exectors工具类中

Executors.newFixedThreadPool(10)：线程数固定的线程池

核心线程数和最大线程数一致

工作队列：LinkedBlockingQueue

非核心线程空闲存活时间：0秒

使用场景：适用于处理CPU密集型的任务，确保CPU在长期被工作线程使用的情况下，尽可能少的分配线程，适用于长期的任务

Executors.newCachedThreadPool()：线程数根据任务动态调整的线程池

核心线程数：0

最大线程数：Integer.MAX_VALUE

工作队列：SynchronousQueue同步对列

非核心线程空闲存活时间：60秒

使用场景：用于并发执行大量短期的小任务

Executors.newSingleThreadExecutor()：仅提供一个单线程的线程池

核心线程数：1

最大线程数：1

工作队列：LinkedBlockingQueue

非核心线程空闲存活时间：0秒

使用场景：适用于串行执行任务的场景，将任务按顺序执行

Executors.newScheduledThreadPool(2)：能实现定时，周期性任务的线程池

核心线程数：corePoolSize

最大线程数：Integer.MAX_VALUE

工作队列：DelayedWorkQueue

非核心线程空闲存活时间：0秒

使用场景：周期性执行任务，并且需要限制线程数量的需求场景