java线程生命周期,你真得看看!

234 阅读2分钟

一 、线程生命周期

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)。