gorden5566的博客

/**
 * 同一时刻，一个线程只能处于一种状态，这些状态是JVM虚拟机状态，
 * 不反映任何操作系统的线程状态
 */
public enum State {
    /**
     * 线程还没有启动
     */
    NEW,

    /**
     * 表示线程可运行。该状态表示线程正在JVM中执行，但是它可能正在
     * 等待来自操作系统的其他资源，例如CPU
     */
    RUNNABLE,

    /**
     * 该状态表示线程正在等待获取 monitor 锁，以进入 synchronized 代码块
     * 或 synchronized 方法，包括被 Object.wait() 唤醒后重新进入上述代码
     */
    BLOCKED,

    /**
     * 线程处于等待状态是由于调用了以下方法之一：
     *   1. 不带超时参数的 Object.wait
     *   2. 不带超时参数的 Thread.join
     *   3. LockSupport.park
     *
     * 线程处于等待状态是在等待其他线程执行特定的操作，
     * 例如：
     *   1. 一个线程调用了某个对象的 Object.wait() 方法，它是在等待另外一个线程
     *      在该对象上执行 Object.notify() 或者 Object.notifyAll() 方法
     *   2. 一个线程调用了 Thread.join() 方法，它是在等待指定线程结束
     */
    WAITING,

    /**
     * 线程处于超时等待状态是由于调用了以下方法之一，并且带有超时参数：
     *   Thread.sleep(long)
     *   Object.wait(long)
     *   Thread.join(long)
     *   LockSupport.parkNanos
     *   LockSupport.parkUntil
     */
    TIMED_WAITING,

    /**
     * 线程已经执行完
     */
    TERMINATED;
}

public class StateNew {
    public static void main(String[] args) {
        // 创建线程对象
        Thread thread = new Thread("myThread");

        // 输出线程状态
        System.out.println(thread.getName() + ": " + thread.getState());

        // 启动线程
        thread.start();
    }
}

myThread: NEW

public class StateRunnable implements Runnable {
    public static void main(String[] args) {
        Thread thread = new Thread(new StateRunnable(), "myThread");

        thread.start();
    }

    @Override
    public void run() {
    	// 显示当前线程状态
        showState();
    }

    public void showState() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + ": " + thread.getState());
    }
}

myThread: RUNNABLE

public class StateWaiting implements Runnable {
    private Object object = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StateWaiting(), "myThread");
        thread.start();

        // 主线程等待
        thread.join();
    }

    @Override
    public void run() {
        synchronized (object) {
            try {
                // 线程等待唤醒
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class StateTimeWaiting implements Runnable {
    private Object object = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StateTimeWaiting(), "myThread");
        thread.start();

        // 主线程等待
        thread.join(1000 * 60);
    }

    @Override
    public void run() {
        synchronized (object) {
            try {
                // 线程等待唤醒
                object.wait(1000 * 60);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}