【并发编程】线程生命周期状态_java线程生命周期是什么-CSDN博客

本文链接：https://blog.csdn.net/yhl_jxy/article/details/86668152

前言

Github：https://github.com/yihonglei/jdk-source-code-reading（java-concurrent）

一线程生命周期状态

1、在 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.
     */
    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;
}

2、Java 线程状态扭转流程图

NEW（初始状态）：线程被构建，还没有调用 start 方法，线程还没有启动。

RUNNABLE（可运行状态）：表示在 jvm 里面该线程可以执行，但是需要等待 CPU 调度，如果获取 CPU 执行片段，

将开始运行，执行 run 方法。

Running(运行中)：注意，Java 线程是没有这个状态的，只是为了更好的理解线程状态扭转，把获取 cpu 片段正在执行的线程抽象出这么一个过程状态。

BLOCKED（阻塞状态）：线程运行中等待进入锁，就会处于阻塞状态。

WAITING（等待状态）：线程进入等待状态，如图中方式，需要通知。

TIMED_WAITING（等待超时状态）：线程处于等待状态，超过等待时长自动恢复。

TERMINATED（终止状态）：执行 Stop 方法或者线程执行 run 方法完成或抛异常中断。

二线程状态实例分析

SleepUtil，等待工具类。

package com.jpeony.concurrent.util;

import java.util.concurrent.TimeUnit;

/**
 * 休眠工具
 *
 * @author yihonglei
 */
public class SleepUtil {
    public static void second(long seconds) {
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ThreadState，线程状态演示类。

package com.jpeony.concurrent.thread;

import com.jpeony.concurrent.util.SleepUtil;

/**
 * 线程生命周期
 *
 * @author yihonglei
 */
public class ThreadState {
    public static void main(String[] args) {
        new Thread(new TimeWaiting(), "TimeWaitingThread").start();
        new Thread(new Waiting(), "WaitingThread").start();
        // 使用两个Blocked线程，一个获取锁成功，另外一个被阻塞
        new Thread(new Blocked(), "BlockedThread-1").start();
        new Thread(new Blocked(), "BlockedThread-2").start();
    }

    /**
     * 该线程不断地进行睡眠
     */
    private static class TimeWaiting implements Runnable {
        @Override
        public void run() {
            while (true) {
                SleepUtil.second(100);
            }
        }
    }

    /**
     * 该线程在Waiting.class实例上等待
     */
    private static class Waiting implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (Waiting.class) {
                    try {
                        Waiting.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 该线程在Blocked.class实例上加锁后，不会释放该锁
     */
    private static class Blocked implements Runnable {
        @Override
        public void run() {
            synchronized (Blocked.class) {
                while (true) {
                    SleepUtil.second(100);
                }
            }
        }
    }
}

运行程序，查看线程堆栈。

1、jps，找到ThreadState进程。

2、jstack加进程id查看堆栈。