乐趣区

Java多线程多线程的状态

jiezi

参考官网文档：

​

获取状态的办法:

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 状态，后半句不太好了解，具体了解如下：

  1. 以后线程取到了锁进入了同步代码块 RUNNABLE 状态
  2. 调用了 wait 办法开释了锁，进入期待 WAITING 状态
  3. 收到其它线程的唤醒告诉（notiify）
  4. 须要从新获取锁进入代码块儿在之前 wait 的中央继续执行，但不能立即获取锁，即进入 BLOCKED 状态；

参考官网文档：

https://docs.oracle.com/en/ja…

— END —

马上关注    /     码上杂谈

退出移动版