关于java:10-张图聊聊线程的生命周期和常用-APIs

上一篇文章 咱们聊了多线程的根底内容，比方为什么要应用多线程，线程和过程之间的不同，以及创立线程的 4 种形式。本文已收录至我的 Github: https://github.com/xiaoqi6666…

明天咱们来说一下线程的生命周期和罕用 APIs：咱们须要十分分明的晓得线程的各种状态，比方排查程序运行慢的起因时，就须要看下是不是哪里被阻塞了；另外它也是面试时十分喜爱问的，如果根底内容都答不好，恐怕间接就挂了。

本文分为两大部分，

线程的 6 大状态；
多线程罕用的 APIs：
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;
}

先上图，咱们再顺次来看。

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

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

MyThread myThread = new MyThread();

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 的资源，那就执行；如果没抢到，就等着呗，等以后正在执行的线程实现它能执行的工夫片之后，再次抢占。

要留神这里在期待的个别是 系统资源，而不是锁或者其余阻塞。

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 个线程。

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()
办法之后，线程进入期待状态。

这里的期待状态是没有工夫限度的，能够有限的等上来 … 所以须要有人来唤醒：

如果是通过 wait() 进入期待状态的，须要有 notify() 或者 notifyAll() 办法来唤醒；
如果是通过 join() 进入期待状态的，须要期待指标线程运行完结。

比方在 生产者消费者模型 里，当没有商品的时候，消费者就须要期待，期待生产者生产好了商品发 notify()。下一篇文章咱们会细讲。

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

Thread.sleep

Object.wait with timeout

Thread.join with timeout

LockSupport.parkNanos

LockSupport.parkUntil

其实就是在上一种状态的根底上，给了 具体的工夫限度。

那么当工夫完结后，线程就解放了。

A thread that has exited is in this state.

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

执行完所有代码，失常完结；
强制被完结，比方调用了 stop() 办法，当初曾经被弃用；
抛出了未捕捉的异样。

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

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

接下来咱们说说多线程中罕用的 11 个 APIs。

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");
        }
    }
}

所以 join() 可能保障某个线程优先执行，而且会始终让它执行完，再回归到公平竞争状态。

join() 办法其实是用 wait() 来实现的，咱们来看下这个办法。

wait() 其实并不是 Thread 类的办法，而是 Object 外面的办法。

该办法就是让以后对象期待，直到另一个对象调用 notify() 或者 notifyAll()。

当然了，咱们也能够设定一个期待时长，到工夫之后对象将会主动昏迷。

yield 自身的中文意思是屈从，用在这里倒也适合。

yield() 示意以后线程被动让出 CPU 资源一下，而后咱们再一起去抢。

留神这里让一下 真的只是一下，从“执行中”回到“期待 CPU 分配资源”，而后所有线程再一起抢占资源。

顾名思义，这个办法就是让以后线程睡一会，比如说，

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

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

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 类型。

该办法能够获取以后线程名称。

这个名称能够本人设置，比方：

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

该办法是获取线程的 Id.

线程也有优先级的哦～

尽管优先级高的线程并不能百分百保障肯定会先执行，但它是有更大的概率被先执行的。

优先级的范畴是 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() 的异样。

当然啦，咱们也是能够本人设置某个线程的优先级的。

设置的优先级也须要在规定的 1-10 的范畴内哦，如果不在这个范畴也会抛异样。

最初咱们来说下 stop() 办法，也是前文提到过的强制进行线程的一种形式，但当初已被弃用，因为会引起一些线程平安方面的问题。

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

如果你喜爱这篇文章，记得给我点赞留言哦～你们的反对和认可，就是我创作的最大能源，咱们下篇文章见！

我是小齐，纽约程序媛，终生学习者，每天晚上 9 点，云自习室里不见不散！

更多干货文章见我的 Github: https://github.com/xiaoqi6666…**

关于java:10-张图聊聊线程的生命周期和常用-APIs

线程状态

1. New

2. Runnable

3. Blocked

4. Waiting

5. Timed_waiting

6. Terminated

APIs

1. join()

2. wait() and notify()

4. yield()

5. sleep()

6. currentThread()

7. getName()

8. getId()

9. getPriority()

10. setPriority()

11. stop()