Java线程的状态及主要转化方法

Java线程的状态及主要转化方法

操作系统中的线程状态转换

在操作系统中，线程是被视为轻量级进程的，所以操作系统的线程状态其实和操作系统进程状态是一致的

操作系统线程主要有以下三个状态：

• 就绪状态(ready)：线程正在等待使用CPU，经调度程序调用之后可进入running状态
• 执行状态(running)：线程正在使用CPU
• 等待状态(waiting)：线程经过等待事件的调用或者正在等待其他资源（如I/O）

Java线程的6个状态

// Thread.State 源码
public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

NEW

处于NEW状态的线程此时尚未启动。这里的尚未启动指的是还没调用Thread实例的start()方法

private void testStateNew() {
    Thread thread = new Thread(() -> {});
    System.out.println(thread.getState()); // 输出 NEW 
}

只是创建了线程而没有调用start方法，此时线程处于NEW状态

关于start()的两个引申问题

1. 反复调用同一个线程的start()方法是否可行？
2. 假如一个线程执行完毕（此时处于TERMINATED状态），再次调用这个线程的start()方法是否可行？

public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {

        }
    }
}

可以看到，在start()内部，这里有一个threadStatus的变量。如果它不等于0，调用start()是会直接抛出异常的

接着往下有一个native()的start0()方法，这个方法里并没有对threadStatus的处理。

我们通过debug的方式可以得到

• 第一次调用threadStatus的值是0
• 第二次！=0

查看当前线程状态的源码：

// Thread.getState方法源码：
public State getState() {
    // get current thread state
    return sun.misc.VM.toThreadState(threadStatus);
}

// sun.misc.VM 源码：
public static State toThreadState(int var0) {
    if ((var0 & 4) != 0) {
        return State.RUNNABLE;
    } else if ((var0 & 1024) != 0) {
        return State.BLOCKED;
    } else if ((var0 & 16) != 0) {
        return State.WAITING;
    } else if ((var0 & 32) != 0) {
        return State.TIMED_WAITING;
    } else if ((var0 & 2) != 0) {
        return State.TERMINATED;
    } else {
        return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
    }
}

最后我们可以知道，两个问题都是不可行的，当threadStatus的值不为0，会抛出异常

RUNNABLE

表示当前线程正在运行中。处于RUNNABLE状态的线程在JVM中运行，也有可能在等待CPU分配资源

Java中线程的RUNNABLE状态

Thread源码对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.
 */

Java线程的RUNNABLE状态其实是包括了传统操作系统线程的ready和running两个状态的

BLOCKED

阻塞状态。处于BLOCKED状态的线程正等待锁的释放以进入同步区

别的线程占有了锁，而你又在等那个锁，就是BLOCKED

WAITING

等待状态。处于等待状态状态的线程变成RUNNABLE状态需要其他线程唤醒

调用以下三个方法会使线程进入等待状态

• Object.wait()：使当前线程处于等待状态直到另一个线程唤醒它
• Thread.join()：等待线程执行完毕，底层调用的是Object实例的wait方法
• LockSupport.park()：除非获得调用许可，否则禁用当前线程进行线程调度

假如你是线程t1，有线程t2。即使你占有了锁，但是t2插队进来，你还是得释放锁。此时t1的状态就是WAITING，而t2获得锁，进入RUNNABLE状态。

要是t2不主动唤醒你t1（notify，notifyAll），你就惨了，可得一直等待了

TIMED_WAITING

超时等待状态。线程等待一个具体的时间，时间到后会被自动唤醒

调用如下方法会使线程进入超时等待状态：

• Thread.sleep(long millis)：使当前线程睡眠指定时间
• Object.wait(long timeout)：线程休眠指定时间，等待期间可以通过notify()/notifyAll()唤醒
• Thread.join(long millis)：等待当前线程最多执行millis毫秒，如果millis为0，则会一直执行
• LockSupport.parkNanos(long nanos)：除非获得调用许可，否则禁用当前线程进行线程调度指定时间
• LockSupport.parkUntil(long deadline)：同上

假如你是线程t1，有一个线程t2，t2让t1等待了指定时间，此时t1等待期间就属于TIMED_WAITING状态

t1等待指定时间后，就自动唤醒，重新拥有争夺锁的资格

TERMINATED

终止状态。此时线程已执行完毕

线程状态的转换

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rPZEA2zq-1638712355311)(/upload/2021/12/image-2ff073e69a534b878b548a77c42bf541.png)]

BLOCKED与RUNNABLE状态的转换

先举个例子，假如有两个线程a和b，a线程提前获得了锁并且暂未释放锁，此时b就处于BLOCKED状态
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L8yNjkRF-1638712355318)(/upload/2021/12/image-d0bcdcd799e64d2eaed019ca5cce8611.png)]

如果看到了sleep()，应该会觉得a的状态是TIMED_WAITING，而线程b因为等待线程a所以必然会输出BLOCKED

其实不是的，有两点需要注意：

1. 在测试方法Demo7内还有一个main线程
2. 启动线程后执行run方法还是需要消耗一定时间的

测试方法的main线程只保证了a，b两个线程调用start()方法（转化为RUNNABLE状态），如果CPU执行效率高点，可能还没等到两个线程真正开始争夺锁，就已经打印出两个线程此时的状态（RUNNABLE）

当然，如果CPU执行效率慢一点，其中某个线程也是可能打印出BLOCKED状态的（此时两个锁已经开始争夺锁了）

想稳定打印出BLOCKED状态的话，可以在处理下测试方法的main线程，调用一下Thread.sleep()方法

要注意main线程sleep的实现要保证在线程争夺锁的时间内，不要等到前一个线程锁都释放你再去争夺锁，此时还是等不到BLOCKED状态的

WAITING状态与RUNNABLE状态的转换

Object.wait()

调用wait()方法前线程必须持有对象的锁

线程调用wait()方法时，会释放当前的锁，知道有其他线程调用notify()/notifyAll()方法唤醒等待锁的线程

需要注意的是，其他线程调用notify()方法只会唤醒单个等待锁，如有多个线程都在等待这个锁的话不一定会唤醒到之前调用wait()方法的线程

同样，调用notifyAll()方法唤醒所有等待锁的线程之后，也不一定会马上把时间片分给刚才放弃锁的那个线程，具体要看系统的调度

Thread.join()

调用join()方法，会一直等待这个线程执行完毕（转换为TERMINATED状态）

把上面用例稍作修改

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gxuSvGwc-1638712355320)(/upload/2021/12/image-892e4bb381e2422fb4a025a8fb2df396.png)]

要是没有调用join方法，main线程不管a线程是否执行完毕都会往下走

a线程启动后马上调用join()方法，这里main线程就会等待a线程执行完毕，所以这里a线程打印的状态固定是TERMINATED

至于b线程的状态，有可能打印RUNNABLE（尚未进入同步方法），也有可能TIMED_WAITING（进入了同步方法）

TIMED_WAITING与RUNNABLE状态转换

TIMED_WAITING与WAITING状态类似，只是TIMED_WAITING状态等待的时间是指定的

Thread.sleep(long)

使当前线程睡眠指定时间。需要注意这里的"睡眠"只是暂时使线程停止执行，并不会释放锁。时间到后，线程会重新进入RUNNABLE状态

Object.wait(long)

wait(long)方法使线程进入TIMED_WAITING状态。这里的wait(long)方法和无参方法wait()相同的地方，都可以通过其他线程调用notify()或notifyAll()方法来唤醒

不同的地方是，有参方法wait(long)就算其他线程不来唤醒它，经过指定时间long之后它会自动唤醒，拥有去争夺锁的资格。

Thread.join(long)

join(long)使当前线程执行指定时间，并且使线程进入TIMED_WAITING状态

我们修改刚才的示例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SZl5sVPE-1638712355321)(/upload/2021/12/image-57b528f66916490b8ef8104cd8db66be.png)]

这里调用a.join(1000L)，因为是指定了具体a线程执行的时间的，并且执行时间是小于a线程sleep的时间，所以a线程输出TIMED_WAITING

线程中断

目前Java里还没有安全直接的方法来停止线程，但是Java还是提供了线程中断机制

线程中断机制是一种协作机制。通过中断操作并不能直接终止一个线程，而是通知需要被中断的线程自行处理

线程中断的几个方法：

• Thread.interrupt()：中断线程。这里的中断线程并不会立即停止线程，而是设置线程的中断状态为true（默认是false）；
• Thread.interrupted()：测试当前线程是否被中断。线程的中断状态受这个方法的影响，意思是调用一次使线程中断状态设置为true，连续调用两次会使得这个线程的中断状态重新转为false；
• Thread.isInterrupted()：测试当前线程是否被中断。与上面方法不同的是调用这个方法并不会影响线程的中断状态。

在线程中断机制里，当其他线程通知需要被中断的线程后，线程中断的状态被设置为true，但是具体被要求中断的线程要怎么处理，完全由被中断线程自己而定，可以在合适的实际处理中断请求，也可以完全不处理继续执行下去。