Java多线程多线程的状态

30次阅读

共计 2187 个字符，预计需要花费 6 分钟才能阅读完成。

参考官网文档：

获取状态的办法:

Thread.getState()

枚举解释:

NEW:

创立线程未启动 start 办法;

Thread thread = new Thread();

RUNNABLE:

执行了该线程的 start 办法，在 Java 虚拟机中执行，但有可能在期待操作系统的其它资源，比方 CPU；

thread.start();

BLOCKED:

当一个线程期待一个 monitor 锁的时候，状态为 BLOCKED，比方被 synchronized 关键字润饰的办法或代码块，如下示例：


public class ThreadStateBlockTest implements Runnable {public static void main(String[] args) {ThreadStateBlockTest threadStateBlockTest = new ThreadStateBlockTest();
        Thread thread1 = new Thread(threadStateBlockTest);
        thread1.start();
        Thread thread2 = new Thread(threadStateBlockTest);
        thread2.start();
        System.out.println("thread1 state:" + thread1.getState());
        System.out.println("thread2 state:" + thread2.getState());
    }

    @Override
    public void run() {blockMethod();
    }

    /**
     * 阻塞的办法
     */
    private synchronized void blockMethod() {
        try {Thread.sleep(1000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
}

执行后果：

thread1 state: TIMED_WAITING
thread2 state: BLOCKED

线程 1，2 同时执行 1 先拿到了 monitor 锁进入 synchronize 润饰的办法，此时 sleep 不能立刻执行实现，线程 2 再进入就是期待获取 monitor 锁，状态为 BLOCKED

WAITING：

TIMED_WAITING:

调用了 Object.wait() 办法后，以后线程会进入 WAITING 状态；

调用了 Object.wait(time) 或 Thread.sleep(time) 则线程会进入 TIMED_WAITING;

TERMINATED:

Thread state for a terminated thread. The thread has completed execution.

线程的 run 办法执行完结；

线程的生命周期 ：

如图：

新建线程后进入 NEW 状态，NEW 只能进入 RUNNABLE，RUNNABLE 执行 run 办法完结进入 TERMINATED，3 个状态不可逆；

右侧为 3 个阻塞状态：

如果 run 办法遇到 synchronize 润饰的代码块或办法却没有取到 monitor 锁就进入 BLOCKED 状态；

BLOCKED 取到 monitor 能够再次进入 RUNNABLE 状态；

RUNNABLE 状态执行了 obj 的 wait() 或 Thread.join() 办法进入 WAITING 状态;

如果有其它线程唤醒调用了 notify() 或 notifyAll() 办法则再次进入 RUNNABLE 状态;

TIMED_WAITING 同 WAITING, 是带 time 入参的的办法：sleep(time), wait(time),join(time)；

wait()、notify()、notifyAll()

wait() 办法做了什么？

获取到 monitor 锁的线程，执行了 wait 办法后会放弃锁，进入期待状态；

notify() 和 notifyAll()?

前者唤醒一个期待的线程（无奈指定，线程调度器自调度），后者唤醒所有期待的线程，而后再抢锁；

sleep(time) 并不会开释锁，time 超时后会继续执行；

须要阐明的一点是 WAITING 状态可能变为 BLOCKED 状态，场景如官网文档里对 BLOCKED 状态的解释

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 Object.wait.

前半句了解就是进入 synchronized 代码库前期待 monitor 锁时为 BLOCKED 状态，后半句不太好了解，具体了解如下：