线程状态是五种还是六种

从操作系统层面上描述线程状态

• 初始状态：仅仅是语言层面创建了线程对象,还没有与操作系统相关联.比如new 了一个Thread对象还没有调用start方法
• 可运行状态：仅仅是语言层面创建了线程对象,还没有与操作系统相关联.比如new 了一个Thread对象还没有调用start方法
  • 这里运行状态和可运行状态是能进行上下文切换的,当CPU时间片用完了,线程就会从运行状态变为可运行状态.,导致线程上下文切换
• 阻塞状态 : 该线程调用了一些阻塞API,如BIO读写文件,这时该线程实际不会用到CPU,就会导致上下文切换,从运行状态变为阻塞状态.线程调度器不会分配给[阻塞状态线程]CPU时间片的,但是会分配给可运行状态的线程. 当读写文件操作完毕,会由操作系统来唤醒阻塞状态的线程, 就会从阻塞状态变为可运行状态
• 终止状态：阻塞状态 : 该线程调用了一些阻塞API,如BIO读写文件,这时该线程实际不会用到CPU,就会导致上下文切换,从运行状态变为阻塞状态.线程调度器不会分配给[阻塞状态线程]CPU时间片的,但是会分配给可运行状态的线程. 当读写文件操作完毕,会由操作系统来唤醒阻塞状态的线程, 就会从阻塞状态变为可运行状态

从java API层面上理解线程的6中状态

6种状态是JavaAPI层面上的.
根据Thread.State 枚举 ,分为6种状态.

• NEW : 仅仅是语言层面创建了线程对象,还没有与操作系统相关联.比如new 了一个Thread对象还没有调用start方法
• RUNNABLE : JavaAPI层面上状态涵盖了操作系统层面的[可运行状态],[运行状态] 和[阻塞状态]
  • RUNNABLE : JavaAPI层面上状态涵盖了操作系统层面的[可运行状态],[运行状态] 和[阻塞状态]
• WAITING: 当调用线程的join方法,LockSupport.park()方法或者用synchronized(obj)获取了对象锁后,调用obj.wait()方法时.
• TIMED_WAITING : 当用synchronized获取对象锁后,调用wait(long n)方法时候,当调用join(long n) ,调用sleep(long n),或者调用LockSupport的有时限的方法时
• TERMINATED : 当当前线程的所有代码执行完成之后,表示线程已经执行完毕,生命周期已经结束了,不会再转换为其他状态.

@Slf4j(topic = "c.TestState")
public class TestState {
 
    public static void main(String[] args) {
        //NEW 状态 -> 没有调用start方法->只创建了线程对象没有启动该线程
        Thread t1 = new Thread(() -> {
            log.debug("running...");
        },"t1");
        //Runnable状态中的可运行状态
        Thread t2 = new Thread(() -> {
            while(true) {
 
            }
        },"t2");
        //TIMED_WAITING状态
        Thread t3 = new Thread(()->{
            synchronized (TestState.class) {
                try {
                    Thread.sleep(100000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t3");
        //WAITING状态
        Thread t4 = new Thread(()->{
            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t4");
        // ->终止状态
        Thread t5 = new Thread(()->{
           log.debug("running....");
        },"t5");
        //BLOCKED 状态
        Thread t6 = new Thread(()->{//后获取到锁
           synchronized (TestState.class) {
               log.debug("running");
           }
        },"t6");
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        System.out.println("t1 : " + t1.getState());
        System.out.println("t2 : " + t2.getState());
        System.out.println("t3 : " + t3.getState());
        System.out.println("t4 : " + t4.getState());
        System.out.println("t5 : " + t5.getState());
        System.out.println("t6 : " + t6.getState());
    }
}

线程的状态转换.
NEW --> RUNNABLE
当调用了 t.start()方法的时候,由NEW --> RUNNABLE

1.RUNNABLE <–> WAITING
t线程用synchronized(obj) 获取了对象锁之后

• 调用了obj.wait()方法的时候,t线程就从 RUNNABLE --> WAITING
• 调用了 obj.notify() ,obj.notifyAll() ,t.interrupt() 时候
  • 竞争锁成功,t线程从 WAITING --> RUNNABLE
  • 竞争锁失败,t线程从 WAITING --> BLOCKED
    比如两个线程竞争同一把锁,其中主线程使用notifyAll把它们全唤醒,那必然有一个线程竞争锁成功从WAITING --> RUNNABLE,必然有一个线程竞争锁失败从WAITING --> BLOCKED

2.RUNNABLE <–> WAITING

• 当线程调用 t.join() 方法时,当前线程从 RUNNABLE --> WAITING
• t线程运行结束,或者调用当前线程的interrupt()方法的时候,当前线程就从WAITING–>RUNNABLE状态

3.RUNNABLE <–> WAITING

• 当前线程调用LockSupport.park()方法的时候会让当前线程从RUNNABLE–>WAITING
• 当调用LockSupport.unpark方法或者调用线程的interrupt(),会让目标线程从WAITING–>RUNNABLE

1.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

2.RUNNABLE <–> TIMED_WAITING

• 当前线程调用 t.join(long n) 方法时,当前线程从 RUNNABLE --> TIMED_WAITING
• 当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从TIMED_WAITING --> RUNNABLE

3. RUNNABLE <–> TIMED_WAITING

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

4.RUNNABLE <–> TIMED_WAITING

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

RUNNABLE <–> BLOCKED

• 当t线程用synchronized(obj)获取了对象锁时如果竞争失败就会从 RUNNABLE–>BLOCKED
• 持有obj锁线程的同步代码块执行完毕,会唤醒该对向上的所有BLOKED的线程,如果其中t线程竞争成功,从BLOKED–>RUNNABLE ,其他失败的线程仍然是 BLOCKED.

RUNNABLE <–> TERMINATED
当当前线程的所有代码执行完成之后,表示线程已经执行完毕,生命周期已经结束了,不会再转换为其他状态.