标签：状态 RUNNABLE obj 05 -- WAITING 线程 TIMED

操作系统中进程状态

1.运行态：进程正在处理机上运行。在单处理机的环境下，每个时刻只有一个进程处于运行态
2.就绪态：进程获得了除处理机外的一切所需资源，一旦得到处理机，就可以立刻运行。系统中处于就绪状态的进程可能有多个，通常把他们放到就绪队列中。
3.阻塞态：又叫等待态。进程正在等待某一事件，所以暂停运行。比如你在等待除处理机之外的某个资源可用，或者等待输入输出操作完成。这时候即使处理机空闲，这个进程仍然不能运行
4.创建态：进程正在被创建，还没被转到就绪态。因为其实创建进程也是需要多个步骤的：首先申请一个空白的PCB，并向PCB中填写一些控制和管理进程的信息，然后由系统为该进程分配运行时所需要的资源，最后把该进程转入就绪态
5.结束态：进程正从系统中消失，可能是正常结束也可能是中断退出运行，进程结束时，需要先置为结束态，然后再回收资源。

Java中线程的状态

NEW：线程刚被创建，但是还没有调用start()方法
RUNNABLE:当调用了start()方法后。Java中的RUNNABLE状态涵盖了操作系统中的就绪状态，运行状态和阻塞状态。
BLOCKED,WAITING,TIMED_WAITING是Java对于阻塞状态的划分
TERMINATED:当线程代码运行结束

线程状态转换

图示

解析

情况1：NEW->RUNNABLE

当调用t.start()方法时，由NEW->RUNNABLE

情况2：RUNNABLE<->WAITING

t线程调用synchronized(obj)获得了对象锁之后
*调用obj.wait()方法，t线程从RUNNABLE转为WAITING
*调用obj.notify()，obj.notifyAll()时，竞争锁成功，t线程从WAITING->RUNNABLE;竞争锁失败，t线程从WAITING变为BLOCKED

//通过以下代码验证竞争锁成功与失败之后线程状态的变化
@Slf4j(topic = "ch.TestWaitNotify04")
public class TestWaitNotify04 {
    final static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行...");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其他代码...");
            }
        }, "t1").start();
        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行...");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其他代码...");
            }
        }, "t2").start();
        Thread.sleep(50);
        log.debug("去唤醒");
        synchronized (obj) {
            obj.notifyAll();
        }
    }
}

情况3：RUNNABLE<->WAITING

当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING，注意是当前线程在t 线程对象的监视器上等待
t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE

情况4：RUNNABLE <--> WAITING

当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING
调用 LockSupport.unpark(目标线程) 或调用了线程的 interrupt() ，会让目标线程从 WAITING -->
RUNNABLE

情况5：RUNNABLE <--> TIMED_WAITING

t线程用 synchronized(obj) 获取了对象锁后
调用obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING
t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
竞争锁成功，t 线程从 TIMED_WAITING --> RUNNABLE
竞争锁失败，t 线程从 TIMED_WAITING --> BLOCKED

情况6：RUNNABLE <--> TIMED_WAITING

当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING
注意是当前线程在t线程对象的监视器上等待
当前线程等待时间超过了n毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从
TIMED_WAITING --> RUNNABLE

情况7：RUNNABLE <--> TIMED_WAITING

当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED_WAITING
当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE

情况8：RUNNABLE <--> TIMED_WAITING

当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线程从 RUNNABLE --> TIMED_WAITING
调用 LockSupport.unpark(目标线程) 或调用了线程的 interrupt() ，或是等待超时，会让目标线程从TIMED_WAITING--> RUNNABLE

情况9：RUNNABLE <--> BLOCKED

t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED
持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED

情况10：RUNNABLE <--> TERMINATED

当前线程所有代码运行完毕，进入TERMINATED

总结：阻塞线程的方法有wait,join,park。将线程阻塞一定时间的方法有wait(时间),join（时间）,sleep(时间)，parkNanos(时间)

标签：状态,RUNNABLE,obj,05,--,WAITING,线程,TIMED
From： https://www.cnblogs.com/wbstudy/p/16599163.html

并发学习记录05：线程状态和操作系统中进程状态对比