资讯专栏INFORMATION COLUMN

上云采购季！| 爆款云服务器低至4.6元/月，首单享0.9折

免费试用
首页/文章专栏/线程的状态

线程的状态

zhou_you / 1895人阅读

摘要：运行中，线程状态中并没有这一状态，但是实际执行中是有的可运行状态的线程获得了时间片，执行程序代码。其他阻塞运行的线程发出了请求时，会把该线程置为阻塞状态。当处理完毕时，线程重新转入可运行状态。

Thread.State

首先看JDK中的代码: java.lang.Thread.State

    /**
     * A thread state.  A thread can be in one of the following states:
     * 一个线程的状态，一个线程可以处于以下状态中的某一个状态
     * 
    
     * 
  • {@link #NEW}
    
     *     A thread that has not yet started is in this state.
     *     
    • 
     * 
  • {@link #RUNNABLE}
    
     *     A thread executing in the Java virtual machine is in this state.
     *     
    • 
     * 
  • {@link #BLOCKED}
    
     *     A thread that is blocked waiting for a monitor lock
     *     is in this state.
     *     
    • 
     * 
  • {@link #WAITING}
    
     *     A thread that is waiting indefinitely for another thread to
     *     perform a particular action is in this state.
     *     
    • 
     * 
  • {@link #TIMED_WAITING}
    
     *     A thread that is waiting for another thread to perform an action
     *     for up to a specified waiting time is in this state.
     *     
    • 
     * 
  • {@link #TERMINATED}
    
     *     A thread that has exited is in this state.
     *     
    • 
     * 

     *
     * 

     * A thread can be in only one state at a given point in time.
     * These states are virtual machine states which do not reflect
     * any operating system thread states.
     *
     * @since   1.5
     * @see #getState
     */
    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,
​
        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,
​
        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,
​
        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * 
    
         *   
  • {@link Object#wait() Object.wait} with no timeout
    • 
         *   
  • {@link #join() Thread.join} with no timeout
    • 
         *   
  • {@link LockSupport#park() LockSupport.park}
    • 
         * 

         *
         * 
A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called Object.wait()
         * on an object is waiting for another thread to call
         * Object.notify() or Object.notifyAll() on
         * that object. A thread that has called Thread.join()
         * is waiting for a specified thread to terminate.
         */
        WAITING,
​
        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * 
    
         *   
  • {@link #sleep Thread.sleep}
    • 
         *   
  • {@link Object#wait(long) Object.wait} with timeout
    • 
         *   
  • {@link #join(long) Thread.join} with timeout
    • 
         *   
  • {@link LockSupport#parkNanos LockSupport.parkNanos}
    • 
         *   
  • {@link LockSupport#parkUntil LockSupport.parkUntil}
    • 
         * 

         */
        TIMED_WAITING,
​
        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }
1、新建(New)

新创建了一个线程对象，还未调用start()方法。

2、就绪（Runnable）

线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中 获取cpu 的使用权 。

3、运行中（Running，线程状态中并没有这一状态，但是实际执行中是有的）

可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。

4、限期等待（Timed Waiting）

也可以称作 TIMED_WAITING（有等待时间的等待状态）。

线程主动调用以下方法：

Thread.sleep方法；

Object的wait方法，带有时间；

Thread.join方法，带有时间；

LockSupport的parkNanos方法，带有时间。

5、无限期等待（Waiting）

运行中（Running）的线程执行了以下方法：

Object的wait方法，并且没有使用timeout参数;

Thread的join方法，没有使用timeout参数；

LockSupport的park方法；

Conditon的await方法。

6、阻塞（Blocked）

阻塞状态是指线程因为某种原因放弃了cpu 使用权，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分两种：

同步阻塞：运行(running)的线程进入了一个synchronized方法，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

其他阻塞：运行(running)的线程发出了I/O请求时，JVM会把该线程置为阻塞状态。当I/O处理完毕时，线程重新转入可运行(runnable)状态。

7、结束（Terminated）

线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。

线程状态探秘

jstack查看线程状态
jstack -l 即可察看线程状态，如何使用呢？

随便写一个死循环看一下

public class TestThreadState {
    public static void main(String[] args) {
        for (; ; ) {
​
        }
    }
}

ps -ef|grep TestThreadState，找到对应的pid，jstack -l 即可，如果未输出线程信息，可以尝试使用-F参数来强制输出。

"main" #1 prio=5 os_prio=31 tid=0x00007f8194801800 nid=0x1603 runnable [0x000070000a9b4000]
   java.lang.Thread.State: RUNNABLE
        at org.java.bin.TestThreadState.main(TestThreadState.java:12)
私有云 云服务器 java线程的状态图 java中线程的四种状态 java线程运行状态 java线程状态图

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/73905.html

相关文章

  • [Java并发-7]java的线程小节

    摘要：在领域，实现并发程序的主要手段就是多线程。可运行状态指的是线程可以分配执行。当等待的事件出现了，线程就会从休眠状态转换到可运行状态。导出线程栈，分析线程状态是诊断并发问题的一个重要工具。 在 Java 领域，实现并发程序的主要手段就是多线程。线程是操作系统里的一个概念，虽然各种不同的开发语言如 Java、C# 等都对其进行了封装，但原理和思路都是相同都。Java 语言里的线程本质上就是...

    Sunxb 评论0 收藏0

  • 关于java多线程

    摘要：线程，有时被称为轻量级进程，，是程序执行流的最小单元。由于线程之间的相互制约，致使线程在运行中呈现出间断性。在单个程序中同时运行多个线程完成不同的工作，称为多线程。当状态超时等待线程终止或者超时或者处理完毕时，线程重新转入就绪状态。 java多线程，先要知道什么是线程（Threads），为什么要使用多线程。 线程，有时被称为轻量级进程(Lightweight Process，LWP），...

    sherlock221 评论0 收藏0

  • 深入浅出Java多线程

    摘要：当状态超时等待线程终止或者超时或者处理完毕时，线程重新转入就绪状态。死亡状态线程执行完了或者因异常退出了方法，该线程结束生命周期。线程加入方法，等待其他线程终止。一系列线程以某种顺序启动并不意味着将按该顺序执行。 初遇 Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程，并且每个线程定义了一个独立的执行路径。 多线程是多任务...

    MarvinZhang 评论0 收藏0

  • 一文读懂Java线程状态转换

    摘要：前言本文描述线程线程状态及状态转换，不会涉及过多理论，主要以代码示例说明线程状态如何转换。被终止线程执行完毕正常结束或执行过程中因未捕获异常意外终止都会是线程进入被终止状态。线程执行完毕打印状态。 前言 本文描述Java线程线程状态及状态转换，不会涉及过多理论，主要以代码示例说明线程状态如何转换。 基础知识 1. 线程状态 线程可以有6种状态： New（新建） Runnable（可运...

    summerpxy 评论0 收藏0

  • Java 几种线程状态之间的相互关系

    摘要：线程可以处于以下状态之一尚未启动的线程处于此状态。被阻塞等待监视器锁定的线程处于此状态。无限期等待另一个线程执行特定操作的线程处于此状态。已退出的线程处于此状态。调用的线程处于状态，以使指定的线程终止。 Java Thread 可能处在以下几种状态 Java Doc 里通过一个枚举类型 Enum 来定义。 线程可以处于以下状态之一：showImg(https://segmentfaul...

    lsxiao 评论0 收藏0

  • Java线程的生命周期

    摘要：线程的生命周期线程的生命周期大致可以分为下面五种状态新建状态就绪状态运行状态休眠状态终止状态新建状态，是线程被创建且未启动的状态这里的创建，仅仅是在的这种编程语言层面被创建，而在操作系统层面，真正的线程还没有被创建。 概要 目前CPU的运算速度已经达到了百亿次每秒，甚至更高的量级，家用电脑即使维持操作系统正常运行的进程也会有数十个，线程更是数以百计。 线程是CPU的调度和分派的基本单位...

    ivyzhang 评论0 收藏0

发表评论

登陆后可评论

0条评论

zhou_you

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<