线程状态 - 简书

五种状态

这是从操作系统的层面来描述的

图片.png

1、初始状态:仅在语言层面创建了线程对象，还未与操作系统相关联
2、可运行状态(就绪状态):指线程已经被创建(与操作系统相关联)，可以由cpu调度执行
3、运行状态:指获取到cpu时间片运行中的状态，当cpu时间片用完会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
4、阻塞状态

如果调用了阻塞API,如BIO读写文件，这个时候线程实际上不会使用cpu,会导致线程上下文切换，进入阻塞状态
与【可运行状态】的区别是对于【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

5、终止状态：表明当前线程已经执行完成，生命周期已经结束，不会再转换为其他状态

六种状态

这是站在Java API层面来进行描述，根据Thread.State枚举，来分为六中状态

    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.
         * 对于当前可运行的线程，
         * 1.是在Java虚拟机种是正常运行的=>对应操作系统层面的运行状态
         * 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.
         * 对于当前可运行的线程，
         * 1.是在Java虚拟机种是正常运行的=>对应操作系统层面的运行状态
         * 2.或许在等待操作系统种的某种资源，例如处理器=>对应操作系统层面的阻塞状态
         */
        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;
    }

1、NEW

Thread state for a thread which has not yet started.

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.
* 对于当前可运行的线程，
* 1.是在Java虚拟机种是正常运行的=>对应操作系统层面的运行状态
* 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}.
* 对于线程的阻塞状态，是在等待monitor的锁，
* 为了进入同步的代码块或者方法中，
* 或者调用了wait()方法后，在重新视图进入同步的代码块或者方法中
*/

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.
*/

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

6、TERMINATED;

使用Java代码演示六种状态

@Slf4j(topic = "c")
public class TestThreadState {
    public static void main(String[] args) {
        //NEW
        Thread t1 = new Thread(() -> {
        });
        //RUNNABLE
        Thread t2 = new Thread(() -> {
            Scanner s = new Scanner(System.in);
            s.next();
        });
        t2.start();
        //WAITING
        Thread t3 = new Thread(() -> {
            while (true) {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t3.start();
        //TIEMD-WAITING
        Thread t4 = new Thread(() -> {
            try {
                Thread.sleep(300000000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t4.start();
        //BLOCKED
        Thread t5 = new Thread(() -> {
            synchronized (TestThreadState.class) {
                while (true) {
                    try {
                        Thread.sleep(300000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t5.start();
        Thread t6 = new Thread(() -> {
            synchronized (TestThreadState.class) {
                log.debug("blocked状态>>>>");
            }
        });
        t6.start();
        Thread t7 = new Thread(() -> {

        });
        t7.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1线程的状态:{}", t1.getState());
        log.debug("t2线程的状态:{}", t2.getState());
        log.debug("t3线程的状态:{}", t3.getState());
        log.debug("t4线程的状态:{}", t4.getState());
        log.debug("t6线程的状态:{}", t6.getState());
        log.debug("t7线程的状态:{}", t7.getState());

    }
}

控制台打印情况

10:53:42[main]c - t1线程的状态:NEW
10:53:42[main]c - t2线程的状态:RUNNABLE
10:53:42[main]c - t3线程的状态:WAITING
10:53:42[main]c - t4线程的状态:TIMED_WAITING
10:53:42[main]c - t6线程的状态:BLOCKED
10:53:42[main]c - t7线程的状态:TERMINATED