【多线程】程序猿进阶多线程（三）—— 线程的运行状态

超、凢脫俗 2022-05-16 01:41 196阅读 0赞

# 一、前言 #

在上一篇博客中，小编向大家介绍了 [线程创建和启动][Link 1]，简单的向大家介绍了线程创建和启动的三种方法：1.继承Thread类，2.实现Runnable接口，3.使用Future和Task创建。可能大家对线程的初步创建有了一定的了解。

在这篇博客中，小编向大家介绍一下，线程运行起来后，有的状态。

# 二、线程的状态 #

![这里写图片描述][70]

线程在执行过程中，可以处于下面几种状态：

> 就绪(Runnable):线程准备运行，不一定立马就能开始执行。  
> 运行中(Running)：进程正在执行线程的代码。  
> 等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。  
> 阻塞状态(Blocked)：等待 I/O 操作完成。  
> 同步阻塞(Locking)：等待获取锁。  
> 死亡(Dead)：线程完成了执行。

下面详细说明：

*  就绪状态 - Runnable

当我们创建好线程后，`Thread t = new Thread();`,开始调用`t.start();`方法后，线程就从初始状态转变为就绪状态。

就绪状态下的线程，在等待操作系统调用，操作系统会根据不同的调度算法来进行调度线程。比如操作系统使用时间片轮转算法。

*  运行状态 - Running

当操作系统选定要运行的线程后，这个线程就会从就绪状态转为运行状态。这个时候，运行状态的线程就会执行我们重写的`run（）`方法。

*  阻塞状态 - blocked

有的时候，我们需要给线程之间一些缓冲时间，通常使用`Sleep()`让子线程和主线程错开。有的时候我们需要线程按照一定的顺序执行，这个时候我们可以使用`b.join()`，安排在线程b执行完成后再执行。

所以在`sleep()`和`join()`调用的过程中，线程会处于阻塞状态。只有等`sleep()`和`join()`完成后，线程才会再次进入就绪状态，等待cpu调用。

*  等待状态 - waiting

运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒

*  锁池状态 - locking

当执行中的线程进入synchronized同步块的时候，没有获取到锁的线程，就会进入锁池状态，获取到锁的线程执行完成后，锁解除，进入就绪状态。

*  死亡状态 -dead

线程执行完成，进入死亡状态。

# 三、一些知识点 #

在上面的线程状态图中，里面有很多方法，可能不是很清楚。下面小编通过几个问题来对比记忆一下这些方法：

java多线程中，会有很多问题，比如经典的：

## 3.1 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？ ##

【方法一】

这个简单的问题，我们可以直接使用join函数完成，join的作用就是，`b.join()`在b线程执行完成后再执行。这样就保证了执行顺序。

package com.dmsd.thread;
    
    /**
     * Created by Ares on 2018/6/11.
     *
     * 说明：使用join完成 ————t1执行完了，t2执行；t2执行完成后，t3执行。
     *
     * 假设现在有两个线程A、B。如果在A的run方法中调用B.join()，
     * 表示A需要在B线程上面等待，也就是需要在B线程执行完成之后才能再次执行。
     */
    public class join { 
        public static void main(String[] args) {
            Thread t1 = new Thread(() -> { for (int i = 0; i < 5; i++) { try { Thread.sleep(40); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("t1 run:"+i); } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 5; i++) { try { Thread.sleep(40); t1.join();//表明当前线程需要在t1线程上等待 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("t2 run:"+i); } }); Thread t3 = new Thread(() -> { for (int i = 0; i < 5; i++) { try { Thread.sleep(40); t2.join();//表明当前线程需要在t2线程上等待 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("t3 run:"+i); } }); t1.start(); t2.start(); t3.start(); } }

【方法二】

可以说使用join的老铁，还是比较low的。在我们的juc包（ java.util.concurrent）中，利用ExcutorService产生的newSingleThreadExecutor的单一线程池。这个线程池的底层是使用了先进先出的队列，通过submit依次把线程添加进队列，然后顺序执行。

package com.dmsd.thread;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /** * Created by Ares on 2018/8/14. */
    public class TestSingleThreadPool { 
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newSingleThreadExecutor();
    
            Thread t1 = new Thread(new MyThread1());
            Thread t2 = new Thread(new MyThread2());
            Thread t3 = new Thread(new MyThread3());
    
            executorService.submit(t1);
            executorService.submit(t2);
            executorService.submit(t3);
    
            executorService.shutdown();
    
        }
    }
    
    class MyThread1 implements Runnable { 
        @Override
        public void run() {
            System.out.println("I am thread 1");
        }
    }
    
    class MyThread2 implements Runnable { 
        @Override
        public void run() {
            System.out.println("I am thread 2");
        }
    }
    
    class MyThread3 implements Runnable { 
        @Override
        public void run() {
            System.out.println("I am thread 3");
        }
    }

底层中用了newThreadPoolExecutor()创建了线程池，线程池中一个线程，并把线程放到linkedBlockingQueue阻塞队列中。保证了线程的顺序执行。

源码：

public static ExecutorService newSingleThreadExecutor() {
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }

## 3.2 Java中sleep和wait的区别 ？ ##

这个问题也是经常问的问题。

① 这两个方法来自 不同的类 分别是，sleep来自Thread类，和wait来自Object类。  
sleep是Thread的静态类方法， 谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉， 要让b线程睡觉要在b的代码中调用sleep。

② 锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。

③ 使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

synchronized(x){ 
          x.notify() 
         //或者wait() 
       }

# 四、小结 #

通过线程的状态，详细大家可以更加深入的剥开多线程的面纱，对多线程的理解也会更加的深刻。

[Link 1]: https://blog.csdn.net/kisscatforever/article/details/81026587
[70]: /images/20220516/ebb08b7b3b734bfd97c85d69704b849f.png