Java线程池中线程的状态简介

最新推荐文章于 2025-05-27 09:42:02 发布
最新推荐文章于 2025-05-27 09:42:02 发布
阅读量333 收藏 2
点赞数
CC 4.0 BY-SA版权
文章标签： java 操作系统 python
原文链接：https://my.oschina.net/xiaoheixiadao/blog/389149
本文详细介绍了Java中线程的各种状态，包括死锁、执行中、等待资源等，并深入探讨了线程池的实现原理及关键参数的作用。通过本文可以了解如何合理配置线程池以提高应用性能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

首先明确一下线程在JVM中的各个状态(JavaCore文件中)

1.死锁，Deadlock（重点关注） 

2.执行中，Runnable（重点关注）   

3.等待资源，Waiting on condition（重点关注） 

4.等待监控器检查资源，Waiting on monitor(eg:如果使用System.out.println等需要分配计算机资源的时候线程会如此等待,主要还需看堆栈)

5.暂停，Suspended

6.对象等待中，Object.wait()

7.阻塞，Blocked（重点关注）  

8.停止，Parked(此状态必须明确,与字面意思不同,主要是指线程空闲时候的状态.如在线程池中,当线程被调用使用后再次放入到池子中,则其状态变为了Parked)

Java基本线程池的实现

public ThreadPoolExecutor(int corePoolSize,  int maximumPoolSize,  long keepAliveTime,  TimeUnit unit, BlockingQueue<Runnable> workQueue) 

参数详解如下:

corePoolSize - 池中所保存的线程数，包括空闲线程.(核心线程)

maximumPoolSize - 池中允许的最大线程数。   

keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲

线程等待新任务的最长时间。   

unit - keepAliveTime 参数的时间单位。   

workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 

方法提交的 Runnable 任务。   

上述参数队列workQueue与corePoolSize,maximumPoolSize的关系为:

如果corePoolSize中的线程使用完,则会使用队列workQueue,队列使用完才会按照maximumPoolSize的大小启动新的线程

对与JavaCore文件的生成针对不同的操作系统使用不同的指令

linux与unix 使用的指令为:jstack -l  pid >>core文件名字

IBM for aix 使用的指令为:kill -3 pid

另外根据测试情况来看.parked状态的线程在linux与unix上体现不出来.只有在aix上parked状态的线程才能体现出来,估计这和不同的JVM的实现有关系

parked状态的由来:只有被使用过的线程再次放入线程池中才被赋予这种状态

转载于:https://my.oschina.net/xiaoheixiadao/blog/389149

多线程学习二十二:多把锁
LHBGXX的博客
05-09 346
多把锁 一间大屋子有两个功能：睡觉、学习，互不相干。现在小南要学习，小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低. 解决方法是准备多个房间（多个对象锁） @Slf4j(topic = "c.test27:") public class Test27 { public static void main(String[] args) { BigRoom bigRoom = new BigRoom(); new Thread(() -> {
【Java线程池与线程状态】线程池分类与最佳实践
weixin_42430947的博客
02-18 1057
解析Java线程池与线程状态变化，结合运行机制与业务场景对照，帮助形成系统性知识，还有线程池分类以及最佳实践。
JVM线程状态，park, wait, sleep, interrupt, yeild 对比
andi8430的博客
12-23 429
---恢复内容开始--- JVM线程状态 NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED BLOCKED是等待获得对象锁 WAITING是调用了wait, sleep, park 操作系统线程状态 sleep， 进入TIMED_WAITING状态，不出让锁 wait,进入TIMED_WA...
线程池状态详解 - 从 RUNNING 到 TERMINATED 的生命周期
weixin_46619605的博客
05-27 1035
线程池状态详解 - 从 RUNNING 到 TERMINATED 的生命周期
Java并发编程：park线程
m0_58535137的博客
08-09 591
park线程
java 线程池 状态_Java线程池中线程的状态简介
weixin_33924571的博客
02-12 775
首先明确一下线程在JVM中的各个状态(JavaCore文件中)1.死锁，Deadlock(重点关注)2.执行中，Runnable(重点关注)3.等待资源，Waiting on condition(重点关注)4.等待监控器检查资源，Waiting on monitor(eg:如果使用System.out.println等需要分配计算机资源的时候线程会如此等待,主要还需看堆栈)5.暂停，Suspend...
正确理解线程WAITING状态
u013433591的博客
12-03 3178
线程如何进入WAITING状态
Java线程池ThreadPoolExecutor背后的秘密与实践
热门推荐
张彦峰的博客
05-12 170万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
java线程池-线程数量到底是几？java线程池-线程数量到底是几？
guanshengg的博客
08-06 1247
java线程池-线程数量到底是几？
Java 线程状态、线程池
01-20
java 线程状态、线程池 1. java 的线程状态 状态 发生条件 NEW 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经在JVM中运行，但是是否运行不确定，看当前线程是否由CPU执行权 ...
Java线程池运行状态监控实现解析
08-25
本文将详细介绍Java线程池运行状态监控实现解析，包括线程池的执行状态监控、线程池的活动线程数、正在排队中的线程数、已经执行完成的线程数、总线程数等。 线程池的执行状态监控是指通过ThreadPoolExecutor类提供...
Thread dump文件抓取和分析(JCA工具)
寻梦友的博客
08-14 3737
Thread dump文件抓取和分析 接下来分析CentOS下怎么抓取Thread dump文件，JCA怎么分析Thread dump文件。 1、CentOS下抓取Thread dump文件 CentOS下命令 ps –ef | grep java kill -3 2、JCA工具分析Thread dump文件 下载好Jca.jar。输入下面命令，打开JCA分析工具 …/bin>java –jar jav433.jar 弹出工具页面，File—>Open Thread dumps，找到文件。
线程最最基础的知识
小烁笔记
09-19 1万+
Java 多线程系列文章第 5 篇。
并发编程之LockSupport的 park 方法及线程中断响应
yemuxiaweiliang的博客
10-27 3033
并发编程之LockSupport的 park 方法及线程中断响应
从JVM源代码的角度一步一步给你讲清楚线程状态的本质以及线程状态的由来
唐欢
03-06 470
从源码可知，根据操作java字段把java状态的偏移量拿出来，java状态的偏移量就是thread中的成员threadstatus（线程状态）的相对于它对象的头部偏移量，然后把状态state放进去，简单说就是C++中操作java的成员变量，把threadstatus的地址拿出来，把线程的state值放进去，把线程状态修改为sleeping。接来敲黑板，考试重点来了， 线程状态是如何修改的，以javaThread::sleep(jlong millis)为例进行解释，这个过程是在C++中进行的。
IBM WebSphere Javacore分析
happyqwz的专栏
11-27 2万+
今天公司的服务器宕机了，抛出很多的javacore 文件，这个文件比较好分析，下面我们讲一下什么是javacore ，以及如何通过分析javaCore文件找出问题。 参考 http://zhangzhiqiangli.blog.163.com/blog/static/459183842012715111949106/ 一、什么是Javacore？ Javacore是Java应用程序在某一
Java线程的生命周期源码详解
CabbageDevil成狂成魔之路
03-09 274
Java线程的生命周期源码详解 Java线程的生命周期 线程的生命周期
【Java】Java线程的6种状态
码小白.
04-17 592
本文目录新建(New)运行(Runable)无限期等待(Waiting)限期等待(Time Waiting)阻塞(Blocker)结束(Terminated) 新建(New) 创建后尚未启动的宣线程处于此·状态 运行(Runable) 包括Runing和Ready，即出于此状态的线程有可能正在执行，也有可能正在等待CPU给分配执行时间 无限期等待(Waiting) 处于此状态的线程不会被分配CPU执行时间，需要等待被其他线程显示唤醒。以下方法会让线程进入无限期等待状态： 没有设置Timeout测试的Ob
Java 线程的 6 种状态
专注分享编程开发与技术进阶干货！
03-11 756
线程的 6 种状态
java 线程池工厂 线程工厂
最新发布
06-19
<think>我们正在讨论Java中的线程工厂（ThreadFactory）和线程池工厂（ThreadPoolFactory）的实现和使用细节。根据引用内容，我们可以从ForkJoinPool中的线程工厂（ForkJoinWorkerThreadFactory）入手，因为引用[1]和[2]提到了ForkJoinPool和ForkJoinWorkerThread。线程工厂（ThreadFactory）是一个用于创建新线程的接口。在Java中，java.util.concurrent.ThreadFactory接口只有一个方法：`ThreadnewThread(Runnabler)`。它的主要目的是允许开发人员自定义线程的创建过程，例如设置线程名称、优先级、守护线程状态等。对于线程池工厂，通常没有标准的接口，但我们可以通过Executors类提供的静态工厂方法来创建不同类型的线程池（如newFixedThreadPool,newCachedThreadPool等）。这些方法内部使用了默认的线程工厂，但也可以传入自定义的ThreadFactory。实现细节：1.自定义ThreadFactory：我们可以实现ThreadFactory接口，在newThread方法中创建线程并设置所需的属性。2.在创建线程池时，可以传入自定义的ThreadFactory。下面我们结合引用内容中的ForkJoinWorkerThreadFactory（这是ForkJoinPool中专用的线程工厂）来举例说明。在引用[1]中，ForkJoinPool的createWorker方法使用了factory（即ForkJoinWorkerThreadFactory）来创建新的工作线程（ForkJoinWorkerThread）。代码片段如下：```javaprivatebooleancreateWorker(){ForkJoinWorkerThreadFactoryfac=factory;Throwableex=null;ForkJoinWorkerThreadwt=null;try{if(fac!=null&&(wt=fac.newThread(this))!=null){wt.start();returntrue;}}catch(Throwablerex){ex=rex;}deregisterWorker(wt,ex);returnfalse;}```这里，factory是ForkJoinWorkerThreadFactory的一个实例，它负责创建新的ForkJoinWorkerThread。然后启动这个线程。ForkJoinWorkerThreadFactory是一个接口，它只有一个方法：```javapublicForkJoinWorkerThreadnewThread(ForkJoinPoolpool);```因此，我们可以通过实现这个接口来自定义ForkJoinWorkerThread的创建。使用示例：1.自定义一个线程工厂（以普通的ThreadFactory为例）：```javaimportjava.util.concurrent.ThreadFactory;publicclassCustomThreadFactoryimplementsThreadFactory{privateintthreadCount=0;@OverridepublicThreadnewThread(Runnabler){threadCount++;Threadthread=newThread(r,"CustomThread-"+threadCount);thread.setDaemon(false);//设置为非守护线程thread.setPriority(Thread.NORM_PRIORITY);returnthread;}}```2.使用自定义线程工厂创建线程池：```javaimportjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;publicclassThreadFactoryExample{publicstaticvoidmain(String[]args){ThreadFactorycustomThreadFactory=newCustomThreadFactory();ExecutorServiceexecutor=Executors.newFixedThreadPool(3,customThreadFactory);//提交任务executor.submit(()->System.out.println("Taskexecutedby"+Thread.currentThread().getName()));executor.shutdown();}}```对于ForkJoinPool，我们可以自定义ForkJoinWorkerThreadFactory：```javaimportjava.util.concurrent.ForkJoinPool;importjava.util.concurrent.ForkJoinWorkerThread;publicclassCustomForkJoinWorkerThreadFactoryimplementsForkJoinWorkerThreadFactory{@OverridepublicForkJoinWorkerThreadnewThread(ForkJoinPoolpool){returnnewCustomForkJoinWorkerThread(pool);}}classCustomForkJoinWorkerThreadextendsForkJoinWorkerThread{publicCustomForkJoinWorkerThread(ForkJoinPoolpool){super(pool);//设置线程名称等setName("CustomForkJoinWorker-"+this.getPoolIndex());}}```然后使用这个工厂创建ForkJoinPool：```javaForkJoinPool.ForkJoinWorkerThreadFactoryfactory=newCustomForkJoinWorkerThreadFactory();ForkJoinPoolpool=newForkJoinPool(Runtime.getRuntime().availableProcessors(),factory,null,false);```注意事项：-在自定义线程时，要注意线程的命名，这样便于调试和监控。-可以设置线程的异常处理器（UncaughtExceptionHandler）来处理线程中未捕获的异常。-对于ForkJoinPool，我们通常不需要直接创建线程工厂，因为默认的已经足够，但在需要特殊控制（如设置线程上下文类加载器）时，自定义工厂很有用。引用说明：-引用[1]展示了ForkJoinPool中createWorker方法使用线程工厂创建线程的过程[^1]。-引用[2]说明了ForkJoinPool中每个工作线程有自己的任务队列以及工作窃取机制[^2]。-引用[3]展示了ForkJoinTask的使用（如Fibonacci任务），但未直接涉及线程工厂[^3]。-引用[4]是关于邮件导出的性能优化，与线程工厂无关[^4]。因此，我们主要参考了引用[1]和[2]来阐述ForkJoinPool中线程工厂的使用。相关问题：1.线程工厂（ThreadFactory）在Java并发编程中有什么作用？2.如何为不同的线程池（如ThreadPoolExecutor、ForkJoinPool）提供自定义的线程工厂？3.在自定义线程工厂时，有哪些常见的配置项（如线程名称、优先级、守护状态）？4.线程工厂在异常处理方面可以做什么？</think>### Java线程工厂与线程池工厂的实现与使用 #### 一、线程工厂（ThreadFactory） 线程工厂是`java.util.concurrent.ThreadFactory`接口，用于**自定义线程创建过程**。核心方法是： ```java Thread newThread(Runnable r); ``` **实现示例**： ```java import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicInteger; public class CustomThreadFactory implements ThreadFactory { private final String namePrefix; private final AtomicInteger threadCount = new AtomicInteger(1); public CustomThreadFactory(String poolName) { this.namePrefix = "pool-" + poolName + "-thread-"; } @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, namePrefix + threadCount.getAndIncrement()); thread.setDaemon(false); // 非守护线程 thread.setPriority(Thread.NORM_PRIORITY); // 默认优先级 thread.setUncaughtExceptionHandler((t, e) -> System.err.println("Uncaught exception in " + t.getName() + ": " + e)); return thread; } } ``` **使用场景**： 1. **线程命名**：便于日志跟踪（如`pool-1-thread-2`） 2. **守护线程控制**：避免主线程退出时意外终止 3. **异常处理**：统一捕获未处理异常 4. **线程优先级设置**：区分关键任务 #### 二、线程池工厂 Java通过`Executors`类提供**线程池工厂方法**，内部使用`DefaultThreadFactory`： **常用工厂方法**： ```java // 固定大小线程池（使用自定义线程工厂） ExecutorService fixedPool = Executors.newFixedThreadPool( 4, new CustomThreadFactory("fixed-pool") ); // 工作窃取线程池（ForkJoinPool） ForkJoinPool forkJoinPool = new ForkJoinPool( Runtime.getRuntime().availableProcessors(), new CustomForkJoinThreadFactory(), // 需实现ForkJoinWorkerThreadFactory null, false ); ``` #### 三、ForkJoinPool的线程工厂实现 引用[1]中的`createWorker()`方法展示了ForkJoinPool如何通过线程工厂创建工作线程[^1]： ```java private boolean createWorker() { ForkJoinWorkerThreadFactory fac = factory; ForkJoinWorkerThread wt = null; try { if (fac != null && (wt = fac.newThread(this)) != null) { wt.start(); // 启动工作线程 return true; } } catch (Throwable ex) { deregisterWorker(wt, ex); // 异常处理 } return false; } ``` **自定义ForkJoin线程工厂**： ```java import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinWorkerThread; public class CustomForkJoinThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFactory { @Override public ForkJoinWorkerThread newThread(ForkJoinPool pool) { return new CustomForkJoinWorkerThread(pool); } } class CustomForkJoinWorkerThread extends ForkJoinWorkerThread { protected CustomForkJoinWorkerThread(ForkJoinPool pool) { super(pool); // 设置线程名称/上下文等 setName("fj-worker-" + this.getPoolIndex()); } } ``` #### 四、关键设计原理 1. **工作窃取（Work-Stealing）** 引用[2]说明：每个工作线程有自己的任务队列，空闲时会窃取其他队列任务（FIFO顺序）[^2]，提升CPU利用率。 2. **递归任务拆分** 如引用[3]的`Fibonacci`示例，通过`fork()`分解任务，`join()`合并结果[^3]： ```java class Fibonacci extends RecursiveTask<Integer> { protected Integer compute() { if (n <= 1) return n; Fibonacci f1 = new Fibonacci(n - 1); f1.fork(); // 异步执行子任务 Fibonacci f2 = new Fibonacci(n - 2); return f2.compute() + f1.join(); // 合并结果 } } ``` 3. **资源控制** - 通过线程工厂限制线程数量 - 避免过度拆分任务（如斐波那契例子的递归深度） #### 五、最佳实践 1. **命名规范**：线程名称包含池标识，便于监控 2. **异常处理**：防止未捕获异常导致线程退出 3. **上下文传递**：在`newThread()`中设置线程上下文（如类加载器、安全策略） 4. **避免阻塞**：ForkJoinPool任务应避免I/O阻塞 > **注意**：ForkJoinPool适用于计算密集型任务，I/O密集型场景应选用`ThreadPoolExecutor`。 --- ### 相关问题 1. 工作窃取（Work-Stealing）算法如何提升线程池性能？ 2. 如何在自定义线程工厂中实现线程级监控（如任务执行耗时）？ 3. ForkJoinPool与ThreadPoolExecutor的核心区别是什么？ 4. 递归任务拆分时如何避免栈溢出问题？ [^1]: `createWorker()`方法通过线程工厂创建并启动工作线程 [^2]: ForkJoinPool使用工作窃取机制优化任务分配 [^3]: 递归任务通过`fork()`/`join()`实现并行计算
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值