java线程池

最新推荐文章于 2025-06-04 10:45:10 发布
原创 最新推荐文章于 2025-06-04 10:45:10 发布 · 167 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

用户写线程有两种方式

方式一:

 用户自己写线程的并发
    Runnable r=new Runnable(){重写run方法}
	Thread t1=new Thread(r);
	Thread t2=new Thread(r);
	...
 用户要自己控制线程对象的作用域,
 相当于用户自己来管理线程

方式二:

 java给提供一个线程池的概念

线程池:把若干用户线程添加到线程池中,由线程池来管理线程

为什么要使用线程池:

  1. 减少了创建和销毁线程的次数,每个工作线程都可以被重复使用
    或利用,可以并发执行多个任务
  2. 可以根据系统的承受能力,调整线程池中的工作线程的数目
    防止因为消耗过多的内存,而使服务器宕机(down)
    结论:就是java给提供一个写api方法,用于更好的管理线程,
    让程序员主要用于写线程逻辑

线程池的使用:

有一个Executors的线程工具类,此类提供了若干静态方法,
这些静态方法用于生成线程池的对象

  1. Executors.newSingleThreadExecutor();
    创建一个单线程的线程池,这个线程池只有一个线程在工作
    即,单线程执行任务,如果这个唯一的线程因为异常结束,
    那么会有一个新的线程来替代他,因此线程池保证所有的任务
    是按照任务的提交的顺序来执行

  2. Executors.newFilxedThreadPool()
    创建固定大小的线程池,每次提交一个任务就创建一个线程
    直到线程达到线程池的最大大小,线程池的大小一旦达到最大
    就会保持不变,如果某个线程因为执行异常而结束,那么就会
    补充一个新的线程

  3. Executors.newCacheedThreadPool();
    创建一个可以缓冲的线程池,如果线程大小超过了处理的任务
    所需要的线程,那么就回收部分线程,当任务数增加的时候,此
    线程池又可以智能的添加新的线程来处理任务
    此线程池不会对线程池大小做限制,线程池的大小完全依赖操作
    系统能够创建的最大的大小

  4. Executors.newScheduledThreadPool();
    创建一个大小无限制的线程池,此线程池支持定时以及周期性
    的执行任务的需求
    在这里插入图片描述

线程逻辑类:

public class MyThread extends Thread {
	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()+"正在执行...");
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

  1. Executors.newSingleThreadExecutor();
    创建一个单线程的线程池,这个线程池只有一个线程在工作
    即,单线程执行任务,如果这个唯一的线程因为异常结束,
    那么会有一个新的线程来替代他,因此线程池保证所有的任务
    是按照任务的提交的顺序来执行

     import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 /**
  *Executors.newSingleThreadExecutor();
  *创建一个单线程的线程池,这个线程池只有一个线程在工作
  *即,单线程执行任务,如果这个唯一的线程因为异常结束,
  *那么会有一个新的线程来替代他,因此线程池保证所有的任务
  *是按照任务的提交的顺序来执行
  * @author ZhangYang
  *
  */
 public class TestExecutors_SingleThreadExecutor {
 	public static void main(String[] args) {
 		ExecutorService pool=Executors.newSingleThreadExecutor();
 		//创建若干线程
 		MyThread mt1=new MyThread();
 		MyThread mt2=new MyThread();
 		MyThread mt3=new MyThread();
 		MyThread mt4=new MyThread();
 		MyThread mt5=new MyThread();
 		//把线程提交个线程池
 		pool.execute(mt1);
 		pool.execute(mt2);
 		pool.execute(mt3);
 		pool.execute(mt4);
 		pool.execute(mt5);
 		//关闭线程池
 		pool.shutdown();
 	}
 
 }

  2. Executors.newFilxedThreadPool()
    创建固定大小的线程池,每次提交一个任务就创建一个线程
    直到线程达到线程池的最大大小,线程池的大小一旦达到最大
    就会保持不变,如果某个线程因为执行异常而结束,那么就会
    补充一个新的线程

     import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 	/**
 	 * 2.Executors.newFilxedThreadPool()
 	 *  创建固定大小的线程池,每次提交一个任务就创建一个线程
 	 *	直到线程达到线程池的最大大小,线程池的大小一旦达到最大
 	 *	就会保持不变,如果某个线程因为执行异常而结束,那么就会
 	 *	补充一个新的线程
 	 * @author ZhangYang
 	 *
 	 */
 	public class TestExecutors_FixedThreadExecutor {
 		public static void main(String[] args) {
 			ExecutorService pool=Executors.newFixedThreadPool(2);
 			//创建若干线程
 			MyThread mt1=new MyThread();
 			MyThread mt2=new MyThread();
 			MyThread mt3=new MyThread();
 			MyThread mt4=new MyThread();
 			MyThread mt5=new MyThread();
 			//把线程提交个线程池
 			pool.execute(mt1);
 			pool.execute(mt2);
 			pool.execute(mt3);
 			pool.execute(mt4);
 			pool.execute(mt5);
 			//关闭线程池
 			pool.shutdown();
 		}
 	
 	}

  3. Executors.newCacheedThreadPool();
    创建一个可以缓冲的线程池,如果线程大小超过了处理的任务
    所需要的线程,那么就回收部分线程,当任务数增加的时候,此
    线程池又可以智能的添加新的线程来处理任务
    此线程池不会对线程池大小做限制,线程池的大小完全依赖操作
    系统能够创建的最大的大小

     import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 	/**
 	 * Executors.newCacheedThreadPool();
 	 * 创建一个可以缓冲的线程池,如果线程大小超过了处理的任务
 	 *	所需要的线程,那么就回收部分线程,当任务数增加的时候,此
 	 *	线程池又可以智能的添加新的线程来处理任务
 	 *	此线程池不会对线程池大小做限制,线程池的大小完全依赖操作
 	 *	系统能够创建的最大的大小
 	 * @author PC
 	 *
 	 */
 	public class TestExecutors_CachedThreadExecutor {
 		public static void main(String[] args) {
 			ExecutorService pool=Executors.newCachedThreadPool();
 			//创建若干线程
 			MyThread mt1=new MyThread();
 			MyThread mt2=new MyThread();
 			MyThread mt3=new MyThread();
 			MyThread mt4=new MyThread();
 			MyThread mt5=new MyThread();
 			//把线程提交个线程池
 			pool.execute(mt1);
 			pool.execute(mt2);
 			pool.execute(mt3);
 			pool.execute(mt4);
 			pool.execute(mt5);
 			//关闭线程池
 			pool.shutdown();
 		}
 	
 	}

  4. Executors.newScheduledThreadPool();
    创建一个大小无限制的线程池,此线程池支持定时以及周期性的执行任务的需求

     import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 	/**
 	 * Executors.newScheduledThreadPool();
 	 * 创建一个大小无限制的线程池,此线程池支持定时以及周期性
 	 * 的执行任务的需求
 	 * @author ZhangYang
 	 *
 	 */
 	public class TestExecutors_ScheduledThreadExecutor {
 		public static void main(String[] args) {
 			ScheduledExecutorService pool=Executors.newScheduledThreadPool(1);
 			pool.scheduleAtFixedRate(new Runnable(){
 				public void run(){
 					System.out.println("计划执行run");
 				}
 			}, 2000, 5000, TimeUnit.MILLISECONDS);
 			//注意不能关闭线程池
 			//	pool.shutdown();
 		}
 	}

另:手动创建线程池

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 此类演示手动创建线程池
 * @author ZhangYang
 *
 */
public class TestExecutorService {
	public static void main(String[] args) {
		//手动创建了一个线程池
		ThreadPoolExecutor threadPool=new ThreadPoolExecutor(5,10,30L,TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),new RejectedExecutionHandler(){

			@Override
			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
				System.out.println("线程数超过了线程池的容量,拒绝指行任务-->"+r);
				
			}
			
		});
		//把线程放在线程池中,并执行
		threadPool.execute(new TestThread(1));
		threadPool.execute(new TestThread(2));
		threadPool.execute(new TestThread(3));
		threadPool.execute(new TestThread(4));
		threadPool.execute(new TestThread(5));
		threadPool.execute(new TestThread(6));
		threadPool.execute(new TestThread(7));
		threadPool.execute(new TestThread(8));
		threadPool.execute(new TestThread(9));
		threadPool.execute(new TestThread(10));
		threadPool.execute(new TestThread(11));
		threadPool.execute(new TestThread(12));
		threadPool.execute(new TestThread(13));
		threadPool.execute(new TestThread(14));
		threadPool.execute(new TestThread(15));
		threadPool.execute(new TestThread(16));
		threadPool.execute(new TestThread(17));
	}
}
/**
 * 写线程的任务逻辑
 * @author tedu
 *
 */
class TestThread implements Runnable{
	private int num;
	public TestThread(int num){
	   this.num=num;
	}
	@Override
	public void run() {
		try {
			System.out.println("第"+num+"号线程开始执行");
			Thread.sleep(3000);
			System.out.println("第"+num+"号线程开始结束");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}
Java线程池ThreadPoolExecutor背后的秘密与实践
张彦峰的博客
05-12 170万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
Java线程池
WYZFJHH的博客
07-19 1923
Java线程池是并发编程中的一个重要工具，通过合理使用线程池，可以显著提高系统的性能和资源利用率。然而，要充分利用线程池的优势，需要深入理解其原理、掌握其使用方法，并遵循最佳实践。希望本文能为读者在使用Java线程池时提供一些有用的指导和参考。
Java 线程池详解
qq_41591215的博客
07-13 1万+
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
java 线程池
Flying_Fish_roe的博客
11-23 1313
线程池（Thread Pool）是包含多个预创建线程的集合，线程池管理这些线程以执行任务。线程池的核心思想是通过复用一定数量的线程来处理大量的并发任务，避免每次任务到来时都创建和销毁线程的开销，从而提高系统的性能和资源利用率。Java线程池是Java提供的一个用于管理线程的框架，它可以帮助我们更高效地使用线程，提高程序的性能和可维护性。线程池的优点：重复利用线程：线程池可以重复利用已经创建的线程，避免频繁创建和销毁线程的开销。控制并发数量：线程池可以限制并发线程的数量，避免资源过度消耗。
Java线程池七个参数详解
热门推荐
IT小跟班
04-23 30万+
java多线程开发时，常常用到线程池技术，这篇文章是对创建java线程池时的七个参数的详细解释。 从源码中可以看出，线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadF...
java 线程池 参数 详解
T_Y_F_的博客
12-03 3392
java 线程池 参数 详解
Java线程池详解
2301_80720675的博客
04-27 1234
Java线程池通过提供高度可定制的并发控制能力。理解每个参数对系统性能的影响（如队列容量与最大线程数的平衡），能够帮助开发者构建出高吞吐、低延迟的线程管理体系。建议根据具体业务场景，结合监控数据动态调整参数，方能发挥线程池的最大效能。
细说 Java 线程池
肢解生活，直达本质；凡所有相，皆是虚妄。
02-28 1933
线程池状态（runStateOf）和线程池中线程数量（workerCountOf）一起存在了 ctl 成员变量中，通过高位掩码提取状态（runStateOf）、低位掩码提取线程数（workerCountOf）的位运算提高效率（相较于传统条件判断或锁操作）。
Java 线程池原理详解
微笑听雨
06-04 1573
本文全面解析Java线程池的实现原理和使用方法。线程池通过复用线程、控制并发数量、任务队列管理等机制提升系统性能。核心类是ThreadPoolExecutor，包含核心线程数、最大线程数、任务队列等关键参数配置。
java线程池使用后到底要关闭吗
08-26
java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...
java线程池实现批量下载文件
08-25
Java线程池实现批量下载文件 Java线程池实现批量下载文件是指使用Java语言和线程池机制来实现批量下载文件的功能。这种方法可以大幅提高下载速度和效率，特别是当需要下载大量文件时。下面将对Java线程池实现批量...
java线程池源码-cThreadPool:JAVA线程池源码分析与重写
05-25
java线程池源码 cThreadPool 项目描述：对java.util.concurrent包下线程池相关源码进行重新实现，深入研究和学习线程池超时机制、饱和策略、生命周期等知识 ThreadPoolExecutor类下部分方法和内部类介绍： 1、Worker...
java线程池处理多并发，所有进程执行完后再统一处理结果
01-21
java线程池处理多并发，所有进程执行完后再统一处理结果线程池配置类多线程并行demo 线程池配置类 import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation....
对象和类在jvm内存中的存储机制
zhany15188773139的博客
07-09 1960
对象和类在jvm内存中的存储机制 引言: 为什么要有面向对象? a.可以用类组织一批不同类型的数据 b.把现实世界的物和事转换到计算中 现实世界的对象--->计算机中的类-->计算机内存中的对象 要实现面向对象的手段和途径,关键是类 类:就是一个名字 就是一个模型 就是一个数据结构 就是一种数据类型 用类可以在内存中实例化若干对象 jvm把内存分为三...
TCP网络编程之多线程文件上传与下载
zhany15188773139的博客
07-24 938
1. java的IO流 input输出:所有往内存中送数据的都是输入 output输出:所有的从内存中出数据都是输出 能用java.io包的api方法操作的输入输出 内存–>外存(硬盘,光盘,U盘) 本地流输出 内存<–外存 本地流输入 2. 结合Socket网络编程 ** 内存–>网络上 网络流输出 内存<–网络上 网络流输入** **...
集合比较器|集合排序
zhany15188773139的博客
07-16 566
List集合排序: - Collections.sort(List); sort方法的参数是一个List集合,对List集合中的数据排序 如果List集合中的元素,每个元素内部只有一个数据,就直接 比较即可,前提要保证元素中的数据类型,必须重写了compareTo方法 如果List集合中的元素,且每个元素中有很多的其他数据,就需要 把元素的类型实现Comparable接口,并重写CompareTo...
JDK1.8新特性之方法函数式接口+默认方法
zhany15188773139的博客
07-30 485
Function interface 接口就是一个有且只有一个抽象方法 但是可以有非抽象方法 的接口 1.可以用lambda表达式 2.也可以用方法的引用 其实在jdk8之前已经有部分的函数式接口 如: Java.lang.Runnable Java.util.Comparator Java.IO.FileFilter 在jdk8以后,新添加的一个函数式接口 Java.util.Function,...
TCP网络编程之多线程
zhany15188773139的博客
07-24 470
单线程客户端与服务器简单实现: 服务器端: import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.InputStream; import java....
Java 线程池
最新发布
06-26
<think>我们正在讨论Java线程池的使用和原理。根据引用内容，线程池在Java中主要通过ThreadPoolExecutor类实现，从JDK5开始内置支持。线程池的好处包括重用线程、控制并发数量、管理线程生命周期等。常见的线程池类型有：FixedThreadPool（固定容量）、CachedThreadPool（缓存）、SingleThreadExecutor（单线程）、ScheduledThreadPool（定时任务）以及通过ThreadPoolExecutor自定义创建。我们将分步骤讲解：1.线程池的核心原理2.创建线程池的五种方式（包括不推荐的原因）3.重点讲解ThreadPoolExecutor及其参数4.线程池的工作机制（任务提交、执行、拒绝策略等）5.使用示例注意：根据引用[3]和[4]，ThreadPoolExecutor是构建线程池的核心类，因此我们将重点分析。步骤1：线程池的核心原理线程池通过预先创建一定数量的线程并维护它们，避免频繁创建和销毁线程的开销。当有任务提交时，线程池分配空闲线程执行任务；若没有空闲线程，任务将被放入队列等待；当队列满时，根据设定的拒绝策略处理。步骤2：创建线程池的五种方式（引用[3]和[5]）1.newCachedThreadPool：创建一个可缓存的线程池，线程数可无限增加（最大为Integer.MAX_VALUE），空闲线程默认60秒回收。不推荐原因：可能创建过多线程导致OOM。2.newFixedThreadPool：固定大小的线程池，使用无界队列（LinkedBlockingQueue）。不推荐原因：无界队列可能堆积大量任务导致OOM。3.newSingleThreadExecutor：只有一个线程的线程池，同样使用无界队列。不推荐原因同上。4.newScheduledThreadPool：用于定时或周期性任务的线程池。不推荐直接使用的原因是其最大线程数为Integer.MAX_VALUE，可能创建过多线程。5.推荐方式：直接使用ThreadPoolExecutor构造函数创建，可明确指定参数，避免资源耗尽。步骤3：ThreadPoolExecutor的七个参数（引用[3]和[4]）构造方法如下：```javapublicThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,longkeepAliveTime,TimeUnitunit,BlockingQueue<Runnable>workQueue,ThreadFactorythreadFactory,RejectedExecutionHandlerhandler)```1.corePoolSize:核心线程数，即使空闲也不会被回收（除非设置allowCoreThreadTimeOut）2.maximumPoolSize:最大线程数3.keepAliveTime:非核心线程的空闲存活时间4.unit:存活时间单位5.workQueue:任务队列（常用有ArrayBlockingQueue有界队列，LinkedBlockingQueue无界队列，SynchronousQueue同步移交队列）6.threadFactory:线程工厂，用于创建线程7.handler:拒绝策略（当线程池和队列都满时触发）步骤4：线程池的工作机制（任务提交执行流程）1.提交任务后，如果当前线程数小于corePoolSize，则创建新线程执行（即使有空闲线程）。2.如果当前线程数>=corePoolSize，则将任务放入workQueue。3.如果队列已满，且线程数小于maximumPoolSize，则创建新的非核心线程执行。4.如果队列已满且线程数达到maximumPoolSize，则触发拒绝策略。拒绝策略（handler）有四种：-AbortPolicy（默认）:抛出RejectedExecutionException-CallerRunsPolicy:由调用线程执行该任务-DiscardPolicy:丢弃任务，不抛异常-DiscardOldestPolicy:丢弃队列最前面的任务，然后重试步骤5：使用示例（以ThreadPoolExecutor为例）下面是一个自定义线程池的示例：```javaimportjava.util.concurrent.*;publicclassThreadPoolExample{publicstaticvoidmain(String[]args){//创建线程池ThreadPoolExecutorexecutor=newThreadPoolExecutor(2,//核心线程数5,//最大线程数60,//空闲线程存活时间TimeUnit.SECONDS,newArrayBlockingQueue<>(10),//有界队列，容量10Executors.defaultThreadFactory(),newThreadPoolExecutor.AbortPolicy());//拒绝策略：直接抛出异常//提交任务for(inti=0;i<15;i++){finalinttaskId=i;executor.execute(()->{System.out.println("Task"+taskId+"isrunningonthread"+Thread.currentThread().getName());try{Thread.sleep(1000);//模拟任务执行}catch(InterruptedExceptione){e.printStackTrace();}});}//关闭线程池executor.shutdown();}}```注意：实际任务数15个，核心线程2个，最大线程5个，队列容量10个。因此前2个任务会创建核心线程执行，接下来的10个任务放入队列，然后第13、14、15个任务会创建非核心线程（共3个非核心线程，总线程数5个）。如果超过15个任务（比如16个），则会触发拒绝策略。最后，关于线程池的关闭，可以使用shutdown()（等待已提交任务完成）或shutdownNow()（尝试中断所有线程，停止任务）。总结：使用线程池时，推荐直接使用ThreadPoolExecutor构造函数，根据实际需求设置参数，避免使用Executors工厂方法可能导致的资源耗尽问题。相关问题：1.线程池中任务队列有哪些类型？各自特点是什么？2.如何合理设置线程池的核心线程数和最大线程数？3.线程池的拒绝策略有哪些？如何自定义拒绝策略？4.如何监控线程池的运行状态？5.线程池中线程是如何创建的？如何自定义线程工厂？</think>### Java线程池使用指南与原理分析 Java线程池通过`java.util.concurrent`包实现，核心类是`ThreadPoolExecutor`。线程池的核心思想是**复用线程**，避免频繁创建销毁线程的开销。线程池中的线程执行完任务后不会销毁，而是回到池中等待新任务[^2]。 --- #### **一、线程池的创建方式** Java提供5种创建线程池的方法（实际都是`ThreadPoolExecutor`的包装）： 1. **固定大小线程池**（推荐） ```java ExecutorService fixedPool = Executors.newFixedThreadPool(5); // 固定5个线程 ``` - 特点：核心线程数=最大线程数，使用无界队列`LinkedBlockingQueue` - 风险：任务过多时可能导致OOM（队列无限增长）[^5] 2. **缓存线程池**（不推荐） ```java ExecutorService cachedPool = Executors.newCachedThreadPool(); ``` - 特点：线程数无上限（`Integer.MAX_VALUE`），空闲线程60秒回收 - 风险：高并发时可能创建大量线程导致OOM[^3] 3. **单线程池** ```java ExecutorService singlePool = Executors.newSingleThreadExecutor(); ``` - 特点：仅1个线程，保证任务顺序执行 - 风险：同固定线程池（无界队列问题） 4. **定时任务线程池** ```java ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3); ``` 5. **推荐做法：手动创建`ThreadPoolExecutor`** ```java ThreadPoolExecutor customPool = new ThreadPoolExecutor( 4, // 核心线程数 10, // 最大线程数 60, // 空闲线程存活时间（秒） TimeUnit.SECONDS, new ArrayBlockingQueue<>(100), // 有界队列（容量100） new ThreadPoolExecutor.AbortPolicy() // 拒绝策略 ); ``` --- #### **二、核心参数详解（7个关键参数）** ```java public ThreadPoolExecutor( int corePoolSize, // 核心线程数（常驻线程） int maximumPoolSize, // 最大线程数 long keepAliveTime, // 非核心线程空闲存活时间 TimeUnit unit, // 时间单位 BlockingQueue<Runnable> workQueue, // 任务队列 ThreadFactory threadFactory, // 线程工厂 RejectedExecutionHandler handler // 拒绝策略 ) ``` 1. **任务队列类型** - `ArrayBlockingQueue`：**有界队列**（推荐），避免OOM - `LinkedBlockingQueue`：**无界队列**（默认） - `SynchronousQueue`：不存储任务，直接移交线程 2. **拒绝策略**（当队列和线程池全满时触发） - `AbortPolicy`（默认）：抛出`RejectedExecutionException` - `CallerRunsPolicy`：由调用者线程直接执行任务 - `DiscardPolicy`：静默丢弃任务 - `DiscardOldestPolicy`：丢弃队列最旧的任务 --- #### **三、线程池工作原理** 1. **任务提交流程**： - 当线程数 < `corePoolSize`，**创建新线程**执行任务 - 当线程数 >= `corePoolSize`，任务进入**工作队列** - 当队列已满且线程数 < `maximumPoolSize`，**创建临时线程**执行 - 当队列满且线程数达到`maximumPoolSize`，触发**拒绝策略**[^4] 2. **线程回收机制**： - 核心线程默认不回收（除非设置`allowCoreThreadTimeOut(true)`） - 非核心线程空闲超过`keepAliveTime`后自动销毁 --- #### **四、最佳实践** 1. **参数设置建议**： - CPU密集型任务：核心线程数 = CPU核数 + 1 - IO密集型任务：核心线程数 = 2 * CPU核数 - 使用**有界队列**防止资源耗尽 - 拒绝策略选择`CallerRunsPolicy`保证任务不丢失 2. **代码示例**： ```java ThreadPoolExecutor executor = new ThreadPoolExecutor( Runtime.getRuntime().availableProcessors(), // 核心线程数=CPU核数 Runtime.getRuntime().availableProcessors() * 2, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(500), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy() ); // 提交任务 executor.execute(() -> System.out.println("Task running")); // 优雅关闭 executor.shutdown(); executor.awaitTermination(1, TimeUnit.MINUTES); ``` 3. **注意事项**： - 避免使用`Executors`快捷方法（有OOM风险） - 监控线程池状态（通过`getActiveCount()`等方法） - 务必调用`shutdown()`释放资源 --- #### **五、原理解析** - **线程复用**：通过`Worker`类封装线程，循环从队列获取任务执行[^3] - **任务调度**：核心逻辑在`ThreadPoolExecutor.execute()`方法中 - **资源控制**：通过`BlockingQueue`实现生产者-消费者模型 > 线程池的本质是**资源池化技术**（Pooling），通过复用线程降低系统开销，同时提供流量缓冲和容错能力[^4]。 --- ### 相关问题 1. **为什么`FixedThreadPool`使用无界队列会导致OOM？如何避免？** 2. **线程池中`corePoolSize`和`maximumPoolSize`设置不当会产生什么后果？** 3. **如何实现一个自定义拒绝策略（如记录日志或降级处理）？** 4. **线程池的`shutdown()`和`shutdownNow()`有什么区别？** 5. **如何监控线程池的运行状态（如队列积压、活跃线程数）？** [^1]: ThreadPoolExecutor是Java线程池的核心实现类。 [^2]: JDK5开始内置线程池，线程执行后返回池中复用。 [^3]: 手动创建ThreadPoolExecutor可避免资源耗尽风险。 [^4]: 线程池通过队列缓冲和动态扩缩容管理任务。 [^5]: FixedThreadPool的无界队列可能导致OOM。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值