Java线程生命周期

前言

Github：https://github.com/yihonglei/thinking-in-concurrent

一 线程生命周期

1、在Thread类中，有个表示线程状态的State枚举。

public enum State {
    
    NEW,

    RUNNABLE,

    BLOCKED,

    WAITING,

    TIMED_WAITING,

    TERMINATED;
 }

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

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

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

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

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

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

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

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

TERMINATED（终止状态）：线程执行完成或被中断结束。

二 线程状态实例分析

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查看堆栈。

详细堆栈如下：

1、BlockedThread-2、BlockedThread-1

BlockedThread-2和BlockedThread-1启动时都去获取同步锁，谁先抢到，就是谁的。

从堆栈可以看出，BlockedThread-1先抢到锁，进入方法后执行While(true)，线程一直等待执行，

所以出现超时，线程状态为TIMED_WAITING(等待超时状态)。

因为BlockedThread-1一直没有退出，一直持有锁，当BlockedThread-2进入的时候，获取不到锁，被阻塞了，

线程状态为BLOCKED(阻塞状态)。

2、WaitingThread

线程调用wait方法，处于等待状态WAITING（等待状态），等待被通知。

3、TimeWaitingThread

线程一直等待，等待超时(TIME_WAITING)。