Java中线程状态

这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析。
线程状态****发生条件NEW(新建状态)创建了一个线程，启动之前处于该状态RUNNABLE(可运行状态)线程正在执行任务(run方法中的代码）BLOCKED(阻塞状态)获取synchronized锁对象失败WAITING(无线等待状态)无限等待状态。获取Lock锁对象失败，就处于该状态，或者调用wait()方法 。 TIMED_WAITING(限时等待状态)线程正在执行sleep()方法的时候TERMINATED(消亡状态)线程执行完任务后

NEW(新建状态)：创建了一个线程，启动之前处于该状态

public class test01 {
     public static void main(String[] args) {
         //创建线程
         Thread t = new Thread();
         //获取线程状态
          State s = t.getState();
         System.out.println(s);
    }
}

RUNNABLE(可运行状态)：线程正在执行任务(run方法中的代码）

public class test02 {
    public static void main(String[] args) throws InterruptedException {
        //创建一个Runnable类型对象接口，覆盖重写run方法
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for(;;); //死循环，处于一直运行状态
            }
        };
        Thread t = new Thread(r);
        //启动线程
        t.start();
        Thread.sleep(1000);//100毫秒保证子线程开始执行for(;;);这一行代码了
        System.out.println(t.getState());    //RUNNABLE
    }
}

BLOCKED(阻塞状态)：获取synchronized锁对象失败

public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                synchronized(this) {
                    for(;;);
                }
            }
        };
        Thread t1 = new Thread(r);
        t1.start();
        Thread t2 = new Thread(r);
        t2.start();
        
        Thread.sleep(100);//100毫秒保证两个子线程已经启动，并开始执行代码了
        //获取并打印线程的状态
        System.out.println(t1.getState());
        System.out.println(t2.getState());
  }
}

WAITING(无线等待状态)：无限等待状态。获取Lock锁对象失败，就处于该状态，或者调用wait()方法 。

public class test04 {
    public static void main(String[] args) throws InterruptedException {
        //创建Lock锁
        Lock lock = new ReentrantLock();
        
        Runnable r = new Runnable() {
            @Override
            public void run() {
                    //上锁
                    lock.lock();
                    for(;;);
            }
        };
        Thread t1 = new Thread(r);
        t1.start();
        Thread t2 = new Thread(r);
        t2.start();
        Thread.sleep(100);//100毫秒保证两个子线程已经启动，并开始执行代码了
        //获取并打印线程的状态
        System.out.println(t1.getState());
        System.out.println(t2.getState());
    }
}

TIMED_WAITING(限时等待状态)：线程正在执行sleep()方法的时候

public class test05 {
    public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }
        };
        Thread t = new Thread(r);
        t.start();
        
        Thread.sleep(100);//100毫秒保证子线程开始执行Thread.sleep(1000000);这一行代码了
        //获取并打印线程的状态
        System.out.println(t.getState());
    }
}

TERMINATED(消亡状态)：线程执行完任务后

public class test06 {
    public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("aaaa");
            }
        };
        Thread t = new Thread(r);
        t.start();
        
        Thread.sleep(10000);//1000毫秒子线程一定把任务执行完毕了
        //获取并打印线程的状态
        System.out.println(t.getState());
      
    }
    
}