线程的6大状态

makabaka_haha

于 2022-10-08 16:10:38 发布

阅读量120

点赞数 1

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/makabaka_haha/article/details/127210602

版权

线程的状态：线程的生命周期

6种状态

（NEW状态和TERMINATED状态只会出现一次）

1.NEW：新建状态
一个线程创建好后，启动之前就处于该状态

2.RUNNABLE：可运行状态
线程正在执行任务就处于该状态

3.BLOCKED：阻塞状态:线程处于阻塞状态，等待监视锁，可以重新进行同步代码块中执行
获取synchronized锁对象失败，就处于该状态

4.WAITING：无限等待状态
获取Lock锁对象失败，就处于该状态

5.TIMED_WAITING:计时等待状态
一个线程正在执行sleep方法，就处于该状态

6.TERMINATED：消亡状态
线程执行任务完，线程销毁后，就处于该状态

1. NEW:创建后，启动前。线程就处于该状态
public class NEW {
   public static void main(String[] args) {
       Thread t1 = new Thread("t1") {
   @Override
   public void run() {
   System.out.println("running....");
   }
   };
   System.out.println("t1的状态是: "+t1.getState());
   }

}

2.//Runnable:线程正在执行任务就处于该状态

//start启动了线程,线程用了while死循环

public class Runnable1 {
public static void main(String[] args) {
Thread t2 = new Thread("t2") {
@Override
public void run() {
while (true) {
// 用了while死循环
}
}
};
t2.start();

System.out.println("t2的状态是: "+t2.getState());

}
}

3.//BLOCKED：阻塞状态:线程处于阻塞状态

//当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；

//当该线程持有锁时，该线程将变成Runnable状态。

public class BLOCKED1 {
public static void main(String[] args) throws InterruptedException {

       Runnable r = new Runnable() {
           @Override
           public void run() {
               synchronized(this) {
                   for(;;);
//               进入synchronized，没有拿到锁
               }
           }
       };
       Thread t1 = new Thread(r,"线程1");
       Thread t2 = new Thread(r,"线程2");
       t1.start();
       t2.start();
       Thread.sleep(100);
   System.out.println(t1.getState());
   System.out.println(t2.getState());
}
}

//
//                   没有争取到锁对象
// runnable----------------------->Blocked锁阻塞
//     <-----------------------
//         获取了锁对象

4.// WAITING:无限等待状态

public class WAITING{
   public static void main(String[] args) throws InterruptedException{
       Lock lock = new ReentrantLock();
       Runnable r = new Runnable() {

           @Override
           public void run() {
               lock.lock();
               for(;;);
//               没有释放锁
//               lock.unlock();
           }

       };

       Thread t1 = new Thread(r,"线程1");
       Thread t2 = new Thread(r,"线程2");

       t1.start();
       t2.start();

       Thread.sleep(100);//保证两个线程都执行到了run方法

       System.out.println(t1.getState());
       System.out.println(t2.getState());
   }
}

//
//一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。
//进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。//
//
//
//           一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的
//           Object.notify()方法或 Object.notifyAll()方法。



//                           获取锁对象，调用wait方法
//           run--------------------------------------------------->Waiting
//           <-----------------------------------------------------
//                   其他线程调用notify()/notifyAll()，获取锁对象

5.//TIMED_WAITING:计时等待状态
//进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法

//这一状态将一直保持到超时期满或者接收到唤醒通知。
//带有超时参数的常用方法有Thread.sleep 、Object.wait。

//           1.sleep(参数)2.获取锁对象之后调用wait(参数)
//   run   ------------------------------------------------------------------------>Timed Waiting
//       <-------------------------------------------------------------------------
//           1.sleep时间到2.wait时间到，并获取到锁3.其他线程调用notify并获取到锁

6.//TERMINATED://线程把任务执行完毕后，就处于该状态

   public class TERMINATED {
       public static void main(String[] args) throws InterruptedException {
           //创建Runnable类型的对象
           Runnable r = new Runnable() {
               public void run() {
                   try {
                       Thread.sleep(30000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("aaaaaaaaa");
               }
           };

           Thread t = new Thread(r);
           t.start();

           Thread.sleep(100);//保证执行下面代码的时候，子线程已经启动并且开始执行run方法中的代码
           State s = t.getState();
           System.out.println(s);
       }
   }