10 张图聊聊线程的生命周期和常用 APIs

￡神魔★判官ぃ 2021-09-02 04:12 217阅读 0赞

今天我们来说一下线程的生命周期和常用 APIs：我们需要非常清楚的知道线程的各种状态，比如排查程序运行慢的原因时，就需要看下是不是哪里被阻塞了；另外它也是面试时非常喜欢问的，如果基础内容都答不好，恐怕直接就挂了。

本文分为两大部分，

1.  线程的 6 大状态；
2.  多线程常用的 APIs：
3.  1.  join()
    2.  wait()
    3.  notify()
    4.  yield()
    5.  sleep()
    6.  currentThread()
    7.  getName()
    8.  getId()
    9.  getPriority()
    10. setPriority()
    11. stop()

## 线程状态 ##

关于线程的状态，网上各种说法都有，比较流行的是 5 种或者 6 种。关于 5 种状态的那个版本我没有找到理论依据，如果有小伙伴清楚的也欢迎留言指出。

我这里所写的是根据 `java.lang.Thread` 的源码，线程有以下 6 大状态：

public enum State {
      NEW,
      RUNNABLE,
      BLOCKED,
      WAITTING,
      TIMED_WAITTING,
      TERMINATED;
    }

先上图，我们再依次来看。

![format_png][]

### 1. New ###

> A thread that has not yet started is in this state.

就是指线程刚创建，还没启动的时候，比如刚 `new` 了一个 `thread`。

MyThread myThread = new MyThread();

### 2. Runnable ###

> A thread is executing in the Java virtual machine but it may be waiting for other resources from the operating system such as processor.

那么接下来，自然就是要启动线程了，也就是调用 `thread` 的 `start()` 方法。

myThread.start();

启动之后，线程就进入了 `Runnable` 状态。

此时所有的线程都会添加到一个等待队列里，等待“CPU 调度”。

如果抢占到 CPU 的资源，那就执行；如果没抢到，就等着呗，等当前正在执行的线程完成它能执行的时间片之后，再次抢占。

要注意这里在等待的一般是**系统资源**，而不是锁或者其他阻塞。

### 3. Blocked ###

> Thread state for a thread blocked waiting for a monitor lock.  
> A thread in the blocked state is **waiting for a monitor lock to enter a synchronized block/method** or reenter a synchronized block/method after calling `wait()` Object.

这里给出了非常明确的 `use case`，就是**被锁在外面的才叫阻塞**。所以这里必须要有至少 2 个线程。

### 4. Waiting ###

> A thread in the waiting state is waiting for another thread to perform a particular action.

那具体有哪些原因呢？

> A thread is in the waiting state due to calling one of the following methods:
> 
>  *  Object.wait with no timeout
>  *  Thread.join with no timeout
>  *  LockSupport.park

所以说，当调用了

*  `wait()`，
 *  `join()`，
 *  `park()`  
    方法之后，线程进入等待状态。

这里的等待状态是没有时间限制的，可以无限的等下去... 所以需要有人来**唤醒**：

1.  如果是通过 `wait()` 进入等待状态的，需要有 `notify()` 或者 `notifyAll()` 方法来唤醒；
2.  如果是通过 `join()` 进入等待状态的，需要等待目标线程运行结束。

比如在**生产者消费者模型**里，当没有商品的时候，消费者就需要等待，等待生产者生产好了商品发 `notify()`。下一篇文章我们会细讲。

### 5. Timed\_waiting ###

导致这个状态的原因如下：

>  *  Thread.sleep
>  *  Object.wait with timeout
>  *  Thread.join with timeout
>  *  LockSupport.parkNanos
>  *  LockSupport.parkUntil

其实就是在上一种状态的基础上，给了**具体的时间限制**。

那么当时间结束后，线程就解放了。

### 6. Terminated ###

> A thread that has exited is in this state.

这里有 3 种情况会终止线程：

*  执行完所有代码，正常结束；
 *  强制被结束，比如调用了 `stop()` 方法，现在已经被弃用；
 *  抛出了未捕获的异常。

线程一旦死亡就不能复生。

如果在一个死去的线程上调用 `start()` 方法，那么程序会抛出 `java.lang.IllegalThreadStateException`。

接下来我们说说多线程中常用的 11 个 APIs。

## APIs ##

### 1. join() ###

`join()` 方法会**强制让该线程执行**，并且一直会让它执行完。

比如上一篇文章的例子是两个线程交替执行的，那么我们这里该下，改成调用`小齐线程.join()`，那么效果就是先输出 `小齐666`。

public class MyRunnable implements Runnable {
        @Override
        public void run() {
            for(int i = 0; i < 100; i++) {
                System.out.println("小齐666：" + i);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(new MyRunnable());
            t.start();
            t.join();
    
            for(int i = 0; i < 100; i++) {
                System.out.println("主线程" + i + "：齐姐666");
            }
        }
    }

![format_png 1][]

所以 `join()` 能够保证某个线程优先执行，而且会一直让它执行完，再回归到公平竞争状态。

`join()` 方法其实是用 `wait()` 来实现的，我们来看下这个方法。

### 2. wait() and notify() ###

`wait()` 其实并不是 `Thread` 类的方法，而是 `Object` 里面的方法。

该方法就是让当前对象等待，直到另一个对象调用 `notify()` 或者 `notifyAll()`。

当然了，我们也可以设定一个等待时长，到时间之后对象将会自动苏醒。

### 4. yield() ###

`yield` 本身的中文意思是屈服，用在这里倒也合适。

`yield()` 表示当前线程主动让出 CPU 资源一下，然后我们再一起去抢。

注意这里让一下**真的只是一下**，从“执行中”回到“等待 CPU 分配资源”，然后所有线程再一起抢占资源。

### 5. sleep() ###

顾名思义，这个方法就是让当前线程睡一会，比如说，

myThread.sleep(1000); // 睡眠 1 秒钟

它会抛出一个 `InterruptedException` 异常，所以还要 `try catch` 一下。

### 6. currentThread() ###

> Returns a reference to the currently executing thread object.

该方法是获取当前线程对象。

注意它是一个 `static` 方法，所以直接通过 `Thread` 类调用。

比如打印当前线程

System.out.println(Thread.currentThread());

前文的例子中，它会输出：

Thread[Thread-0,5,main]
    Thread[main,5,main]

没错，它的返回值也是 `Thread` 类型。

### 7. getName() ###

该方法可以获取当前线程名称。

这个名称可以自己设置，比如：

Thread t = new Thread(new MyRunnable(), "壹齐学");

### 8. getId() ###

该方法是获取线程的 `Id`.

### 9. getPriority() ###

线程也有优先级的哦～

虽然优先级高的线程并不能百分百保证一定会先执行，但它是有更大的概率被先执行的。

优先级的范围是 `1-10`，我们来看源码：

/**
         * The minimum priority that a thread can have.
         */
        public final static int MIN_PRIORITY = 1;
    
       /**
         * The default priority that is assigned to a thread.
         */
        public final static int NORM_PRIORITY = 5;
    
        /**
         * The maximum priority that a thread can have.
         */
        public final static int MAX_PRIORITY = 10;

如果不在这个范围，JDK 抛出 `IllegalArgumentException()` 的异常。

10. setPriority()

当然啦，我们也是可以自己设置某个线程的优先级的。

设置的优先级也需要在规定的 `1-10` 的范围内哦，如果不在这个范围也会抛异常。

11. stop()

最后我们来说下 `stop()` 方法，也是前文提到过的强制停止线程的一种方式，但现在已被弃用，因为会引起一些线程安全方面的问题。

![format_png 2][]

好了，以上就是有关线程状态和常用 API 的介绍了。相信大家看完之后对线程的整个流程应该有了清晰的认识，其实里面还有很多细节我没有展开，毕竟这是多线程的第 2 讲，更深入的内容我们慢慢来。

如果你喜欢这篇文章，记得给我点赞留言哦～你们的支持和认可，就是我创作的最大动力，我们下篇文章见！

**- END -**

最近整理一份面试资料《Java技术栈学习手册》，覆盖了Java技术、面试题精选、Spring全家桶、Nginx、SSM、微服务、数据库、数据结构、架构等等。
    获取方式：点“ 在看，关注公众号 Java后端 并回复 777 领取，更多内容陆续奉上。
    推荐阅读 
    1. 使用 IntelliJ IDEA 查看类图，内容极度舒适
    2. 40 张图看懂分布式追踪系统原理及实践
    3. :: 是什么语法？
    4. 消息队列面试连环问
    5. 这种 Github 不要写在简历上！
    
    喜欢文章，点个在看

[format_png]: /images/20210730/97a72c28691f477799b692be61ed926a.png
[format_png 1]: /images/20210730/ea5e67d4227441f79323774e1a6216e6.png
[format_png 2]: /images/20210730/57d224aeface473fb67b5f93c97751ac.png