Java线程的六种状态

java中，线程的状态使用一个枚举类型来描述的。这个枚举一共有6个值: NEW(新建)、RUNNABLE(运行)、BLOCKED(锁池)、TIMED_WAITING(定时等待)、WAITING(等待)、TERMINATED(终止、结束)。

但是我发现大多数人的理解和上面的这六种还是有些差别，通常会加上阻塞状态，可运行状态，挂起状态。

这是Thread类描述线程状态的枚举类的源代码：

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.
         *
         * 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;
    }

一、大多数人对线程状态以及状态转换的理解

线程的状态转换：

　　当一个线程创建以后，就处于新建状态。那什么时候这个状态会改变呢？只要它调用的start()方法，线程就进入了锁池状态。

　　进入锁池以后就会参与锁的竞争，当它获得锁以后还不能马上运行，因为一个单核CPU在某一时刻，只能执行一个线程，所以他需要操作系统分配给它时间片，才能执行。所以人们通常把一个线程在获得锁后，获得系统时间片之前的状态称之为可运行状态，但Java源代码里面并没有可运行状态这一说。

　　当一个持有对象锁的线程获得CPU时间片以后，开始执行这个线程，此时叫做运行状态。

　　当一个线程正常执行完，那么就进入终止（死亡）状态。系统就会回收这个线程占用的资源。

　　但是，线程的执行并不是那么顺利的。一个正在运行的线程有可能会进入I/O交互，还可能调用sleep()方法，还有可能在当前线程当中有其它线程调用了join()方法。这时候线程就进入了阻塞状态（但这也只是人们在理解的时候意淫加上去的，源代码里也没有定义这一个状态）。阻塞状态的线程是没有释放对象锁的。当I/O交互完成，或sleep()方法完成，或其它调用join()方法的线程执行完毕。阻塞状态的线程就会恢复到可运行状态，此时如果再次获得CPU时间片就会进入运行状态。

　　一个处于运行状态的线程还可能调用wait()方法、或者带时间参数的wait(long milli)方法。这时候线程就会将对象锁释放，进入等待队列里面（如果是调用wait()方法则进入等待状态，如果是调用带时间参数的则进入定时等待状态）。

　　一个线程如果的调用了带时间参数的wait(long milli)方法进入了定时等待状态，那么只要时间一到就会进入锁池状态，并不需要notify()或notifyAll()方法来唤醒它。如果调用的是不带时间参数的wait()则需要notify()或notifyAll()这两个方法来唤醒它然后进入锁池状态。进入锁池状态以后继续参与锁的竞争。

　　当一个处于运行状态的线程调用了suspend()方法以后，它就会进入挂起状态（这一方法已经过时不建议使用）。挂起状态的线程也没有释放对象锁，它需要调用resume()方法以后才能恢复到可运行状态。将线程挂起容易导致程序死锁。

下面是我自己画线程状态转换图：

这是大多数对一个线程的状态的理解。我以前也是这么理解的，但是，现在我对线程的状态有了新的理解。这与大多数人的理解有些不一样。

二、我对线程状态以及转换的理解

下面是我对线程的自己的理解，如果有不对的地方希望懂的人可以指出来一起讨论一下。

据官方源码，一个线程有六个状态，没有阻塞状态，没有可运行，没有挂起状态。

所以，现在我要提出一个观点：一个处于等待状态、定时等待状态的线程它也可能持有对象锁。例如调用sleep(long millis)会使线程进入等待状态，但是没有释放锁。

线程没有阻塞状态，那一个正在运行的线程进入I/O，或调用sleep()方法，或当前线程当中有其它线程调用了join()方法时，线程就会进入什么状态呢，它总得有六个当中的一个吧。

①、当线程调用sleep()方法或当前线程中有其他线程调用了带时间参数的join()方法的时候进入了定时等待状态（TIMED_WAITING）。

 

②、当其他线程调用了不带时间参数的join()方法时进入等待状态(WAITING)。

 

③、当线程遇到I/O的时候还是运行状态（RUNNABLE）。

④、当一个线程调用了suspend()方法挂起的时候它还是运行状态（RUNNABLE）。

现在我要来证明一下以上四点，如果证明过程有误，希望能够得到指正。这些代码的可以直接复制来运行一下。

证明一：当线程调用sleep()方法的时候进入了定时等待状态。

现在两个线程t1、t2，t1持有t2的一个引用。启动两个线程，t2启动后立即睡眠，让t1打印t2的状态。这样就可以看到睡眠时候的线程是六个当中的哪一个状态了。

public class Test1
{
    public static void main(String[] args)
    {
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        t1.setThread2(t2);
        
        t1.start();
        t2.start();
    }
}

//Thread1负责打印两个线程的状态。
class Thread1 extends Thread
{
    private Thread2 t2;
    
    public void setThread2(Thread2 t2)
    {
        this.t2 = t2;
    }
    
    @Override
    public void run()
    {
        System.out.println("进入t1线程");
        for(int i = 0; i < 5; i++)
        {
            try
            {
                System.out.println("t1 的状态： " + getState());
                System.out.println("t2 的状态： " + t2.getState());
                System.out.println();
                
                //为了减少打印次数，所以t1每打印一次睡1秒
                Thread.sleep(1000);
            } catch (InterruptedException e)
            {
                
            }
        }
    }
}

class Thread2 extends Thread
{
    @Override
    public void run()
    {
        System.out.println("进入t2线程，马上进入睡眠");
        try
        {
            //睡眠5秒钟。
            sleep(5000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("t2睡眠结束");
    }
}

上面的程序执行打印的结果

说明调用sleep()方法以后线程处于定时等待状态（TIMED_WAITING）。至于网上一直说的处于等待状态的线程不持有对象锁这种说法，我不知道这是官方给出的还是人们自己定义的。

 证明二：当其他线程调用了join()方法时进入等待状态。

现在有三个线程t1 、t2 、t3。t1负责打印三个线程的状态。t2线程持有t3线程的引用，当进入t2线程以后，立即启动t3线程，并调用t3.join()方法。当t3加入后t2就是等待状态。

public class Test1
{
    public static void main(String[] args)
    {
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        Thread3 t3 = new Thread3();
        
        //t1需要持有t2,t3的引用，以便打印他们的状态。
        t1.setThread2(t2,t3);
        
        //t2需要持有t3的引用，以便t3能够在t2执行时加入(调用join()方法)
        t2.setTh3(t3);
        
        t1.start();
        t2.start();
    }
}

//Thread1负责打印所有线程的状态。
class Thread1 extends Thread
{
    private Thread2 t2;
    private Thread3 t3;
    
    public void setThread2(Thread2 t2, Thread3 t3)
    {
        this.t2 = t2;
        this.t3 = t3;
    }
    
    @Override
    public void run()
    {
        System.out.println("进入t1线程");
        for(int i = 0; i < 5; i++)
        {
            try
            {
                System.out.println("t1 的状态： " + getState());
                System.out.println("t2 的状态： " + t2.getState());
                System.out.println("t3 的状态： " + t3.getState());
                System.out.println();
                
                //为了减少打印次数，所以t1每打印一次睡1秒
                Thread.sleep(1000);
            } catch (InterruptedException e)
            {
                
            }
        }
    }
}


class Thread2 extends Thread
{
    private Thread3 t3;
    
    public void setTh3(Thread3 t3)
    {
        this.t3 = t3;
    }
    
    //当进入t2线程以后马上启动t3线程并调用join()方法。
    @Override
    public void run()
    {
        System.out.println("进入t2线程，t3准备加入(调用join()方法)");
        t3.start();
        try
        {
            t3.join();
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("t2执行结束");
    }
}
class Thread3 extends Thread
{
    @Override
    public void run()
    {
        System.out.println("进入t3线程，准备睡眠");
        
        //本来是想让t3线程做加法运算的，奈何电脑算太快了，所以改为睡眠。因为睡眠不释放锁，所以效果一样。
        try
        {
            sleep(5000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        System.out.println("t3线程结束");
    }
}

这是运行的打印结果，当t3加入后t2处于等待状态

 根据结果看，说明当一个正在执行的线程在其他线程调用join()方法以后进入了等待状态。

 

 证明三：当一个线程调用了suspend()方法的时候它还是运行状态（RUNNABLE）。

package com.zcd.observe;

public class Test1
{
    public static void main(String[] args)
    {
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        
        //t1需要持有t2,以便打印状态，和控制它恢复运行。
        t1.setThread2(t2);
        
        t1.start();
        t2.start();
    }
}

//Thread1负责打印所有线程的状态。
class Thread1 extends Thread
{
    private Thread2 t2;
    
    public void setThread2(Thread2 t2)
    {
        this.t2 = t2;
    }
    
    @Override
    public void run()
    {
        System.out.println("进入t1线程");
        for(int i = 0; i < 6; i++)
        {
            try
            {
                System.out.println("t1 的状态： " + getState());
                System.out.println("t2 的状态： " + t2.getState());
                System.out.println();
                
                if(i == 3)
                {
                    //恢复t2的运行。
                    t2.resume();
                }
                
                //为了减少打印次数，所以t1每打印一次睡1秒
                Thread.sleep(1000);
            } catch (InterruptedException e)
            {
                
            }
        }
        
    }
}

class Thread2 extends Thread
{
    @Override
    public void run()
    {
        System.out.println("进入t2线程，挂起");
        //将线程挂起。让t1来控制它的恢复运行。
        suspend();
        
        System.out.println("t2已经恢复运行");
        System.out.println("t2正在打印1");
        System.out.println("t2正在打印2");
        System.out.println("t2正在打印3");
        
        
        System.out.println("t2线程结束");
    }
}

执行结果截图

说明：当一个线程调用了suspend()方法的时候它还是运行状态（RUNNABLE）。

证明四：当线程遇到I/O的时候还是运行状态。

package com.zcd.observe;

import java.util.Scanner;

public class Test1
{
    public static void main(String[] args)
    {
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        
        t1.setThread2(t2);
        
        t1.start();
        t2.start();
    }
}

//Thread1负责打印所有线程的状态。
class Thread1 extends Thread
{
    private Thread2 t2;
    
    public void setThread2(Thread2 t2)
    {
        this.t2 = t2;
    }
    
    @Override
    public void run()
    {
        System.out.println("进入t1线程");
        for(int i = 0; i < 6; i++)
        {
            try
            {
                System.out.println("t1 的状态： " + getState());
                System.out.println("t2 的状态： " + t2.getState());
                System.out.println();
                
                
                //为了减少打印次数，所以t1每打印一次睡1秒
                Thread.sleep(1000);
            } catch (InterruptedException e)
            {
                
            }
        }
        System.out.println("进入t1线程结束");
    }
}

class Thread2 extends Thread
{
    @Override
    public void run()
    {
        System.out.println("进入t2线程");
        
        //让线程进入I/O
        System.out.println("请输入数据：");
        Scanner scan = new Scanner(System.in);
        String read = scan.nextLine();
        System.out.println("您输入的数据为："+read); 
        
        System.out.println("t2线程结束");
    }
}

执行结果截图:

说明：当线程遇到I/O的时候还是运行状态。

 下面在附上我画的状态转换图，一共只有六个状态。

转自：https://yq.aliyun.com/articles/49051