Java 线程的状态

Java 中的线程有 6 种状态

// java.lang.Thread
public enum State {
	NEW,
	RUNNABLE,
	BLOCKED,
	WAITING,
	TIMED_WAITING,
	TERMINATED;
}
//这些状态是虚拟机状态，它不反映任何操作系统的线程状态。

新建(NEW)

新创建了一个线程对象，还未调用 start() 方法。

public class Main {
    public static void main(String[] args) {
        Thread threadA = new Thread("threadA");
        System.out.println(threadA.getState()); // NEW
    }
}

可运行(RUNNABLE)

线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权(时间片) 。
RUNNABLE 在 Java 中就是运行状态的标识。但它可能正在等待来自于操作系统的其它资源，比如处理器。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < Integer.MAX_VALUE; i++) {
                    System.out.println(i);
                }
            }
        }, "RUNNABLE-Thread");
        thread.start();
    }
}

等待(WAITING)

运行中（Running）的线程执行了4个方法中的任意方法：

1. Object 的wait()方法，并且没有使用 timeout 参数
2. Thread 的join()方法，没有使用 timeout 参数
3. LockSupport 的 park() 方法
4. Condition 的 await() 方法

处于WAITING状态的线程会等待另外一个线程处理特殊的行为。 举个例子，如果一个线程调用了一个对象的wait方法，那么这个线程就会处于waiting状态直到另外一个线程调用这个对象的notify或者notifyAll方法后才会解除这个状态

public class Main {
    public static void main(String[] args) {
        Object o = new Object();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (o) {
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "threadA");
        threadA.start();
    }
}

有时间等待(TIMED_WAITING)

有等待时间的等待状态，比如调用了以下几个方法中的任意方法，并且指定了等待时间，线程就会处于这个状态。

1. Thread.sleep 方法
2. Object的 wait 方法，带有时间
3. Thread.join 方法，带有时间
4. LockSupport 的 parkNanos 方法，带有时间
5. LockSupport 的 parkUntil 方法，带有时间

public class Main {
    public static void main(String[] args) {
        Object o = new Object();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (o) {
                    try {
                        o.wait(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "threadA");
        threadA.start();
    }
}

阻塞(BLOCKED)

阻塞状态是指线程因为某种原因放弃了cpu 使用权，暂时停止运行。直到线程进入可运行(RUNNABLE)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。
阻塞的情况分两种：

• 同步阻塞：运行(running)的线程进入了一个synchronized方法，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
• 其他阻塞：运行(running)的线程发出了I/O请求时，JVM会把该线程置为阻塞状态。当I/O处理完毕时，线程重新转入可运行(RUNNABLE)状态。

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName() + " invoke");
                    try {
                        Thread.sleep(20000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "BLOCKED-Thread-A");
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName() + " invoke");
                    try {
                        Thread.sleep(20000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "BLOCKED-Thread-B");
        threadA.start();
        threadB.start();
    }
}

线程A和线程B都需要持有lock对象的锁才能调用方法。如果线程A持有锁，那么线程B处于BLOCKED状态；如果线程B持有锁，那么线程A处于BLOCKED状态。

死亡(TERMINATED)

线程的run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。并且死亡的线程不可再次复生。

Thread threadA = new Thread();
threadA.start();
try {
    Thread.sleep(5000l);
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println(threadA.getState()); // TERMINATED

---

1. RUNNABLE，对应"就绪"和"运行"两种状态，也就是说处于就绪和运行状态的线程在java.lang.Thread中都表现为"RUNNABLE"
2. BLOCKED，对应"阻塞"状态，此线程需要获得某个锁才能继续执行，而这个锁目前被其他线程持有，所以进入了被动的等待状态，直到抢到了那个锁，才会再次进入"就绪"状态。
3. WAITING，对应"阻塞"状态，代表此线程正处于无限期的主动等待中，直到有人唤醒它，它才会再次进入就绪状态
4. TIMED_WAITING，对应"阻塞"状态，代表此线程正处于有限期的主动等待中，要么有人主动唤醒它，要么等待够了一定时间之后，才会再次进入就绪状态。

BLOCKED 与 WAITING的区别？

BLOCKED是指线程正在等待获取锁；WAITING是指线程正在等待其他线程发来的通知（notify），收到通知后，可能会顺序向后执行（RUNNABLE），也可能会再次获取锁，进而被阻塞住（BLOCKED）。

Thread.sleep() 与 Object.wait() 最重要的区别就是：
sleep()在执行时，保持对象锁。
而wait()在执行时，释放对象锁。
另外：

• wait, notify 和 notifyAll 只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

---

Thread.yield()
译为线程让步，就是说当一个线程使用了这个方法之后，它会把自己 CPU 执行时间(时间片)让掉，让自己或者其它的线程运行，注意是让自己或者其他线程运行，并不是单纯的让给其他线程。
它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用 yield() 之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

举个例子：一帮朋友在排队上公交车，轮到 Yield 的时候，他突然说：我不想先上去了，咱们大家来竞赛上公交车。然后所有人就一块冲向公交车，有可能是其他人先上车了，也有可能是 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.

查看 API 可以看到，线程调度器可以忽略该方法。

参考：
https://fangjian0423.github.io/2016/06/04/java-thread-state/
http://www.cnblogs.com/dolphin0520/p/3920357.html
https://www.zhihu.com/question/56494969
https://www.uml-diagrams.org/java-thread-uml-state-machine-diagram-example.html