多线程-线程状态

常见的线程状态有六种：

1.新建状态(new)：当我们new 了一个线程，但是没有调用start()方法；

2.Runnable状态：此状态包含两个状态：

就绪状态(Ready)：当线程调用了start()方法时,线程就进入了就绪状态；
运行状态(Running)：当该线程被系统的调度器选中就会进入运行状态；

3.结束状态(Taminate)：如果不出意外，当线程执行完毕以后就会进入死亡状态，也就是结束状态；

4.(Timed_Waiting)按照时间等待：在运行过程中如果调用以下方法就会进入按时间等待的状态:

LockSupport.parkNanos
LockSupport.parkUntil
Thread.sleep(time)
o.wait(time)
t.join(time)

5.(Wating)等待: 在运行过程中，如果调用以下方法就会进入Waiting状态：

o.wait()
t.join()
LockSupport.park()

当调用以下方法就会回到Running状态：

o.notify() / notifyAll()
LockSupport.park()

6.阻塞状态(Blocked)：在同步代码块的情况下，如果线程没有获得锁，就会进入阻塞状态；

下面是线程状态的简图：

话不多说直接上代码：

package com.example.demo.threaddemo.juc_001;

/**
 * 线程的状态有6种状态:
 *    1、当我们创建一个线程时，还没有调用start()方法时，此时该线程处于新建状态；
 *
 *    2、线程调用start()方法时，他会被线程调度器来执行，也就是交给操作系统来执行，操作系统执行时整个状态称为
 *       Runnable ,Runnable内部又分为两个状态: ready(就绪状态) running(运行状态)
 *       ****等到调用yield() 方法时,线程回到等待队列，处于就绪状态，等到线程调度器选中又进入running状态
 *       (1)就绪状态就是扔到CPU的等待队列中去，等待CPU的执行；
 *       (2)等真正扔到CPU上去执行的时候，才叫做running状态；
 *
 *    3、如果线程顺利执行完了，就进入了Teminated(结束状态)
 *       在runnable这个状态中还会出现其他状态的变迁，例如TimeWating 、Wating 、Blocked;
 *
 *    4、在同步代码块的情况下没获得锁就会进入阻塞状态，获得锁就会进入运行状态；
 *
 *    5、在运行的过程中如果调用了  o.wait() 、t.join() 、LockSupport.park()方法进入Waiting状态 ，调用o.notify()
 *       notifyAll() 、 LockSupport.unpark()方法又会回到running状态；
 *
 *    6、TimeWating是按照时间等待，时间结束以后自己就回去了，Thread.sleep(time)、 o.wait(time)、 t.join(time)、
 *       LockSupport.parkNanos()、LockSupport.parkUntil()
 */
public class Thread_State {

    public static class MyThread extends Thread{

        @Override
        public void run() {
            System.out.println("A开始-------------"+ this.getState());
            for (int i = 0; i < 20; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public static void main(String[] args) {
            MyThread myThread = new MyThread();
            System.out.println("new MyThread"+ myThread.getState());
            myThread.start();
            try {
                myThread.sleep(3000);
                System.out.println("myThread.sleep()"+ myThread.getState());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {
                myThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(myThread.getState());
        }
    }
}