精华内容
下载资源
问答
  • 详细介绍了Java线程的6种状态,以及状态之间的转换。

    详细介绍了Java线程的6中状态,以及状态之间的转换。


    本文基于JDK1.8。

    1 线程状态(生命周期)

    1.1 源码中的状态

    关于Java线程的状态,网上说法很多,有五种、六种甚至七种,本文采用Java官方的线程状态分类。

    实际上,官方一共给出了六种线程状态,我们来看看源码便可知:

        public class Thread implements Runnable {
            //线程的状态以枚举的方式定义在Thread类的内部
            /**
             * A thread state.  A thread can be in one of the following states:
             * <ul>
             * <li>{@link #NEW}<br>
             *     A thread that has not yet started is in this state.
             *     </li>
             * <li>{@link #RUNNABLE}<br>
             *     A thread executing in the Java virtual machine is in this state.
             *     </li>
             * <li>{@link #BLOCKED}<br>
             *     A thread that is blocked waiting for a monitor lock
             *     is in this state.
             *     </li>
             * <li>{@link #WAITING}<br>
             *     A thread that is waiting indefinitely for another thread to
             *     perform a particular action is in this state.
             *     </li>
             * <li>{@link #TIMED_WAITING}<br>
             *     A thread that is waiting for another thread to perform an action
             *     for up to a specified waiting time is in this state.
             *     </li>
             * <li>{@link #TERMINATED}<br>
             *     A thread that has exited is in this state.
             *     </li>
             * </ul>
             *
             * <p>
             * 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:
                 * <ul>
                 *   <li>{@link Object#wait() Object.wait} with no timeout</li>
                 *   <li>{@link #join() Thread.join} with no timeout</li>
                 *   <li>{@link LockSupport#park() LockSupport.park}</li>
                 * </ul>
                 *
                 * <p>A thread in the waiting state is waiting for another thread to
                 * perform a particular action.
                 * <p>
                 * For example, a thread that has called <tt>Object.wait()</tt>
                 * on an object is waiting for another thread to call
                 * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
                 * that object. A thread that has called <tt>Thread.join()</tt>
                 * 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:
                 * <ul>
                 *   <li>{@link #sleep Thread.sleep}</li>
                 *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
                 *   <li>{@link #join(long) Thread.join} with timeout</li>
                 *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
                 *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
                 * </ul>
                 */
                TIMED_WAITING,
    
                /**
                 * Thread state for a terminated thread.
                 * The thread has completed execution.
                 */
                TERMINATED;
            }
        }
    

    从源码可以看出,Java语言定义了6种线程状态,作为内部枚举保存在Thread类中。这里我建议大家采用这六种状态,当然也可以按照自己的理解来。下面来解释一下每一种状态。

    1.2 状态解释

    在任意一个时间点,一个线程只能有且只有其中的一种状态,这6种状态分别如下:

    1. 新建(NEW):创建后尚未启动的线程处于这种状态。
    2. 运行(RUNNABLE):调用start()方法,RUNNABLE包括了操作系统线程状态中的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着CPU为它分配执行时间(该线程已经获取了除CPU资源外的其他资源,等待获取CPU 资源后才会真正处于运行状态)。

    官方为什么不将这两种状态分开呢?有种可能是:线程在这Running和Ready两种状态之间的时长太短了,现代cpu采用轮询式时间片调度,大部分线程Running和Ready的时间都非常短暂,因此考虑将这两种状态合并为RUNNABLE状态。

    1. 无限期等待(WAITING):处于这种状态的线程不会被分配CPU执行时间,它们要等待被其他线程显式地唤醒。以下方法会让线程陷入无限期的等待状态:
    1. 没有设置Timeout参数的Object.wait()方法。
    2. 没有设置Timeout参数的Thread.join()方法。
    3. LockSupport.park()方法。
    1. 限期等待(TIMED_WAITING):处于这种状态的线程也不会被分配CPU执行时间,不过无须等待被其他线程显式地唤醒,在一定时间之后它们会由系统自动唤醒。以下方法会让线程进入限期等待状态:
    1. Thread.sleep(long millis)方法。
    2. 设置了Timeout参数的Object.wait()方法。
    3. 设置了Timeout参数的Thread.join()方法。
    4. LockSupport.parkNanos()方法。
    5. LockSupport.parkUntil()方法。
    1. 阻塞(BLOCKED):线程被阻塞了,“阻塞状态”与“等待状态”的区别是:“阻塞状态”在等待着获取到一个排他锁,这个事件将在另外一个线程获得锁的时候可能发生,比如synchronized之外;而“等待状态”则是在获得锁之后,主动释放锁,进入等待一段时间,或者等待唤醒动作的发生。

    2. 结束(TERMINATED):已终止线程的线程状态,线程已经结束执行。

    补充:
    Java将操作系统中的运行和就绪两个状态合并称为运行状态。

    阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态,但是阻塞在java.concurrent包中Lock接口的线程状态却是等待状态,因为java.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法。

    线程状态概述

    2 线程状态转换

    上述6种状态在遇到特定事件发生的时候将会互相转换,它们的转换关系如下图:

    线程转换图

    上图状态的转换和方法已经很明朗了,下面重点说说几种状态转换,以及相关方法补充。

    2.1 进入等待/超时等待

    2.1.1 进入等待状态

    1. LockSupport.park()。
    2. 发生Io阻塞。
    3. suspend(),方法已过时。
    4. public final void wait() 释放锁
    5. public final void join() 释放锁

    2.1.1.1 wait方法的介绍

    wait方法属于object类,wait()方法使当前线程暂停执行并释放锁,让其他线程可以进入synchronized数据块,当前线程被放入对象等待队列中。Wait()方法必须被包含在对应的synchronized语句中,无论是wait()方法还是notify()方法都需要获取目标对象的一个监视器。

    当调用notify()方法后,将从对象的等待队列中移走一个任意的线程并放到锁标志等待池中,只有锁标志等待池中线程才可能够获取锁标志;如果等待队列中没有线程,则notify()不起作用。notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。

    被唤醒的线程并不会立即执行而是尝试获得锁,执行唤醒方法的线程也并不会立即释放锁。

    2.1.1.2 join方法的介绍

    join方法在内部使用wait()方法进行等待,底层用wait()来实现,可以释放锁。join方法上加了synchronuzed关键字,因此使用wait没有问题。

    join方法的主要作用就是同步,它可以使得线程之间的并行执行变为串行执行,有些类似于同步的运行效果。在A线程中调用了B线程的join()方法时,表示只有当B线程执行完毕时,A线程才能继续执行。如果有多个线程,除了A线程之外的其他线程正常竞争cpu和锁。

    join方法中如果传入参数,则表示这样的意思:如果A线程中调用B线程的join(10),则表示A线程会等待B线程执行10毫秒,10毫秒过后,A、B线程并行执行。需要注意的是,jdk规定,join(0)的意思不是A线程等待B线程0秒,而是A线程等待B线程无限时间,直到B线程执行完毕,即join(0)等价于join()。(其实join()中调用的是join(0))。主线程中调用join,则主线程等待, 其他多个线程之间并不需要互相等待。

    join()与synchronized的区别是:join在内部调用wait()方法进行等待,而synchronized关键字使用的是"对象监视器"原理作为同步。

        /**
         * join方法
         * @throws InterruptedException
         */
        public final void join() throws InterruptedException {
            //内部调用join(long millis)方法,参数为0 ,表示无限等待
            join(0);
        }
    
        /**
         * 等待millis毫秒
         * @param millis
         * @throws InterruptedException
         */
        public final synchronized void join(long millis)
                throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
    
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
            //millis等于0 表示无限期等待
            if (millis == 0) {
                while (isAlive()) {
                    //调用wait方法
                    wait(0);
                }
            } 
            //否则,限时等待
            else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    //调用wait方法
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }
    

    2.1.2 进入超时等待

    1. public final void join(long millis) --超时等待 释放锁
    2. LockSupport.parkNanos
    3. LockSupport.parkUntil
    4. wait(long timeout); --超时等待 释放锁
    5. public static void sleep(long millis); —超时等待 不释放锁

    2.1.2.1 sleep方法的介绍

    sleep方法使当前线程(即调用该方法的线程)暂停执行一段时间,让其他线程有机会继续执行,但它并不释放对象锁。也就是说如果有synchronized同步快,其他线程仍然不能访问共享数据。注意该方法要捕捉异常。sleep会让其他所有线程都有同等的cpu争夺权力

    睡眠时被中断,则会在sleep()处抛出InterruptedException 异常。

    在调用Thread.sleep(long millis)时为millis 参数传递了一个负数, 则会抛出IllegalArgumentException 异常.

    2.1.2.2 LockSupport类简介

    LockSupport是一个线程阻塞工具类,所有的方法都是静态方法,可以让线程在任意位置阻塞,当然阻塞之后肯定得有唤醒的方法。

    常用方法:

    方法名称描述
    void park()阻塞当前线程,如果调用unpark(Thread)方法或被中断,才能从park()返回。
    void parkNanos(long nanos)阻塞当前线程,超时返回,阻塞时间最长不超过nanos纳秒。
    void parkUntil(long deadline)阻塞当前线程,直到deadline时间点
    void unpark(Thread)唤醒处于阻塞状态的线程

    park不需要获取某个对象的锁。因为中断的时候park不会抛出InterruptedException异常,所以需要在park之后自行判断中断状态,然后做额外的处理。

    2.1.2.3 过期的suspend和resume方法

    suspend方法被不推荐使用。不推荐使用suspend()去挂起线程的原因,是因为suspend()在导致线程暂停的同时,并不会去释放任何锁资源。其他线程都无法访问被它占用的锁。直到对应的线程执行resume()方法后,被挂起的线程才能继续,从而其它被阻塞在这个锁的线程才可以继续执行。如果resume()操作出现在suspend()之前执行,那么线程将一直处于挂起状态,同时一直占用锁,这就容易产生死锁。

    而且,对于被挂起的线程,它的线程状态居然还是RUNNABLE

            //创建子线程,在其内部调用suspend让其"阻塞"
            Thread thread = new Thread(() -> Thread.currentThread().suspend());
            thread.start();
            //主线程睡眠三秒,让子线程充分运行
            Thread.currentThread().sleep(3000);
            //获取子线程状态,发现还是RUNNABLE状态
            Thread.State state = thread.getState();
            System.out.println(state);
    

    2.4 进入RUNNABLE状态

    1. TIMED_WAITING状态结束
    2. WAITING状态被唤醒
    3. BLOCKED状态获得锁
    4. public static void yield();
    5. 线程的cpu时间片使用完毕还未执行完任务,重回就绪态,但此时不会释放锁。

    2.4.1 yield方法的介绍

    yield方法又称为“线程礼让”,使调用线程释放cpu执行权,让自己和其他多个线程重新争夺cpu执行权。

    线程直接回到RUNNABLE状态,而不是让线程处于阻塞态,因此也有可能是当前让步的线程又进入到“运行状态”继续运行

    yield会尽量让同等级和高等级的线程具有更大的争夺权,而sleep会让所有线程都有同等的争夺权力,但它们并不是绝对的。毕竟java线程最终是调用操作系统的资源生成的,充满了不确定性。

    yield方法不会释放持有已获得的锁,只是释放cpu的执行权

    如果有什么不懂或者需要交流,各位可以留言。另外,希望收藏、关注一下,我将不间断更新Java各种教程!

    展开全文
  • 那为什么有的地方说是5种呢,那这一定是将操作系统层面的线程状态搞混了。 下面我们就分别介绍一下java线程的6种状态以及操作系统层面的5种状态: 1、java线程状态 java线程有6种状态,我们先来一个官方的依据 ...

    背景

    先来解答一个世界级难题:

    java线程有多少种状态?

    答案是6种!!!

    那为什么有的地方说是5种呢,那这一定是将操作系统层面的线程状态搞混了。

    下面我们就分别介绍一下java线程的6种状态以及操作系统层面的5种状态:

    1、java线程状态

    java线程有6种状态,我们先来一个官方的依据

    public class Thread implements Runnable {
      public enum State {
            /**
             * Thread state for a thread which has not yet started.
             * <p>
             *  尚未启动的线程的线程状态。
             * 
             */
            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.
             * <p>
             * 可运行线程的线程状态。处于可运行状态的线程正在Java虚拟机中执行,但它可能正在等待来自操作系统的其他资源,例如处理器。
             * 
             */
            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}.
             * <p>
             *  线程阻塞等待监视器锁的线程状态。处于阻塞状态的线程在调用{@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:
             * <ul>
             *   <li>{@link Object#wait() Object.wait} with no timeout</li>
             *   <li>{@link #join() Thread.join} with no timeout</li>
             *   <li>{@link LockSupport#park() LockSupport.park}</li>
             * </ul>
             *
             * <p>A thread in the waiting state is waiting for another thread to
             * perform a particular action.
             *
             * For example, a thread that has called <tt>Object.wait()</tt>
             * on an object is waiting for another thread to call
             * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
             * that object. A thread that has called <tt>Thread.join()</tt>
             * is waiting for a specified thread to terminate.
             * <p>
             *  等待线程的线程状态。线程由于调用以下方法之一而处于等待状态:
             * <ul>
             *  <li> {@ link Object#wait()Object.wait}没有超时</li> <li> {@ link #join()Thread.join}没有超时</li> <li> {@ link LockSupport #park()LockSupport.park}
             *  </li>。
             * </ul>
             * 
             *  <p>处于等待状态的线程正在等待另一个线程执行特定操作。
             * 
             *  例如,在对象上调用<tt> Object.wait()</tt>的线程正在等待另一个线程调用<tt> Object.notify()</tt>或<tt> Object.notifyAll )</tt>
             * 。
             * 调用<tt> Thread.join()</tt>的线程正在等待指定的线程终止。
             * 
             */
            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:
             * <ul>
             *   <li>{@link #sleep Thread.sleep}</li>
             *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
             *   <li>{@link #join(long) Thread.join} with timeout</li>
             *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
             *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
             * </ul>
             * <p>
             *  具有指定等待时间的等待线程的线程状态。由于调用指定正等待时间的以下方法之一,线程处于定时等待状态:
             * <ul>
             * <li> {@ link #sleep Thread.sleep} </li> <li> {@ link Object#wait(long)Object.wait} with timeout </li>
             *  <li> {@ link #join .join} with timeout </li> <li> {@ link LockSupport#parkNanos LockSupport.parkNanos}
             *  </li> <li> {@ link LockSupport#parkUntil LockSupport.parkUntil}。
             * </ul>
             */
            TIMED_WAITING,
    
            /**
             * Thread state for a terminated thread.
             * The thread has completed execution.
             * <p>
             *  终止线程的线程状态。线程已完成执行。
             * 
             */
            TERMINATED;
        }
    }
    

    简单来介绍一下6种状态:

    1))NEW:初始状态,线程被构建,但是还没有调用 start 方法;

    2)RUNNABLED:运行状态,JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中” ;

    3)BLOCKED:阻塞状态,表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权,阻塞也分为几种情况 :

    • 等待阻塞:运行的线程执行了 Thread.sleepwait()join() 等方法JVM 会把当前线程设置为等待状态,当 sleep 结束、join 线程终止或者线程被唤醒后,该线程从等待状态进入到阻塞状态,重新抢占锁后进行线程恢复;

    • 同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被其他线程锁占用了,那么jvm会把当前的线程放入到锁池中 ;

    • 其他阻塞:发出了 I/O请求时,JVM 会把当前线程设置为阻塞状态,当 I/O处理完毕则线程恢复;

    4)WAITING:等待状态,没有超时时间,要被其他线程或者有其它的中断操作;

    执行wait()、join()、LockSupport.park();

    5)TIME_WAITING:超时等待状态,超时以后自动返回;

    执行 Thread.sleep(long)、wait(long)、join(long)、LockSupport.park(long)、LockSupport.parkNanos(long)、LockSupport.parkUntil(long)

    6)TERMINATED:终止状态,表示当前线程执行完毕 。

    2、线程状态间的转换

    借一个图来描述:

    C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200526103703738.png

    具体的转换场景,图中描述的比较清楚,此处不再详细赘述。

    注意:

    1)sleep、join、yield时并不释放对象锁资源,在wait操作时会释放对象资源,wait在被notify/notifyAll唤醒时,重新去抢夺获取对象锁资源。

    2)sleep可以在任何地方使用,而wait,notify,notifyAll只能在同步控制方法或者同步控制块中使用。

    3)调用obj.wait()会立即释放锁,以便其他线程可以执行notify(),但是notify()不会立刻立刻释放sycronized(obj)中的对象锁,必须要等notify()所在线程执行完sycronized(obj)同步块中的所有代码才会释放这把锁。然后供等待的线程来抢夺对象锁。

    3、java代码中查看线程状态

    我们可以通过打印堆栈信息来查看线程的状态,下面举一个实例:

    public class ThreadState {
    
        public static void main(String[] args) {
            new Thread(()->{
                while(true){
                    try {
                        TimeUnit.SECONDS.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"thread01_status").start();  //阻塞状态
    
            new Thread(()->{
                while(true){
                    synchronized (ThreadState.class){
                        try {
                            ThreadState.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            },"thread02_status").start(); //阻塞状态
    
            new Thread(new BlockedDemo(),"BLOCKED-DEMO-01").start();
            new Thread(new BlockedDemo(),"BLOCKED-DEMO-02").start();
    
        }
        static class BlockedDemo extends  Thread{
            @Override
            public void run() {
                synchronized (BlockedDemo.class){
                    while(true){
                        try {
                            TimeUnit.SECONDS.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    
    

    通过打印堆栈信息来查看:(我使用的是IDEA,也可以直接用cmd命令打开命令窗口查看,效果是一样的)

    1)获取java进程的pid;

    S:\workspace\study\concurrent\thread-demo>jps
    23328 Launcher
    5376 ThreadState
    14700
    19708 Jps
    
    

    2)根据上一步骤获得的 pid,继续输入 jstack pidjstack是 java 虚拟机自带的一种堆栈跟踪工具。jstack用于
    打印出给定的 java 进程 ID 或 core file 或远程调试服务的 Java 堆栈信息)

    S:\workspace\study\concurrent\spring-boot-thread-demo>jstack 5376
    2020-05-26 11:19:31
    Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.131-b11 mixed mode):
    
    "DestroyJavaVM" #19 prio=5 os_prio=0 tid=0x0000000002e44000 nid=0x5788 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
    "thread05_status" #18 prio=5 os_prio=0 tid=0x000000001f703000 nid=0x5efc waiting for monitor entry [0x00000000202df000]
       java.lang.Thread.State: `BLOCKED (on object monitor)`
            at com.example.springbootthreaddemo.demo02.ThreadState$BlockedDemo.run(ThreadState.java:49)
            - waiting to lock <0x000000076c0dc148> (a java.lang.Class for com.example.springbootthreaddemo.demo02.ThreadState$BlockedDemo)
            at java.lang.Thread.run(Thread.java:748)
    
    "thread04_status" #16 prio=5 os_prio=0 tid=0x000000001f701000 nid=0x52e0 waiting on condition [0x00000000201df000]
       java.lang.Thread.State:` TIMED_WAITING (sleeping)`
            at java.lang.Thread.sleep(Native Method)
            at java.lang.Thread.sleep(Thread.java:340)
            at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
            at com.example.springbootthreaddemo.demo02.ThreadState$BlockedDemo.run(ThreadState.java:49)
            - locked <0x000000076c0dc148> (a java.lang.Class for com.example.springbootthreaddemo.demo02.ThreadState$BlockedDemo)
            at java.lang.Thread.run(Thread.java:748)
    
    "thread03_status" #14 prio=5 os_prio=0 tid=0x000000001f715000 nid=0x4fc4 runnable [0x00000000200df000]
       java.lang.Thread.State: `RUNNABLE`
            at com.example.springbootthreaddemo.demo02.ThreadState.lambda$main$2(ThreadState.java:35)
            at com.example.springbootthreaddemo.demo02.ThreadState$$Lambda$3/935044096.run(Unknown Source)
            at java.lang.Thread.run(Thread.java:748)
    
    "thread02_status" #13 prio=5 os_prio=0 tid=0x000000001f714000 nid=0x4748 in Object.wait() [0x000000001ffdf000]
       java.lang.Thread.State:` WAITING (on object monitor)`
            at java.lang.Object.wait(Native Method)
            - waiting on <0x000000076bc73f08> (a java.lang.Class for com.example.springbootthreaddemo.demo02.ThreadState)
            at java.lang.Object.wait(Object.java:502)
            at com.example.springbootthreaddemo.demo02.ThreadState.lambda$main$1(ThreadState.java:26)
            - locked <0x000000076bc73f08> (a java.lang.Class for com.example.springbootthreaddemo.demo02.ThreadState)
            at com.example.springbootthreaddemo.demo02.ThreadState$$Lambda$2/443308702.run(Unknown Source)
            at java.lang.Thread.run(Thread.java:748)
    
    "thread01_status" #12 prio=5 os_prio=0 tid=0x000000001f711000 nid=0xb28 waiting on condition [0x000000001fedf000]
       java.lang.Thread.State: `TIMED_WAITING (sleeping)`
            at java.lang.Thread.sleep(Native Method)
            at java.lang.Thread.sleep(Thread.java:340)
            at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
            at com.example.springbootthreaddemo.demo02.ThreadState.lambda$main$0(ThreadState.java:15)
            at com.example.springbootthreaddemo.demo02.ThreadState$$Lambda$1/205797316.run(Unknown Source)
            at java.lang.Thread.run(Thread.java:748)
    

    从上面的信息中可以看到:

    1)thread01_status:状态为TIMED_WAITING,该线程是执行了sleep(),所以处于线程休眠状态;

    2)thread02_status:状态为WAITING,该线程是执行了wait(),所以处于线程等待状态;

    3)thread03_status:状态为RUNNABLE,该线程是正常运行中,处于运行状态;

    4)thread04_status:状态为TIMED_WAITING,该线程执行了同步代码块,它先获取到了BlockedDemo的类锁,执行了sleep(),所以处于线程等待状态;

    5)thread05_status:因为线程thread04_status获取到的类锁没有释放,所以thread05_status在执行synchronized(BlockedDemo.class)时是阻塞的,所以为BLOCKED状态。

    4、操作系统层面线程状态

    ​ 很多人会把操作系统层面的线程状态与java线程状态混淆,所以导致有的文章中把java线程状态写成是5种,在此我们说清楚一个问题,java线程状态是6个,操作系统层面的线程状态是5种。如下图所示:

    在这里插入图片描述
    下面分别介绍一下这5种状态:

    1)new :一个新的线程被创建,等待该线程被调用执行;

    2)ready :表示线程已经被创建,正在等待系统调度分配CPU使用权,或者时间片已用完,此线程被强制暂停,等待下一个属于它的时间片到来。

    3)running :表示线程获得了CPU使用权,正在占用时间片,正在进行运算中;

    4)waiting :表示线程等待(或者说挂起),等待某一事件(如IO或另一个线程)执行完,让出CPU资源给其他线程使用;

    5)terminated :一个线程完成任务或者其他终止条件发生,该线程终止进入退出状态,退出状态释放该线程所分配的资源。

    需要注意的是,操作系统中的线程除去new 和terminated 状态,一个线程真实存在的状态是ready 、running、waiting 。

    结语

    至此,我们就把java线程状态以及操作系统层面的线程状态说清了,是不是以后再也不会混淆了,希望能帮助到大家。

    展开全文
  • Java线程状态分析/线程状态转换图

    万次阅读 多人点赞 2018-05-12 10:16:16
    注:以下代码讲解基于JDK1.8.0_144一、线程状态分类 线程一共有六种状态,分别为New、RUNNABLE、BLOCKED、WAITING、TIMED_WAITINGTERMINATED,同一时刻只有一种状态,通过线程的getState方法可以获取线程的状态。...

    注:以下代码讲解基于JDK1.8.0_144

    一、线程状态分类
     

    线程一共有六种状态,分别为NewRUNNABLEBLOCKEDWAITINGTIMED_WAITING

    TERMINATED,同一时刻只有一种状态,通过线程的getState方法可以获取线程的状态。

    二、线程状态讲解

    2.1 NEW

          /**

             * Thread state for a thread which has not yet started.

             */

            NEW,

         当线程被创建出来还没有被调用start()时候的状态。    

    2.2 RUNNABLE

            /**

             * 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,

         当线程被调用了start(),且处于等待操作系统分配资源(如CPU)、等待IO连接、正在运行状态,即表示Running状态和Ready状态。

         注:不一定被调用了start()立刻会改变状态,还有一些准备工作,这个时候的状态是不确定的。

    2.3 BLOCKED

            /**

             * 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,

          等待监视锁,这个时候线程被操作系统挂起。当进入synchronized/方法或者在调用wait()被唤醒/超时之后重新进入synchronized/方法,锁被其它线程占有,这个时候被操作系统挂起,状态为阻塞状态。

           阻塞状态的线程,即使调用interrupt()方法也不会改变其状态。

    2.4 WAITING

            /**

             * Thread state for a waiting thread.

             * A thread is in the waiting state due to calling one of the

             * following methods:

             * <ul>

             *   <li>{@link Object#wait() Object.wait} with no timeout</li>

             *   <li>{@link #join() Thread.join} with no timeout</li>

             *   <li>{@link LockSupport#park() LockSupport.park}</li>

             * </ul>

             *

             * <p>A thread in the waiting state is waiting for another thread to

             * perform a particular action.

             *

             * For example, a thread that has called <tt>Object.wait()</tt>

             * on an object is waiting for another thread to call

             * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on

             * that object. A thread that has called <tt>Thread.join()</tt>

             * is waiting for a specified thread to terminate.

             */

            WAITING,

    无条件等待,当线程调用wait()/join()/LockSupport.park()不加超时时间的方法之后所处的状态,如果没有被唤醒或等待的线程没有结束,那么将一直等待,当前状态的线程不会被分配CPU资源和持有锁。

    2.5 TIMED_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:

             * <ul>

             *   <li>{@link #sleep Thread.sleep}</li>

             *   <li>{@link Object#wait(long) Object.wait} with timeout</li>

             *   <li>{@link #join(long) Thread.join} with timeout</li>

             *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>

             *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>

             * </ul>

             */

            TIMED_WAITING,

          有条件的等待,当线程调用sleep(睡眠时间)/wait(等待时间)/join(等待时间)/ LockSupport.parkNanos(等待时间)/LockSupport.parkUntil(等待时间)方法之后所处的状态,在指定的时间没有被唤醒或者等待线程没有结束,会被系统自动唤醒,正常退出。

    2.6 TERMINATED

            /**

             * Thread state for a terminated thread.

             * The thread has completed execution.

             */

            TERMINATED;

    执行完了run()方法。其实这只是Java语言级别的一种状态,在操作系统内部可能已经注销了相应的线程,或者将它复用给其他需要使用线程的请求,而在Java语言级别只是通过Java代码看到的线程状态而已。

    三、状态转换图

     四、常见场景

    4.1 RUNNABLE状态

    主要是测试在进入run方法之后线程的状态,以及在等待IO的时候,线程的状态。

    测试代码:

    public static void testStateRunnable() {
    		IOThread simpleThread = new IOThread("IOThread");
    		simpleThread.start();
    
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("Main thread check the state is " + simpleThread.getState() + "."); // RUNNABLE
    	}
    
    	static class IOThread extends Thread {
    
    		public IOThread(String name) {
    			super(name);
    		}
    
    		@Override
    		public void run() {
    			System.out.println("In run method, state is " + getState() + "."); // RUNNABLE
    			Socket socket = new Socket();
    			try {
    				System.out.println("Try to connect socket address which not exist...");
    				socket.connect(new InetSocketAddress(
    						InetAddress.getByAddress(new byte[] { (byte) 192, (byte) 168, 1, 14 }), 5678));
    			} catch (UnknownHostException e) {
    				e.printStackTrace();
    			} catch (IOException e) {
    				e.printStackTrace();
    			} finally {
    				try {
    					socket.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}

    测试结果:

    In run method, state is RUNNABLE.
    
    Try to connect socket address which not exist...
    
    Main thread check the state is RUNNABLE.

    堆栈信息:

    "IOThread" #10 prio=5 os_prio=0 tid=0x00000000187c7800 nid=0x8b0 runnable [0x00000000192ee000]
       java.lang.Thread.State: RUNNABLE
    	at java.net.DualStackPlainSocketImpl.connect0(Native Method)
    	at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:79)
    	at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:350)
    	- locked <0x00000000eb6c0fa8> (a java.net.DualStackPlainSocketImpl)
    	at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:206)
    	at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:188)
    	at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:172)
    	at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392)
    	at java.net.Socket.connect(Socket.java:589)
    	at java.net.Socket.connect(Socket.java:538)
    	at com.test.threadpool.TestThreadState$IOThread.run(TestThreadState.java:83)

    4.2 BLOCKED状态

    模拟两个线程抢锁,当一个线程抢到锁之后进入sleepsleep状态下不会释放锁,所以另外一个线程被阻塞。从堆栈信息可以看到,lockedwaiting to lock都是同一个对象。

    测试代码:

     public static void testBlockedState() {
    		Object lock = new Object();
    		SleepThread t1 = new SleepThread("t1", lock);
    		SleepThread t2 = new SleepThread("t2", lock);
    		t1.start();
    		t2.start();
    
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("Thread t1's state " + t1.getState());
    		System.out.println("Thread t2's state " + t2.getState());
    	}
    
    	static class SleepThread extends Thread {
    		private String name;
    		private Object lock;
    
    		public SleepThread(String name, Object lock) {
    			super(name);
    			this.name = name;
    			this.lock = lock;
    		}
    
    		@Override
    		public void run() {
    			System.out.println("Thread:" + name + " in run.");
    
    			synchronized (lock) {
    				System.out.println("Thread:" + name + " hold the lock.");
    
    				try {
    					Thread.sleep(1000 * 1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    
    				System.out.println("Thread:" + name + " return the lock.");
    			}
    		}
    	}

    测试结果:

    Thread:t2 in run.
    
    Thread:t1 in run.
    
    Thread:t2 hold the lock.
    
    Thread t1's state BLOCKED
    
    Thread t2's state TIMED_WAITING

    堆栈信息:

    "t2" #11 prio=5 os_prio=0 tid=0x0000000018604800 nid=0x934 waiting on condition [0x000000001920f000]
       java.lang.Thread.State: TIMED_WAITING (sleeping)
            at java.lang.Thread.sleep(Native Method)
            at com.test.threadpool.TestThreadState$SleepThread.run(TestThreadState.java:274)
            - locked <0x00000000eb64b910> (a java.lang.Object)
    "t1" #10 prio=5 os_prio=0 tid=0x000000001860b000 nid=0x3528 waiting for monitor entry [0x000000001910f000]
       java.lang.Thread.State: BLOCKED (on object monitor)
            at com.test.threadpool.TestThreadState$SleepThread.run(TestThreadState.java:271)
            - waiting to lock <0x00000000eb64b910> (a java.lang.Object)

    4.3 WAITING状态

    4.3.1 调用wait()方法导致的WAITING状态。

    测试代码:

     /**
    	 * 线程调用wait方法,状态变成WAITING。
    	 */
    	public static void testStateWatingByWait() {
    		Object lock = new Object();
    		WaitingThread waitingThread = new WaitingThread("WaitingThread", lock);
    		waitingThread.start();
    
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("Main thread check the state is " + waitingThread.getState() + "."); // WAITING
    	}
    
    	static class WaitingThread extends Thread {
    		private int timeout = 0;
    		private Object lock;
    
    		public WaitingThread(String name, Object lock) {
    			this(name, lock, 0);
    		}
    
    		public WaitingThread(String name, Object lock, int timeout) {
    			super(name);
    			this.timeout = timeout;
    			this.lock = lock;
    		}
    
    		@Override
    		public void run() {
    			synchronized (lock) {
    				if (timeout == 0) {
    					try {
    						System.out.println("Try to wait.");
    						lock.wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				} else {
    					try {
    						System.out.println("Try to wait in " + timeout + ".");
    						lock.wait(timeout);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    
    			System.out.println("Over thread.");
    		}
    	}

    测试结果:

    Try to wait.
    
    Main thread check the state is WAITING.

    堆栈信息:

    "WaitingThread" #10 prio=5 os_prio=0 tid=0x0000000018dea000 nid=0x1220 in Object.wait() [0x00000000198ee000]
       java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00000000eb6477e8> (a java.lang.Object)
            at java.lang.Object.wait(Object.java:502)
            at com.test.threadpool.TestThreadState$WaitingThread.run(TestThreadState.java:138)
            - locked <0x00000000eb6477e8> (a java.lang.Object)

    4.3.2 调用join()方法导致的WAITING状态。

    thread.join()方法其实就是synchronized(thread)内部一直判断thread的状态,如果为存活状态,就wait一个指定的时间,默认为0,然后继续循环判断,直到状态不为存活状态。

    测试代码:

     /**
    	 * 线程调用join方法,状态变成WAITING。
    	 */
    	public static void testStateWatingByJoin() {
    		Object lock = new Object();
    		WaitingThread waitingThread = new WaitingThread("WaitingThread", lock);
    		waitingThread.start();
    		JoinThread joinThread = new JoinThread("JoinThread", waitingThread);
    		joinThread.start();
    		
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("Main thread check the join thread's state is " + joinThread.getState() + "."); // WAITING
    	}
    
    	static class JoinThread extends Thread {
    		private int timeout = 0;
    		private Thread thread;
    
    		public JoinThread(String name, Thread thread) {
    			this(name, thread, 0);
    		}
    
    		public JoinThread(String name, Thread thread, int timeout) {
    			super(name);
    			this.timeout = timeout;
    			this.thread = thread;
    		}
    
    		@Override
    		public void run() {
    			if (timeout == 0) {
    				try {
    					System.out.println("Try to join.");
    					thread.join();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			} else {
    				try {
    					System.out.println("Try to join in " + timeout + ".");
    					thread.join(timeout);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    			System.out.println("Over join.");
    		}
    	}
    	static class WaitingThread extends Thread {
    		private int timeout = 0;
    		private Object lock;
    
    		public WaitingThread(String name, Object lock) {
    			this(name, lock, 0);
    		}
    
    		public WaitingThread(String name, Object lock, int timeout) {
    			super(name);
    			this.timeout = timeout;
    			this.lock = lock;
    		}
    
    		@Override
    		public void run() {
    			synchronized (lock) {
    				if (timeout == 0) {
    					try {
    						System.out.println("Try to wait.");
    						lock.wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				} else {
    					try {
    						System.out.println("Try to wait in " + timeout + ".");
    						lock.wait(timeout);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    
    			System.out.println("Over thread.");
    		}
    	}

    测试结果:

    Try to wait.
    
    Try to join.
    
    Main thread check the state is WAITING.

    堆栈信息:

    "JoinThread" #11 prio=5 os_prio=0 tid=0x0000000019007000 nid=0x33c0 in Object.wait() [0x0000000019c1f000]
       java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00000000eb64a498> (a com.test.threadpool.TestThreadState$WaitingThread)
            at java.lang.Thread.join(Thread.java:1252)
            - locked <0x00000000eb64a498> (a com.test.threadpool.TestThreadState$WaitingThread)
            at java.lang.Thread.join(Thread.java:1326)
            at com.test.threadpool.TestThreadState$JoinThread.run(TestThreadState.java:194)
    "WaitingThread" #10 prio=5 os_prio=0 tid=0x0000000019006000 nid=0x35ac in Object.wait() [0x0000000019b1f000]
       java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00000000eb64a468> (a java.lang.Object)
            at java.lang.Object.wait(Object.java:502)
            at com.test.threadpool.TestThreadState$WaitingThread.run(TestThreadState.java:138)
            - locked <0x00000000eb64a468> (a java.lang.Object)

    4.3.3 调用LockSupport.park方法导致的WAITING状态。

    使用线程池的时候经常会遇到这种状态,当线程池里面的任务都执行完毕,会等待获取任务。

    测试代码:

    public static void testStateWatingByThreadExecutor() {
    		ExecutorService executeService = Executors.newSingleThreadExecutor();
    		executeService.submit(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("Over Run.");
    			}
    		});
    
    		try {
    			Thread.sleep(10000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}

    堆栈信息:

    "pool-1-thread-1" #10 prio=5 os_prio=0 tid=0x0000000018f9c000 nid=0x2e88 waiting on condition [0x0000000019aaf000]
       java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000000eb64cc30> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)
            at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:442)
            at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074)
            at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)
            at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
            at java.lang.Thread.run(Thread.java:748)

    4.4 TIMED_WAITING状态

    只测试sleep()方法,其余参照WAITING状态。

    测试代码:

     public static void testSleep() {
    		try {
    			Thread.sleep(1000 * 100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}

    堆栈信息:

    "main" #1 prio=5 os_prio=0 tid=0x0000000004f80800 nid=0x34bc waiting on condition [0x0000000004e7f000]
       java.lang.Thread.State: TIMED_WAITING (sleeping)
            at java.lang.Thread.sleep(Native Method)
            at com.test.threadpool.TestThreadState.testSleep(TestThreadState.java:233)
            at com.test.threadpool.TestThreadState.main(TestThreadState.java:53)

    4.5 NEWTERMINATED状态

    测试创建线程,启动线程,线程运行完毕。处于这两个状态的线程在堆栈不会出现在堆栈信息里面。

    测试代码:

    public static void testNewAndTerminatedState() {
    		Thread thread = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("Over Run.");
    			}
    		});
    
    		System.out.println("State " + thread.getState() + ".");
    		thread.start();
    
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("State " + thread.getState() + ".");
    	}

    测试结果:

    State NEW.
    
    Over Run.
    
    State TERMINATED.
    展开全文
  • JVM线程状态

    千次阅读 2018-12-18 11:24:22
    在jvm中一共定义了6种线程状态,分别是:NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED。在Thread类中体现为下面的代码: public static enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_...

    在jvm中一共定义了6种线程状态,分别是:NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED。在Thread类中体现为下面的代码:

    public static enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    
        private State() {
        }
    }

    jdk中对各种状态的描述如下:

    NEW:尚未启动的线程处于此状态。

    RUNNABLE:可运行线程的线程状态。 可运行状态的线程正在Java虚拟机中执行,但它可能正在等待来自操作系统(例如处理器)的其他资源

    BLOCKED:一个线程的线程状态阻塞等待监视器锁定。 处于阻塞状态的线程正在等待监视器锁定进入同步块/方法,或者在调用Object.wait后重新输入同步的块/方法

    WAITING:等待线程的线程状态 由于调用以下方法之一,线程处于等待状态

                          Object.wait没有超时

                         Thread.join没有超时

                          LockSupport.park 

    TIMED_WAITING:具有指定等待时间的等待线程的线程状态。 线程处于定时等待状态,因为在指定的正等待时间内调用以下方法之一

                         Thread.sleep

                         Object.wait与超时

                         Thread.join与超时

                         LockSupport.parkNanos

                         LockSupport.parkUntil

     TERMINATED:终止线程的线程状态。 线程已完成执行。

    一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

    可以通过Thread.getState()获取线程状态(java5开始)

    下面通过代码说明其中的四种状态,其余两种后续再更新:

    新建线程类,这里是通过集成Thread类的方式:

    public class MyThread extends Thread {
        public MyThread(String name) {
            this.setName(name);
        }

        @Override
        public void run() {
            super.run();
            for (int i = 0; i < 10; i++) {
                System.out.println(this.getName() + "   " + i);
                if (i == 5) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public class ThreadState {
        public static void main(String[] args) throws InterruptedException {
            MyThread myThread = new MyThread("nhl");
            System.out.println(myThread.getState().name());// 新建状态,还未调用start方法,状态为  NEW
            myThread.start();
            System.out.println(myThread.getState().name());// 调用start方法后,线程处于RUNNABLE状态
            Thread.sleep(2000);
            System.out.println(myThread.getState().name());// myThread线程调用sleep方法后,处于TIMED_WAITING状态
            Thread.sleep(5000);
            System.out.println(myThread.getState().name());// myThread线程执行完成后,处于TERMINATED状态
        }
    }

    执行结果如下:

    ------------------------------------------------------------------------------------------------------------------------------------------------------

    下面演示BLOCKED状态:

    修改代码:

    测试代码:

    第一次打印BLOCKED是在主线程中获取myThread的状态

    第二次打印RUNNABLE是在myThread线程中获取自己的状态

    这里关键要理解:Thread.currentThread()代表的是什么。WAITING状态下次再更新

     

    --------------------------------------------------------------------------------------------------------------------------------------------

    下面演示WAITING状态:

     

    测试类:

    至此,JVM中定义的线程状态就演示完毕啦,如果有什么问题,欢迎伙伴们指正

    展开全文
  • Java线程状态RUNNABLE详解

    千次阅读 2020-11-03 20:53:50
    Java虚拟机层面所暴露给我们的状态,与操作系统底层的线程状态是两个不同层面的事。具体而言,这里说的 Java 线程状态均来自于 Thread 类下的 State 这一内部枚举类中所定义的状态: 什么是 RUNNABLE? 直接看它的 ...
  • windows线程状态

    千次阅读 2019-01-29 13:53:07
    文章目录线程状态就绪态备用态运行态等待态转换态终止态线程关系线程同步线程互斥实现同步与互斥方法线程同步实例未同步状态使用临界区实现同步使用事件实现同步信号量使用互斥量使线程同步 线程状态 就绪态 可以被...
  • Java 中线程状态有哪些?

    万次阅读 热门讨论 2021-04-14 23:56:20
    写在前面 本文隶属于专栏《100个问题搞定Java并发》,该专栏为笔者原创,引用请注明...不代表线程在跑,两种:被cpu执行的线程,随时可以被cpu执行的状态。 ③ BLOCKED 线程阻塞,处于synchronized同步代码块或方法中被
  • 图文详解jvm中的线程状态

    千次阅读 2017-12-08 12:55:22
    本文使用下面这张图详细介绍JAVA线程的六种状态     JAVA线程的六种状态详解  在java.lang.Thread类中,定义了线程的以下六种状态(同一个时刻线程只能有一种状态)  NEW(新建) 这个状态是指...
  • 线程状态 Thread.State 状态类型 在指定的时间点, 一个线程有且只有一种状态。 这些状态是 JVM 的状态, 他们并没有反映操作系统的状态。 定义 Thread 的状态是定义在 Thread 内部的枚举类型。...
  • 本章主要对Java中线程状态转换进行学习。 1.前言 在之前的章节中,已经学习了java的各种方法,涉及到状态转换的方法有: Thread.sleep(long):强制线程睡眠一段时间。 thread.start():启动一个线程。 thread....
  • 线程状态转换图及各部分介绍

    千次阅读 2019-04-11 22:13:14
    线程状态转换图 线程的几种状态 新建状态(New): 用new语句创建的线程处于新建状态,此时它和其他Java对象一样,仅仅在堆区中被分配了内存。 就绪状态(Runnable): 当一个线程对象创建后,其他线程调用它的...
  • MySQL线程状态详解

    千次阅读 2021-04-11 23:03:08
    文章目录一、show processlist二、command命令类型三、用户线程状态 一、show processlist Id:连接进程标识符。是由 CONNECTION_ID() 函数返回的值 User:执行语句的 MySQL 用户名称。如果显示的是“system user”...
  • jstack线程状态分析

    千次阅读 2016-03-11 19:48:23
    jstack线程状态
  • Java进程与线程、线程状态及判断

    千次阅读 2019-02-19 23:19:49
    java的第一大特色:多线程的编程支持 一、进程:操作系统中一个程序的执行周期称为是一个进程 多进程:操作系统中多个程序同时进行,比如,windows就是一个多进程的操作系统 二、线程:一个程序下的每一个任务称...
  • Java 线程状态---WAITING(部分转载)

    千次阅读 2019-08-01 20:16:02
    看到一篇关于写线程waiting状态的文章,感觉很生动有趣,转过来保存下。 定义 一个正在无限期等待另一个线程执行一个特别的动作的线程处于这一状态。 A thread that is waiting indefinitely for another ...
  • Java线程状态

    千次阅读 2014-11-29 19:03:17
    线程跟人类一样拥有自己的生命周期,一条线程从创建到执行完毕的过程即是线程的生命周期,此过程可能在不同时刻处于不同的状态,线程状态正是这小节的主题,线程到底有多少种状态?不同状态之间是如何转化的? 对于...
  • 近来在学习Eugene Agafonov编写的《C#多线程编程实战》(译),做些笔记也顺便分享一下^-^using System;...namespace 检测线程状态 { class Program { static void Main(string[] args) { Cons...
  • linux 下查看线程状态

    万次阅读 2018-03-12 13:23:53
    前言 在调试程序时需要查看各个线程的状态,方便定位问题。 解决 方法1、pstree pstree PID 方法2、top top 然后按H,会显示线程 ...此方法还可以查看线程状态 方法3、ps ps -T ...
  • C++之多线程学习篇(3)之线程状态

    千次阅读 2018-07-18 16:59:33
    1. 线程的几种状态 线程在一定条件下,状态会发生变化。线程一共有以下几种状态: 1、新建状态(New):新创建了一个线程对象。 2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该...
  • Java的六种线程状态(不是五种)

    千次阅读 2019-04-29 13:28:38
    网上的文章鱼龙混杂,对于Java到底几种线程状态?这个问题,根据《Java并发编程》这本经典的教材里提到的,是六种状态,不是很多文章中提到的五种状态。这些文章中所提到的是操作系统的五种状态 Java线程的六种状态...
  • Java的六种线程状态

    千次阅读 2021-09-09 09:19:22
    Java语言定义了6种线程状态,在任意一个时间点,一个线程只能有且只有其中的一种状态,这6种状态分别如下。 新建(New):创建后尚未启动的线程处于这种状态。 运行(Runable):Runable包括了操作系统线程状态...
  • JVM性能调优之jstack分析线程状态

    万次阅读 2018-02-24 13:53:42
    背景 记得前段时间,同事说他们测试环境的服务器cpu使用率一直处于100%,本地又没有什么接口调用,为什么会这样?cpu使用率居高不下,自然是有某些线程一直占用着cpu资源,那又如何查看占用cpu较高的线程
  • linux下进程和线程状态查看

    万次阅读 2017-09-05 10:28:45
    检查 使用 ps -fe |grep programname 查看获得进程的pid,再使用 ps -Lf pid 查看对应进程下的线程数. 查找资料发现可以通过设置 ulimit -s 来增加每进程线程数。 每进程可用线程数 = VIRT上限/stack size 32位x86...
  • Java线程模型、线程状态 - 线程(1)

    千次阅读 2016-05-06 15:26:56
    众所周知,线程 - Thread 是比进程 - Progress 更轻量级的调度单位。简单来说,引入线程带来的好处是: 可以把一个进程 的资源分配和执行调度分开,各个线程 既可以共享进程 资源(内存地址、文件I/O等),又可以...
  • 我在qtcreator中用调用的gdb找不到如何显示线程号对应的线程名字,因此需要继续学习使用gdb进行多线程调试. 1.创建多线程工程 2.启动进程并查看运行进程对应的id 3.使用gdb连接进程,并查看进程 1.gdb...
  • jstack 线程状态

    千次阅读 2015-09-25 17:19:10
    jstack 线程状态 jstack 线程里,值得关注的线程状态有: 死锁,Deadlock(重点关注) 执行中,Runnable  等待资源,Waiting on condition(重点关注) 等待获取监视器,Waiting
  • 使用 Java 阻塞 I/O 模型读取数据,将会导致线程阻塞,线程将会进入休眠,从而让出 CPU 的执行权,直到数据读取完成。这个期间如果使用 jstack 查看线程状态...
  • Java 线程状态之 TIMED_WAITING

    万次阅读 2019-07-05 16:19:46
    一个正在限时等待另一个线程执行一个动作的线程处于这一状态。 A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state. 更详细的定义还是看 ...
  • 超清晰的java线程状态机图

    千次阅读 2017-09-10 19:28:54
    http://www.uml-diagrams.org/examples/java-6-thread-state-machine-diagram-example.html
  • 下面给出一个线程池使用示例,及教你获取线程状态。 private static ExecutorService es = new ThreadPoolExecutor(50, 100, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(100000)); public static...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,054,647
精华内容 421,858
关键字:

线程状态