线程池总结_线程池处理进程-CSDN博客

本文链接：https://blog.csdn.net/2401_82742105/article/details/142352182

线程池的执行流程总结：

从创建线程池的参数分析：

1.提交新线程，线程池会在线程池中分配一个空闲线程，用于执行线程任务。

2.参数(int corePoolSize)：核心线程数

如果线程池中不存在空闲线程，则线程池会判断当前“存活的线程数”是否小于核心线程数
如果小于核心线程数，线程池会创建一个新线程(核心线程)去处理新线程任务。

3.参数(BlockingQueue<Runnable> workQueue)：工作队列

如果大于核心线程数，线程池会检查工作队列(workQueue),如果工作队列未满，则将该线程任务放入工作队列进行等待。线程池中如果出现空闲线程，将从工作队列中按照FIFO的规则取出1个线程任务并分配执行。

4.参数(int maximumPoolSize)：最大线程数

如果工作队列已满，则判断线程数是否达到最大线程数maximumPoolSize.

如果当前“存活线程数”没有达到最大线程数maximumPoolSize，则创建一个新线程(非核心线程)执行新线程任务。
如果当前“存活线程数”已经达到最大线程数maximumPoolSize，直接采用拒绝策略处理新线程任务。

线程池的状态：

线程池的状态分为：RUNNING，SHUTDOWN，STOP，TIDYING，TERMINATED

RUNNING：运行状态，线程池一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0.该状态的线程池会接收新任务，并处理工作队列中的任务。

调用线程池的shutdown()方法，可以切换到SHUTDOWN关闭状态
调用线程池的shutdownNow()方法，可以切换到STOP停止状态

SHUTDOWN：关闭状态，该状态的线程池不会接收新任务，但会处理工作队列中的任务；

当工作队列为空时，并且线程池中执行的任务也为空时，线程池进入 TIDYING状态。

STOP：停止状态，该状态下的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在进行中的任务。

当线程池中的任务为空时，进入TIDYING状态；

TIDYING：整理状态，该状态表明所有的任务已经运行终止，记录的任务数量为0；

terminated()执行完毕，进入TERMINATED状态；

TERMINATED：终止状态，该状态表示线程池彻底关闭。

线程池的类型：

FixedThreadPool

线程数固定的线程池，使用Executors.newFixedThreadPool()创建

线程池参数：

核心线程数和最大线程数一致
非核心线程线程空闲存活时间，即keepAliveTime为0
阻塞队列为无界队列LinkedBlockingQueue

public class Test05 {
	public static void main(String[] args) {
		//创建一个固定大小的线程池
		ExecutorService executorService = Executors.newFixedThreadPool(4);
		
		for(int i=0;i<6;i++) {
			executorService.execute(new Task("线程"+i));
		}
		//关闭线程池
		executorService.shutdown();
	}
}
class Task implements Runnable{
	private String taskName;
	public Task(String taskName) {
		this.taskName=taskName;
	}
	@Override
	public void run() {
		System.out.println("启动线程==>"+this.taskName);
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("结束线程<="+this.taskName);
	}	
}

运行结果为：
启动线程==>线程0
启动线程==>线程3
启动线程==>线程2
启动线程==>线程1
结束线程<=线程2
结束线程<=线程1
结束线程<=线程0
结束线程<=线程3
启动线程==>线程5
启动线程==>线程4
结束线程<=线程4
结束线程<=线程5

执行分析：一次性放入6个线程，由于线程池只有固定的4个线程，因此，前4 个任务会同时执行，等到有空闲线程后，才会执行后面的两个任务。

工作机制：
a、提交线程任务

b、如果线程数少于核心线程数，创建核心线程执行任务

c、如果线程数等于核心线程数，把任务添加到LinkedBlockingQueue阻塞队列

d、如果线程执行完任务，去阻塞队列领取任务，继续执行

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

CachedThreadPool

可缓存线程池，线程数根据任务动态调整的线程池，使用Executors.newCacheThreadPool()创建

线程池参数：

核心线程数为0
最大核心线程数为Integer.MAX_VALUE
工作队列是SynchronousQueue同步队列
非核心线程空闲存活是时间为60秒

将线程池改为CachedThreadPool

ExecutorService executorService = Executors.newCachedThreadPool();

执行结果：

启动线程==>线程1
启动线程==>线程3
启动线程==>线程2
启动线程==>线程0
启动线程==>线程4
启动线程==>线程5
结束线程<=线程0
结束线程<=线程3
结束线程<=线程5
结束线程<=线程2
结束线程<=线程1
结束线程<=线程4

执行分析：由于这个线程池的实现会根据任务数量动态调整线程池的大小，所以6个任务可一次性全部同时执行。

工作机制：

a、提交线程任务

b、因为核心线程数为0，所有任务直接添加到SynchronousQueue工作队列

c、判断是否有空闲线程，如果有，就去取出任务执行

d、如果没有空闲线程，就创建一个新线程

e、执行完任务的线程，还可以存活60秒，如果在这期间，接到任务，可以继续存活下去；否则，被销毁。

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

SingleThreadExecutor

单线程化的线程池，使用Executors.newSingleThreadExecutor()创建

线程池参数：

核心线程数为1
最大线程数也为1
阻塞队列是LinkedBlockingQueue
非核心线程数空闲存活时间为0秒

将线程池改为SingleThreadExecutor

ExecutorService executorService = Executors.newSingleThreadExecutor();

执行结果：

启动线程==>线程0
结束线程<=线程0
启动线程==>线程1
结束线程<=线程1
启动线程==>线程2
结束线程<=线程2
启动线程==>线程3
结束线程<=线程3
启动线程==>线程4
结束线程<=线程4
启动线程==>线程5
结束线程<=线程5

执行结果分析：一次只执行一个线程，当该线程彻底执行完毕，再执行下一个线程。

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

ScheduleThreadPool

能实现定时、周期性任务的线程池,，使用Executors.newScheduledThreadPool()创建

线程池参数：

最大线程数为Integer.MAX_VALUE
阻塞队列是DelayedWorkQueue
keepAliveTime为0

将线程池改为ScheduledThreadPool

ExecutorService executorService = Executors.newScheduledThreadPool(3);

延迟3秒钟后，任务只执行1次

executorService.schedule(new Task("线程A"),3,TimeUnit.SECONDS);

延迟2秒钟后，每隔3秒执行一次

executorService.scheduleAtFixedRate(new Task("线程A"), 2, 3, TimeUnit.SECONDS);
executorService.scheduleWithFixedDelay(new Task("线程A"), 2, 3, TimeUnit.SECONDS);

FixedRate和Fixedelay的区别：