Java线程的生命周期和状态控制_线程生命周期状态与调度英文翻译-CSDN博客

本文链接：https://blog.csdn.net/HoldonWithYourGoal/article/details/103739624

生命周期

Java线程有新建（New）、就绪（Runable）、执行（Running）、阻塞（Blocked）、死亡（Dead）五种状态。

新建状态
线程创建完成时，即new Thread(…)还没调用start前的状态。
就绪
调用线程的start()方法后，进入就绪状态，等待CPU资源。就绪状态的线程由Java运行时系统的线程调度成都（thread scheduler）来调度。
执行
就绪状态的线程获得CPU执行权后，开始执行run()方法。
阻塞
线程没有执行完，由于某种原因（IO操作等）让出CPU执行权，自身进入阻塞状态。
死亡
线程执行完成，或者执行过程中出现异常，线程就会进入死亡状态。

状态控制

wait

wait/notify/notifyAll是Object类的方法。可以实现该Object所在的线程Running -> Blocked的状态变化。

方法	作用
void wait()	将该对象所在的所有线程挂起（及让其进入阻塞Blocked状态），知道notify()或者notifyAll()方法来唤醒
void wait(long timeout)	将对象所在的所有线程挂起，如果没有notify/notifyAll唤醒，则在timeout毫秒后自动唤醒。wait()与wait(0)等效
void wait(long timeout, int nanos)	挂起线程，若未被唤醒则在timeout毫秒+nanos纳秒后唤醒。本意是更精确地控制唤醒时间，但是从源码（1.8）看，纳秒只实现了四舍五入。

需要注意：

直接调用wait方法会抛出java.lang.IllegalMonitorStateException异常。
因为wait方法是一个本地native方法，其实现是通过获取对象监视器的所有权，而对象所有权只有一个线程可以获取，获取了对象监视器等于给对象加锁，从而实现线程的阻塞。而Java中只能通过Synchronized关键字获取对象监视器所有权。翻译成JVM指令就是：
montiorenter 进入并获取对象监视器
monitorexit 释放并退出对象监视器
所以，wait方法必须在同步范围内使用。
调用wait()方法后，线程会释放对该对象monitor的所有权（锁）。
阻塞线程被唤醒后，要竞争到monitor所有权才能继续执行。

notify/notifyAll

notify/notifyAll是Object类的方法。可以实现该Object所在的线程Blocked -> Runnable的状态变化。

方法	作用
void notify()	唤醒该对象阻塞状态的线程，即在等待monitor的线程
void notifyAll()	与notify()方法的区别是，notify()只能唤醒一个等待monitor的线程，而notifyAll()可以唤醒所有等下monitor的锁。

sleep

sleep()是Thread类的方法。可以实现当前线程Running->Blocked的状态变化。
Thread.sleep(long timeout)的作用是让当前线程暂停timeout毫秒，与wait()的区别是，wait方法依赖于同步，需要释放对象监视器才能阻塞线程；而sleep只是暂时释放CPU执行权，并不释放锁。

yield

yield()是Thread类的方法。可以实现当前线程Running->Runnable的状态变化。
yield()目的是暂停当前线程，让出资源给优先级更高的线程。
不能指定暂停时间，也不能保证线程能马上停止。

public class TestYield implements Runnable {

    @Override
    public void run() {
        for (int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            Thread.yield();
        }
    }

    public static void main(String[] args) {
        TestYield runnable = new TestYield();
        new Thread(runnable, "A").start();
        new Thread(runnable, "B").start();
    }
}

A:0
B:0
A:1
B:1
A:2
B:2
A:3
B:3
A:4
B:4
A:5
B:5
A:6
B:6
A:7
B:7
A:8
B:8
A:9
B:9

可以看出yield()可以实现线程交替执行，不过这种交替得不到保证，源码也做出声明。

/**
     * A hint to the scheduler that the current thread is willing to yield
     * its current use of a processor. The scheduler is free to ignore this
     * hint.
     *
     * <p> Yield is a heuristic attempt to improve relative progression
     * between threads that would otherwise over-utilise a CPU. Its use
     * should be combined with detailed profiling and benchmarking to
     * ensure that it actually has the desired effect.
     *
     * <p> It is rarely appropriate to use this method. It may be useful
     * for debugging or testing purposes, where it may help to reproduce
     * bugs due to race conditions. It may also be useful when designing
     * concurrency control constructs such as the ones in the
     * {@link java.util.concurrent.locks} package.
*/

这段话主要说明了三个问题：

调度器可能会忽略该方法。
使用的时候要仔细分析和测试，确保能达到预期的效果。
很少有场景要用到该方法，主要使用的地方是调试和测试。

join

join()是Thread类的方法。可以实现当前线程Running->Blocked->Runnable的状态变化。
Thread.join()的作用是让父线程等待子线程执行完成后再执行，换句话说就是将异步执行的线程合并为同步线程。
JDK1.8源码：

public final void join() throws InterruptedException {
        join(0);
    }

 public final synchronized void join(long millis)
    throws InterruptedException {
       long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

public final synchronized void join(long millis, int nanos)
    throws InterruptedException {

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        join(millis);
    }

可以看出，join方法是用wait()阻塞当前线程（主线程），如果子线程还在执行，继续阻塞主线程。
nojoin
join