java中的线程状态流转

一、java中6中线程状态

java中的线程状态。在Thread类中有一个State的枚举类，表示当前线程所处的状态。

线程状态一共有6种：

1.  新建状态 (New) 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
2.  就绪状态 (Runnable): 也被称为“可执行状态”，此时等待资源如os处理器资源。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。(java中运行与就绪统称为可运行状态)
3. 阻塞状态 (Blocked)  : 等待监视器锁。阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
        a.  等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
        b.  同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
       c.  其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等       待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
4. 等待状态 (Waiting)。等待另外一个线程的特定操作
5. 超时等待（timed_waiting）。等待特定的时间
6.  运行状态 (Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。(java中运行与就绪统称为可运行状态)
7. 死亡状态 (Dead)    : 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

public enum State {
    /**
     * Thread state for a thread which has not yet started.
     * 尚未启动的线程的线程状态
     */
    NEW,

    /**
     * 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.
     * 可运行线程的状态。 runnable状态的线程正在Java虚拟机中执行，但它可能在等待来自操作系统的资源，如处理器。
     */
    RUNNABLE,

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     * 等待监视器锁的线程状态
     * 阻塞状态的线程，正在等待获得监视器锁，从而能进入同步块/方法，或在调用后重新输入同步块/方法
     */
    BLOCKED,

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread * to perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     * 等待的线程状态
     * 处于等待状态的线程是由于调用了一下任意一个方法
     *   Object.wait()
     *   Thread.join()
     *   LockSupport.park
     *  处于WAITING状态的线程等待另外一个线程执行指定的动作 
     *  如：调用一个对象的Object.wait()正在等待另外一个线程调用该对象的Object.notify()或Object.notifyAll()；
     *  调用Thread.join()的线程等待一个指定的线程执行结束
     */
    WAITING,

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     * 等待指定时间的线程状态
     * 处于TIMED_WAITING的线程由于调用了以下任意一个方法（等待时间大于0）
     *   Thread.sleep(long millis)
     *   Object.wait(long timeout)
     *   Thread.join(long millis)
     *   LockSupport.parkNanos
     *   LockSupport.parkUntil
     */
    TIMED_WAITING,

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     * 已终止的线程状态
     * 线程已完成执行
     */
    TERMINATED;
}

二、java中线程状态流转图

线程之间的状态转换图：

三、操作线程状态流转的方法及原理

1. wait(), notify(), notifyAll()等方法介绍

在Object.java中，定义了wait(), notify()和notifyAll()等接口。

    // wait方法
    public final native void wait(long timeout) throws InterruptedException;

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

    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

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

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

    // notify 方法
    public final native void notify();

    public final native void notifyAll();

Object类中关于等待/唤醒的API详细信息如下：

notify：唤醒在此对象监视器上等待的线程

1. notify()        -- 唤醒在此对象监视器上等待的单个线程。
2. notifyAll()   -- 唤醒在此对象监视器上等待的所有线程。

wait：让当前线程处于等待(阻塞)状态，也会让当前线程释放它所持有的锁

1. wait()：让当前线程处于“等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，当前线程被唤醒(进入就绪状态)。
2. wait(long timeout) ：让当前线程处于“等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量，当前线程被唤醒(进入“就绪状态”)。
3. wait(long timeout, int nanos) ：让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过某个实际时间量，或者其他某个线程中断当前线程，当前线程被唤醒(进入就绪状态)。

2. 为什么notify(), wait()等函数定义在Object中，而不是Thread中

Object中的wait(), notify()等函数，和synchronized一样，会对“对象的同步锁”进行操作。

思考1：wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行。线程调用wait()之后，会释放它锁持有的“同步锁”；而且，根据前面的介绍，我们知道：等待线程可以被notify()或notifyAll()唤醒。现在，请思考一个问题：notify()是依据什么唤醒等待线程的？或者说，wait()等待线程和notify()之间是通过什么关联起来的？答案是：依据“对象的同步锁”。

负责唤醒等待线程的那个线程(我们称为“唤醒线程”)，它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个)，并且调用notify()或notifyAll()方法之后，才能唤醒等待线程。虽然，等待线程被唤醒；但是，它不能立刻执行，因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“对象的同步锁”之后，等待线程才能获取到“对象的同步锁”进而继续运行。

总之，notify(), wait()依赖于“同步锁”，而“同步锁”是对象锁持有，并且每个对象有且仅有一个！这就是为什么notify(), wait()等函数定义在Object类，而不是Thread类中的原因。

 3. yield()介绍

yield()：当前线程调用此方法，放弃获取的CPU时间片，但不释放锁资源。由“运行状态”进入到“就绪状态”。让相同优先级的等待线程获取执行权，但并不保证其它具有相同优先级的线程就一定能获得执行权，也可能是当前让步线程被线程调度程序再次选中。

4. Thread.yield() 与 Object.wait()的比较

wait() 的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时，也会释放同步锁。而yield()的作用是让步，它也会让当前线程离开“运行状态”。它们的区别是：
(01) wait()是让线程由“运行状态”进入到“等待(阻塞)状态”，而yield()是让线程由“运行状态”进入到“就绪状态”。
(02) wait()是会线程释放它所持有对象的同步锁，而yield()方法不会释放锁。

5.Thread.join()

调用thread1.join()方法后，等待thread1线程执行完毕后，join后面的语句才会执行，在thread1执行完毕前，当前线程处于waiting状态

实例：

public class TestJoin {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("thread1 start...");
                try {
                    Thread.sleep(2000L);
                } catch (Exception e) {
                }
                System.out.println("thread1 end...");
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                System.out.println("thread2 start...");
                try {
                    t1.join();
                } catch (Exception e) {
                }
                System.out.println("thread2 end...");
            }
        };
        t1.start();
        t2.start();
    }
}

---

执行结果：

thread2 start...
thread1 start...
thread1 end...
thread2 end...

Process finished with exit code 0