Java线程间的协作以及创建线程的四种方式

一、前言

线程间的协作方法主要有：wait、notify、notifyAll、sleep、yield、join，本文首先介绍下线程的状态有哪些，然后解释下各个方法的含义以及作用，最后从底层原理解释下它们之间的区别。

二、正文

1.线程的状态

Java中线程中状态可分为六种：

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。

   线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法，线程进入就绪状态，等待CPU资源，此时处于就绪状态（ready）。

   就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

3. 阻塞(BLOCKED)：表示线程被阻塞，可能正在尝试进入synchronized关键字修饰的同步代码块、方法，

   等待获取监视器锁(monitor )。

4. 等待(WAITING)：通常调用Object.wait()会进入该状态，直到其他线程调用Object.notify() 或Object.notifyAll()才会唤醒。

5. 超时等待(TIMED_WAITING)：有限时间的等待状态，通常调用Object.wait(long timeout) 或Object.wait(long timeout, int nanos)会进入该状态，与等待状态类似，区别就是时间到了之后如果没有被Object.notify()或Object.notifyAll()唤醒的话会自动唤醒。

6. 终止(TERMINATED)：表示该线程已经执行完毕。

线程状态图如下：

2.状态详细说明

(1)初始状态(NEW)

实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

(2)就绪状态(RUNNABLE之READY)

1. 就绪状态只是说你有资格运行，调度程序(Cpu)没有挑选到你，你就永远是就绪状态。
2. 调用线程的start()方法，此线程进入就绪状态。
3. 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
4. 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
5. 锁池里的线程拿到对象锁后，进入就绪状态。

(3)运行中状态(RUNNABLE之RUNNING)

就绪状态的线程获取到CPU时间片后，进入运行状态。

(4)阻塞状态(BLOCKED)

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

(5)等待(WAITING)

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

(6)超时等待(TIMED_WAITING)

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

(7)终止状态(TERMINATED)

1. 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
2. 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

3.线程的协作方法

1.wait、notify、notifyAll这三个方法属于Object类。

2.sleep、yield、join这三个方法属于Thread类。

问：wait、notify、notifyAll这三个方法作用是实现线程间协作，但是为什么不属于Thread类，而是属于Object类？

(1)我们首先要知道，Java所有的类都继承自Object类。

(2)我们要知道wait方法的底层实现原理，wait实际是等待对象的monitor，由于Java中的每一个对象都有一个内置的monitor对象，自然所有的类都理应有wait/notify方法。

3.1wait、notify、notifyAll方法的使用

wait、notify、notifyAll这三个方法属于Object类。

1.wait方法

JDK中一共提供了这三个版本的方法，

（1）wait()方法的作用是将当前运行的线程挂起（即让其进入阻塞状态），直到notify或notifyAll方法来唤醒线程。

（2）wait(long timeout)，该方法与wait()方法类似，唯一的区别就是在指定时间内，如果没有notify或notifAll方法的唤醒，也会自动唤醒。

（3）至于wait(long timeout,long nanos)，本意在于更精确的控制调度时间，不过从目前版本来看，该方法貌似没有完整的实现该功能，其源码(JDK1.8)如下：

public final void wait(long timeout, int nanos) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
            "nanosecond timeout value out of range");
    }

    if (nanos > 0) {
        timeout++;
    }

    wait(timeout);
}

从源码来看，JDK8中对纳秒的处理，只做了四舍五入，所以还是按照毫秒来处理的，可能在未来的某个时间点会用到纳秒级别的精度。虽然JDK提供了这三个版本，其实最后都是调用wait(long timeout)方法来实现的，wait()方法与wait(0)等效，而wait(long timeout,int nanos)从上面的源码可以看到也是通过wait(long timeout)来完成的。

下面我们通过一个栗子来看下wait()的用法：

public class ThreadTest {
    public static void main(String[] args) {
        Object object = new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

直接执行，我们将会得到以下异常：

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.xiangyu.demo.ThreadTest$1.run(ThreadTest.java:10)
    at java.lang.Thread.run(Thread.java:748)

出错的代码在：object.wait();。这里我们需要了解以下事实：

• 无论是执行对象的 wait、notify 还是 notifyAll 方法，必须保证当前运行的线程取得了该对象的控制权（monitor）
• 如果在没有控制权的线程里执行对象的以上三种方法，就会报 java.lang.IllegalMonitorStateException 异常。
• JVM 基于多线程，默认情况下不能保证运行时线程的时序性

在上面的示例代码中，我们 new 了一个 Thread，但是对象 object 的控制权仍在主线程里。所以会报 java.lang.IllegalMonitorStateException 。

我们可以通过同步锁来获得对象控制权，例如：synchronized 代码块。对以上的示例代码做改造：

public class ThreadTest {
    public static void main(String[] args) {
        Object object = new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object){ // 修改处
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

再次执行，代码不再报错。

我们可以得到以下结论：

• 调用对象的wait()和notify()方法，需要先取得对象的控制权
• 可以使用synchronized (object)来取得对于 object 对象的控制权
• 在 Java 中任何一个时刻，对象的控制权只能被一个线程拥有

2.notify、notifyAll方法

这两个方法均为 native 方法，在JDK 1.8 中的关于notify()的JavaDoc如下：

Wakes up a single thread that is waiting on this object’s monitor. If any threads are waiting on this object, one of them is chosen to be awakened.

译为：

唤醒此 object 控制权下的一个处于 wait 状态的线程。若有多个线程处于此 object 控制权下的 wait 状态，只有一个会被唤醒。

也就是说，如果有多个线程在 wait 状态，我们并不知道哪个线程会被唤醒。

在JDK 1.8 中的关于notifyAll()的JavaDoc如下：

Wakes up all threads that are waiting on this object’s monitor.

译为：

唤醒所有处于此 object 控制权下的 wait 状态的线程。

有了对wait方法原理的理解，notify方法和notifyAll方法就很容易理解了。既然wait方式是通过对象的monitor对象来实现的，所以只要在同一对象上去调用notify/notifyAll方法，就可以唤醒对应对象monitor上等待的线程了。notify和notifyAll的区别在于前者只能唤醒monitor上的一个线程，对其他线程没有影响，而notifyAll则唤醒所有的线程。

下面我们通过一个题来更好的理解wait和notify是如何应用的：

启动两个线程, 一个输出 1,3,5,7…99, 另一个输出 2,4,6,8…100 最后 STDOUT 中按序输出 1,2,3,4,5…100

题目要求用 Java 的 wait + notify 机制来实现，重点考察对于多线程可见性的理解。下面给出此题的解法：

public class ThreadTest {
    private final Object flag = new Object();

    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        ThreadA threadA = threadTest.new ThreadA();
        threadA.start();
        ThreadB threadB = threadTest.new ThreadB();
        threadB.start();
    }

    class ThreadA extends Thread {
        @Override
        public void run() {
            synchronized (flag) {
                for (int i = 1; i <= 100; i += 2) {
                    flag.notify();
                    System.out.println(i); // 奇数
                    try {
                        flag.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }

    class ThreadB extends Thread {
        @Override
        public void run() {
            synchronized (flag) {
                for (int i = 2; i <= 100; i += 2) {
                    flag.notify();
                    System.out.println(i); // 偶数
                    if (i == 100) {
                        // 当输出了最后一个数字的时候，不能再wait了
                        break;
                    }
                    try {
                        flag.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

通过运行，可以看到输出结果是：1,2,3,4,5…100，符合题目的要求。

3.2 sleep、yield、join方法解析

sleep、yield、join这三个方法属于Thread类。

1.sleep

sleep方法的作用是让当前线程暂停指定的时间（毫秒），sleep方法是最简单的方法，在上述的例子中也用到过，比较容易理解。唯一需要注意的是其与wait方法的区别。最简单的区别是，wait方法依赖于同步，而sleep方法可以直接调用。而更深层次的区别在于sleep方法只是暂时让出CPU的执行权，并不释放锁。而wait方法则需要释放锁。

下面来看一个栗子：

public class SleepTest {

    public synchronized void sleepMethod() {
        System.out.println("Sleep start---------");
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Sleep end---------");
    }

    public synchronized void waitMethod() {
        System.out.println("Wait start---------");
        try {
            wait(1000);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Wait end---------");
    }

    public static void main(String[] args) {
        SleepTest sleepTest1 = new SleepTest();

        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    sleepTest1.sleepMethod();
                }
            }).start();
        }

        try {
            // 暂停10s，等待上面线程运行完
            Thread.sleep(10000);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-------分割线--------");

        SleepTest sleepTest2 = new SleepTest();

        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    sleepTest2.waitMethod();
                }
            }).start();
        }
    }
}

输出结果如下：

Sleep start---------
Sleep end---------
Sleep start---------
Sleep end---------
Sleep start---------
Sleep end---------
-------分割线--------
Wait start---------
Wait start---------
Wait start---------
Wait end---------
Wait end---------
Wait end---------

这个结果的区别很明显，通过sleep方法实现的暂停，程序是顺序进入同步块的，只有当上一个线程执行完成的时候，下一个线程才能进入同步方法，sleep暂停期间一直持有monitor对象锁，其他线程是不能进入的。而wait方法则不同，当调用wait方法后，当前线程会释放持有的monitor对象锁，因此，其他线程还可以进入到同步方法，线程被唤醒后，需要竞争锁，获取到锁之后再继续执行。

2、yield方法
　　yield方法的作用是暂停当前线程，以便其他线程有机会执行，不过不能指定暂停的时间，并且也不能保证当前线程马上停止。yield方法只是将Running状态转变为Runnable状态。我们还是通过一个栗子来看下：

public class YieldTest implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName() + ": " + i);
            Thread.yield();
        }
    }

    public static void main(String[] args) {
        YieldTest runn = new YieldTest();
        Thread t1 = new Thread(runn,"FirstThread");
        Thread t2 = new Thread(runn,"SecondThread");

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

    }
}

输出结果如下：

FirstThread: 0
SecondThread: 0
FirstThread: 1
SecondThread: 1
FirstThread: 2
SecondThread: 2
FirstThread: 3
SecondThread: 3
FirstThread: 4
SecondThread: 4

这个例子就是通过yield方法来实现两个线程的交替执行。不过请注意：这种交替并不一定能得到保证，源码中也对这个问题进行说明。

3、join方法

join方法的作用是父线程等待子线程执行完成后再执行，换句话说就是将异步执行的线程合并为同步的线程。JDK中提供三个版本的join方法，其实现与wait方法类似，join()方法实际上执行的join(0)，而join(long millis, int nanos)也与wait(long millis, int nanos)的实现方式一致，暂时对纳秒的支持也是不完整的。我们可以看下join方法的源码，这样更容易理解：

public final void join() throws InterruptedException {
        join(0);
    }

 public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

public final synchronized void join(long millis, int nanos)
    throws InterruptedException {

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        join(millis);
    }

大家重点关注一下join(long millis)方法的实现，可以看出join方法就是通过wait方法来将线程的阻塞，如果join的线程还在执行，则将当前线程阻塞起来，直到join的线程执行完成，当前线程才能执行。不过有一点需要注意，这里的join只调用了wait方法，却没有对应的notify方法，原因是Thread的start方法中做了相应的处理，所以当join的线程执行完成以后，会自动唤醒主线程继续往下执行。下面我们通过一个例子来演示join方法的作用：

(1)不使用join方法：

public class JoinTest implements Runnable{

    @Override
    public void run() {

        try {
            System.out.println(Thread.currentThread().getName() + " start-----");
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " end------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        for (int i=0;i<5;i++) {
            Thread test = new Thread(new JoinTest());
            test.start();
        }

        System.out.println("Finished~~~");
    }
}

输出结果如下：

Finished~~~
Thread-0 start-----
Thread-1 start-----
Thread-2 start-----
Thread-4 start-----
Thread-3 start-----
Thread-0 end------
Thread-1 end------
Thread-2 end------
Thread-4 end------
Thread-3 end------

（2）使用join方法：

public class JoinTest implements Runnable{

    @Override
    public void run() {

        try {
            System.out.println(Thread.currentThread().getName() + " start-----");
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " end------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        for (int i=0;i<5;i++) {
            Thread test = new Thread(new JoinTest());
            test.start();

            try {
                test.join();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Finished~~~");
    }
}

输出结果如下：

Thread-0 start-----
Thread-0 end------
Thread-1 start-----
Thread-1 end------
Thread-2 start-----
Thread-2 end------
Thread-3 start-----
Thread-3 end------
Thread-4 start-----
Thread-4 end------
Finished~~~

对比两段代码的执行结果很容易发现，在没有使用join方法之前，线程是并发执行的，而使用join方法后，所有线程是顺序执行的。

4.同步队列状态

• 当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
• 当一个线程1被另外一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
• 同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。
• 线程等待时间到了或被notify/notifyAll唤醒后，会进入同步队列竞争锁，如果获得锁，进入RUNNABLE状态，否则进入BLOCKED状态等待获取锁。

5.几个方法的比较

1. Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
2. Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。 作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。
3. thread.join()/thread.join(long millis)，当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程一般情况下进入RUNNABLE状态，也有可能进入BLOCKED状态（因为join是基于wait实现的）。
4. Object.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列，状态变为wait状态。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。如果获得锁，进入RUNNABLE状态，否则进入BLOCKED状态等待获取锁。
5. LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态，需要通过LockSupport.unpark(Thread thread)唤醒。

6.创建线程的四种方法

Thread

线程运行的过程会产生很多信息，这些信息都保存在Thread类中的成员变量里面，常见的有：
a.线程的ID是唯一标识getId()
b.线程的名称：getName()，如果不设置线程名称默认为“Thread-xx”
c.线程的优先级：getPriority，线程优先级从1-10,其中数字越大表示优先级别越高，同时获得JVM调度执行的可能性越大。

1.继承Thread类

步骤：
1，定义一个类继承Thread类。
2，覆盖Thread类中的run方法。
3，直接创建Thread的子类对象创建线程。
4，调用start方法开启线程并调用线程的任务run方法执行。

可以通过Thread的getName获取线程的名称 Thread-编号(从0开始)，主线程的名字就是main。

下面来看下实际的栗子：

class Demo extends Thread
{
    /**
     *线程名称
     */
    private String name;
    Demo(String name)
    {
       //父类构造函数，改线程的名称 
        super(name); 
        //this.name = name;
    }
    //***run方法中定义就是线程要运行的任务代码。***
    public void run()
    {
        for(int x=0; x<10; x++)
        {
            System.out.println(name+"....x="+x+".....name="+Thread.currentThread().getName());
        }
    }
}

class ThreadDemo2 
{
    public static void main(String[] args) 
    {
        Demo d1 = new Demo("旺财");
        Demo d2 = new Demo("xiaoqiang");
        d1.start();//开启线程，调用run方法。
        d2.start();
        System.out.println("over...."+Thread.currentThread().getName());
    }
}

2.通过实现Runnable接口，覆盖run方法。（常用）

1，定义类实现Runnable接口。

2，覆盖接口中的run方法，将线程的任务代码封装到run方法中。

3，通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。

为什么?因为线程的任务都封装在Runnable接口子类对象的run方法中。

所以要在线程对象创建时就必须明确要运行的任务。

思想：将线程的任务通过Runnable接口封装成了对象。

4，调用线程对象的start方法开启线程。

实现Runnable接口的好处：

1，将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
2，避免了java单继承的局限性。

下面来看下实际的栗子：

 //准备扩展Demo类的功能，让其中的内容可以作为线程的任务执行。
//通过接口的形式完成。
class Demo implements Runnable{
    public void run()
    {
        show();
    }
    public void show()
    {
        for(int x=0; x<20; x++)
        {
            System.out.println(Thread.currentThread().getName()+"....."+x);
        }
    }
}

class  ThreadDemo
{
    public static void main(String[] args) 
    {    
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t2.start();

    }
}

3.实现Callable接口

与使用Runnable相比， Callable功能更强大些：

1.相比run()方法，可以有返回值

2.方法可以抛出异常

3.支持泛型的返回值

4.需要借助FutureTask类，比如获取返回结果

Future接口

1.可以对具体Runnable、Callable任务的执行结果进行取消、查询是
否完成、获取结果等。

2.FutrueTask是Futrue接口的唯一的实现类。

3.FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值。

//1.创建一个实现Callable的实现类
class Stu implements Callable {
    //2.实现call方法,将此线程需要执行的操作放到call()中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 1; i <=100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class Bank {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        Stu stu = new Stu();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
         FutureTask futureTask = new FutureTask(stu);
        //5.FutureTask的对象作为参数传递到Thread类的构造器中创建Thread，并调用start()
         new Thread(futureTask).start();
        try {
            Object sum = futureTask.get();
            System.out.println("总和为"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4.使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

好处:

1.提高响应速度（减少了创建新线程的时间）

2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）

3.便于线程管理

//创建并使用多线程的第四种方法：使用线程池
class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if(i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }

}

public class ThreadPool {
    public static void main(String[] args) {
        // 1.提供指定线程的数量
        ExecutorService service = Executors.newFixedThreadPool(10);
        //设置线程的属性
        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        //service1.setMaximumPoolSize(15);
        //service1.setCorePoolSize();*/
        // 2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中，开启线程
        // 并执行相关的run()
        service.execute(new MyThread());//适用于Runnable
        //service.submit();适用于Callable

        // 3.结束线程的使用
        service.shutdown();

    }
}

三、总结

本文首先介绍了线程有哪几种状态，每种状态什么时候发生。然后介绍了线程的协作方法，详细讲解了每种协作方法的作用，并比较了这几种协作方法的异同。最后讲解了线程四种创建方法。

最后引用我很佩服的一个人经常说的话：你知道的越多，你不知道的越多！

文章参考：

https://segmentfault.com/a/1190000038392244#

https://www.cnblogs.com/paddix/p/5381958.html