java多线程之线程的六种状态

叁歲伎倆 2023-09-25 17:46 43阅读 0赞

### 线程的六种状态 ###

*   *   *  (1) NEW(初始状态)
         *  (2) TERMINATED(终止状态 / 死亡状态)
         *  (3) RUNNABLE(运行时状态)
         *  (4) TIMED\_WAITING(超时等待状态)
         *  (5) WAITING(等待状态)
         *  (6) BLOCK(阻塞状态)
         *  sleep和wait的区别:

操作系统里的线程自身是有一个状态的,但是java Thread 是对系统线程的封装,把这里的状态又进一步细化了~~

<table> 
 <thead> 
  <tr> 
   <th>状态</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>NEW</td> 
   <td>线程还没有创建,但是线程对象已经创建出来了</td> 
  </tr> 
  <tr> 
   <td>TERMINATED</td> 
   <td>线程结束了,但是线程对象还存在</td> 
  </tr> 
  <tr> 
   <td>RUNNABLE</td> 
   <td>就绪状态,可以细分为两个状态</td> 
  </tr> 
  <tr> 
   <td>TIMED_WAITING</td> 
   <td>指超时等待状态</td> 
  </tr> 
  <tr> 
   <td>BLOCK</td> 
   <td>等待状态</td> 
  </tr> 
  <tr> 
   <td>WAITING</td> 
   <td>表示阻塞时出现的状态</td> 
  </tr> 
 </tbody> 
</table>

下面将通过代码运行结果来带大家细致了解线程运行的状态.

### (1) NEW(初始状态) ###

public static void main(String[] args) {
        
            Thread t = new Thread(()->{
        
                System.out.println("t 线程");
            });
            //获取线程的状态
            System.out.println("当前线程是 " +t.getState() + "状态");
            //调用start(),创建这个线程
            t.start();
    
        }

**NEW状态指的是** : 线程在刚刚被new出来的时候,还没有调用start()的状态.

此时可以称这个状态为: (1) 初始状态 (2) 创建状态

运行结果:

![在这里插入图片描述][e6762638d951414598667b6811bf700c.png]

### (2) TERMINATED(终止状态 / 死亡状态) ###

public static void main(String[] args) {
        
            Thread t = new Thread(()->{
        
                System.out.println("t 线程");
            });
    
            //调用start(),创建这个线程
            t.start();
            try {
        
                //由于计算机的执行速度是很快的,所以1000ms足够t线程执行完
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            //获取线程的状态
            System.out.println("当前线程是 " +t.getState() + "状态");
              t.start();
        }

如果一个线程的 `run()` 方法执行结束 该线程就会死亡,对于已经死亡的线程,无法再使用 `start()` 方法令其进入就绪.

运行结果:

![在这里插入图片描述][875b393898944dd884454a7ae3e65c8e.png]

### (3) RUNNABLE(运行时状态) ###

运行时状态可以细分为两个状态:(1) 正在运行状态`RUNNING` (2) 就绪状态`READY`

我们可以这么理解 :

(1) 例如我女朋友下班了,我**正在**带我女朋友去吃饭,此时就是**正在运行状态**.  
(2)因为我提前下班了,但是我女朋友还没有下班,所以此时我在女朋友公司门口等她,只要她下班我**随时**可以带她吃饭去,此时我就是**就绪状态**.

通过代码实现(1) :

public static void main(String[] args) {
        
            Thread t = new Thread(()->{
        
                while(true){
        
                    //什么都不打印,防止把下面的打印信息冲走
                }
            });
    
            //调用start(),创建这个线程
            t.start();
            //运行线程时判断此时的状态
            System.out.println("当先线程是 "+t.getState()+"状态");
    
        }

由于此时的 t 线程一直在执行死循环,所以 t 线程的状态是正在运行的~~

运行结果:

![在这里插入图片描述][76b77b987c344d0abcc97bc0a2070075.png]

### (4) TIMED\_WAITING(超时等待状态) ###

可以理解为,具有指定等待时间的,正在等待(阻塞)线程的线程状态,由于调用具有**指定等待时间的以下方法之一**,线程处于定时等待状态.

具有指定等待时间的方法:

(1) Thread.sleep(参数)指定时间,单位为ms  
该方法会让当前线程暂停一段时间，其他线程有机会获得 CPU 时间片。  
(2) t.join(参数)  
调用 `t.join` 的线程需要等待线程 t 执行指定时间后,才可以运行,等待的过程中是处于阻塞状态的.  
(3) wait(参数) :wait 方法提供一个带有 timeout 参数的版本, 来指定等待时间.超过这个时间之后无需其他线程调用该对象的 `notify()` 或 `notifyAll()` 方法唤醒该线程,该线程自己就会唤醒.

代码实现(1)

public static void main(String[] args) {
        
         Thread t = new Thread(()->{
        
             try {
        
             //睡眠1000ms
                 Thread.sleep(1000);
                 System.out.println("hello t");
    
             } catch (InterruptedException e) {
        
                 e.printStackTrace();
             }
         });
            //调用start(),创建这个线程
            t.start();
            
            try {
        
                //等待1000ms,此时t线程就创建结束,系统自动执行run方法里面的逻辑
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
             //运行线程时判断此时的状态
            System.out.println("当先线程是 "+t.getState()+"状态");
        }

运行结果:

![在这里插入图片描述][067e5347ab7349d8b613941b4466e80d.png]

代码实现(2)

public static void main(String[] args) throws InterruptedException {
        
            Thread t1 = new Thread(()->{
        
                while (true){
        
                    try {
        
                        //每500ms打印一次
                        Thread.sleep(500);
                        System.out.println("t1");
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
            Thread t2 = new Thread(()->{
        
                try {
        
                    //等待t1线程执行完1000ms
                    //t2线程再开始执行
                    t1.join(1000);
                    System.out.println("t2");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            //创建t1线程
            t1.start();
            //创建t2线程
            t2.start();
            //等待500ms此时两个线程都创建完毕
            Thread.sleep(500);
            System.out.println("当先线程是 "+t2.getState()+"状态");
        }

运行结果:

![在这里插入图片描述][d6d1f9b8e1604e9b813ce2649d644b77.png]

代码实现(3)

public class ThreadDemo8 {
        
    	//自己指定的锁对象
        static Object object = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            Thread t1 = new Thread(()->{
        
            //两个锁对象相同
               synchronized (object){
        
                   for (int i = 0; i < 10; i++) {
        
                       if(i == 5) {
        
                           try {
        
                               object.wait(1000);
                                //虽然过了1000ms,但是还是需要等待t2线程中锁里面的程序执行完
                               // 才可以继续执行锁.(这里是指,仅有两个锁,且锁对象相等的情况)
                           } catch (InterruptedException e) {
        
                               e.printStackTrace();
                           }
                       }
                       System.out.println(i);
                   }
               }
            });
            Thread t2 = new Thread(()->{
        
             //两个锁对象相同
                synchronized (object){
        
                    for (int i = 0; i <10 ; i++) {
        
                        try {
        
                       		 System.out.println("t2");
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
                    });
            //t1线程先创建
            t1.start();
            //等待100ms是防止t2先抢到锁
            Thread.sleep(100);
            //创建t2线程
            t2.start();
            //查看当前线程的状态
            System.out.println("当先线程是 "+t1.getState()+"状态");
        }
    }

运行结果:

![在这里插入图片描述][2eaca7baad19419f8c70285580459758.png]

### (5) WAITING(等待状态) ###

处于这种状态的线程不会被CPU分配执行时间，他们要等待的显示被唤醒，否则会处于无限期的等待状态

具有阻塞的方法:

(1)使用 `Thread.join()` 方法。该方法会让当前线程等待另一个线程终止  
(2) 使用 `Object.wait()` 方法。该方法会让当前线程等待,直到其他线程调用该对象的 notify() 或 notifyAll() 方法唤醒该线程。

我们这里只演示第一种就好~

public static void main(String[] args) throws InterruptedException {
        
            Thread t1 = new Thread(()->{
        
                while (true){
        
    
                }
            });
            Thread t2 = new Thread(()->{
        
                try {
        
                    t1.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            },"猪猪侠");
    
            //创建这t1线程
            t1.start();
            //等待200ms让t1线程优先创建好
            Thread.sleep(200);
            //创建这t2线程
            t2.start();
            //等待200ms让t2线程优先创建好
            Thread.sleep(200);
    
            System.out.println("当先线程 "+t2.getName()+"的状态是"+t2.getState()+"状态");
        }

运行结果是:

![在这里插入图片描述][54085e04e01b40e0bd92b638e2a25487.png]

### (6) BLOCK(阻塞状态) ###

阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃cpu的使用权，暂停或停止运行，直到线程进入就绪状态，才有机会获得cpu的青睐从而转入运行状态。

我们可以通俗点理解为~ 等待锁的状态.

例如: t1 和 t2 需要的锁对象相同,如果此时 t1 拿到了锁,当 t2 执行到进入锁的代码的时候, t2 就需要等 t1 释放锁之后才可以拿到这把锁.

我们通过代码演示:

public class ThreadDemo8 {
        
    
        static Object object = new Object();
        
        public static void main(String[] args) throws InterruptedException {
        
            
            Thread t1 = new Thread(()->{
        
            //两个锁对象相同
               synchronized (object){
        
                   while (true){
        
    
                   }
               }
            });
            Thread t2 = new Thread(()->{
        
            //两个锁对象相同
            //由于先执行的t1所以需要等t1释放锁才可以执行t2
            //此时t2处于阻塞状态
                synchronized (object){
        
                    System.out.println("t2");
                }
            },"猪猪侠");
            
            //创建这t1线程
            t1.start();
            
            //等待200ms让t1线程优先创建好
            Thread.sleep(200);
            
            //创建这t2线程
            t2.start();
            
            //等待200ms让t2线程优先创建好
            Thread.sleep(200);
            //查看t2线程的状态
            System.out.println("当先线程 "+t2.getName()+"的状态是"+t2.getState()+"状态");
        }
    }

运行结果:

![在这里插入图片描述][067f893471fe4e71bdec04eff71ebba4.png]

关于线程状态的关系图:

![在这里插入图片描述][a152d4ce960342d8a36da74692a44f76.png]

### sleep和wait的区别: ###

sleep()和wait()方法有什么区别：  
　sleep()睡眠时，保持对象锁，仍然占有该锁；  
　而wait()睡眠时，释放对象锁。  
　但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

[e6762638d951414598667b6811bf700c.png]: https://img-blog.csdnimg.cn/e6762638d951414598667b6811bf700c.png
[875b393898944dd884454a7ae3e65c8e.png]: https://img-blog.csdnimg.cn/875b393898944dd884454a7ae3e65c8e.png
[76b77b987c344d0abcc97bc0a2070075.png]: https://img-blog.csdnimg.cn/76b77b987c344d0abcc97bc0a2070075.png
[067e5347ab7349d8b613941b4466e80d.png]: https://img-blog.csdnimg.cn/067e5347ab7349d8b613941b4466e80d.png
[d6d1f9b8e1604e9b813ce2649d644b77.png]: https://img-blog.csdnimg.cn/d6d1f9b8e1604e9b813ce2649d644b77.png
[2eaca7baad19419f8c70285580459758.png]: https://img-blog.csdnimg.cn/2eaca7baad19419f8c70285580459758.png
[54085e04e01b40e0bd92b638e2a25487.png]: https://img-blog.csdnimg.cn/54085e04e01b40e0bd92b638e2a25487.png
[067f893471fe4e71bdec04eff71ebba4.png]: https://img-blog.csdnimg.cn/067f893471fe4e71bdec04eff71ebba4.png
[a152d4ce960342d8a36da74692a44f76.png]: https://img-blog.csdnimg.cn/a152d4ce960342d8a36da74692a44f76.png