一、线程的创建和使用

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
Thread类的特性
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run(）

1.、Thread类：

构造器

Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象

2. API中创建线程的两种方式

JDK1.5之前创建新执行线程有两种方法：

继承Thread类的方式
实现Runnable接口的方式

2.1 继承Thread类

1) 定义子类继承Thread类。
2) 子类中重写Thread类中的run方法。
3) 创建Thread子类对象，即创建了线程对象。
4) 调用线程对象start方法：启动线程，调用run方法。

2.1.1. 注意点：

1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
3. 想要启动多线程，必须调用start方法。
4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException” 。

/*
* 练习：创建两个分线程，1 遍历100内偶数 2 遍历100内奇数
* */
public class ThreadDemo {
    public static void main(String[] args) {
        //1.创建对象方式
/*        MyThread1 myThread1 = new MyThread1();
        MyThread2 myThread2 = new MyThread2();
        myThread1.start();
        myThread2.start();*/
        //2.创建Thread类的匿名子类方式
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i%2==0){
                        System.out.println(Thread.currentThread().getName()+" :  "+ i);
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i%2!=0){
                        System.out.println(Thread.currentThread().getName()+" : " +i);
                    }
                }
            }
        }.start();

    }

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

2.2 实现Runnable接口

1) 定义子类，实现Runnable接口。
2) 子类中重写Runnable接口中的run方法。
3) 通过Thread类含参构造器创建线程对象。
4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

2.3. 继承方式和实现方式的联系与区别

public class Thread extends Object implements Runnable
2.3.1 区别

继承Thread：线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法。

2.3.2 实现方式的好处

避免了单继承的局限性
多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源

3. Thread类的有关方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
static void yield()：线程让步
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
- 若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
- 低优先级的线程也可以获得执行
static void sleep(long millis)： (指定时间:毫秒)
- 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
- 抛出InterruptedException异常
stop(): 强制线程生命期结束，不推荐使用
boolean isAlive()：返回boolean，判断线程是否还活着

package com.zhanghl.service;

/*
* 测试Thread类中的常用方法：
* 1.start() :启动线程，并执行对象的run()方法
* 2.run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明再此方法中
* 3.currentThread(): 返回当前代码执行的线程，静态方法
* 4.getName()：获取当前线程的方法
* 5.setName(): 设置当前线程的方法
* 6.yield() 线程让步
* 7.join() 在线程A中调用线程B的join()，此时线程A进入阻塞状态，
*           直到线程B完全执行完以后，线程A才会结束阻塞状态
* 8.stop() 强制线程生命周期停止。不推荐使用，已过时
* 9.sleep(long millitime) 让当前线程睡眠指定的millitime毫秒，在指定的millitime毫秒时间内，当前线程时阻塞装
* 10. isAlive() 判断当前线程是否存活
* */
public class ThreadMethodTest {
    public static void main(String[] args) {
        /*构造器方式命名*/
        HelloThread h1 = new HelloThread("线程1");
        //h1.setName("线程一");
        h1.start();
        /*给主线程命名*/
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+" :  "+ i);
            }
            /*当i==20时 让子线程 h1 先执行 ，执行完毕再回到主线程*/
            if (i==20){
                try {
                    h1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("h1.isAlive()"+h1.isAlive());
    }

}
class HelloThread extends Thread{
    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            if(i%2!=0){
                try {
                    //睡眠1秒
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" :  "+ i);
            }
            /*yield释放执行权*/
            /*if(i%10==0){
                this.yield();
            }*/
        }

    }
    public HelloThread(){}
    /*利用Thread 类中 使用名称实例化的方法*/
    public HelloThread(String name){
        super(name);
    }
}

4. 线程的调度

调度策略
- 时间片:
- 抢占式：高优先级的线程抢占CPU
Java的调度方法
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 对高优先级，使用优先调度的抢占式策略

5. 线程的优先级

线程的优先级等级
- MAX_PRIORITY： 10
- MIN _PRIORITY： 1
- NORM_PRIORITY： 5
涉及的方法
- getPriority() ：返回线程优先值
- setPriority(int newPriority) ：改变线程的优先级
说明
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

6. 补充：线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将退出。
形象理解：兔死狗烹，鸟尽弓藏

二、线程的生命周期

1. JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。 Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五
种状态：

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

<span style="color:#2980b9">一、线程的创建和使用</span>-LMLPHP

三、线程的同步

1. 问题的提出

多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

2. 问题的原因。

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

3. 解决办法：

Java对于多线程的安全问题提供了专业的解决方式：同步机制

3.1 Synchronized的使用方法

3.1.1 同步代码块

synchronized (对象){
// 需要被同步的代码；
}

3.1.2 同步方法： synchronized还可以放在方法声明中，表示整个方法为同步方法

public synchronized void show (String name){
......
}

3.1.3 同步机制中的锁

同步锁机制：

在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了

synchronized的锁是什么？
- 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
- 同步方法的锁：静态方法（类名.class）、非静态方法（this）
- 同步代码块：自己指定，很多时候也是指定为this或类名.class

3.1.4. 同步的范围

1、如何找问题，即代码是否存在线程安全？（非常重要）
（1）明确哪些代码是多线程运行的代码
（2）明确多个线程是否有共享数据
（3）明确多线程运行代码中是否有多条语句操作共享数据
2、如何解决呢？（非常重要）
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。即所有操作共享数据的这些语句都要放在同步范围中
3、切记：

范围太小：没锁住所有有安全问题的代码
范围太大：没发挥多线程的功能。

3.1.5 释放锁的操作

当前线程的同步方法、同步代码块执行结束。
当前线程在同步代码块、同步方法中遇到break、 return终止了该代码块、该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

3.1.6 不会释放锁的操作

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
应尽量避免使用suspend()和resume()来控制线程

3.1.7 单例设置模式之懒汉式（线程安全）

/*
* 使用同步机制将单例模式中的懒汉式改为线程安全的
*
* */
public class BankTest {
}
class  Bank{
    private Bank(){}
    private static Bank instance=null;
    public static synchronized Bank getInstance(){
        /*方式一：效率稍差 */
        /*synchronized (Bank.class){
            if(instance==null){
                instance=new Bank();
            }
            return instance;
        }*/
        /*方式二：效率更高*/
        if(instance==null){
            synchronized (Bank.class){
                if(instance==null){
                    instance=new Bank();
                }
            }
        }
        return instance;
    }
}

3.1.8 线程的死锁问题

死锁
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
  - 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步

package org.zhanghl;
/*
* 演示线程的死锁问题
* 1.
* */
public class DeadLock {
    public static void main(String[] args) {
        StringBuffer s1=new StringBuffer();
        StringBuffer s2=new StringBuffer();
        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

3.2 Lock（锁）

class A{
    private final ReentrantLock lock = new ReenTrantLock();
    public void m(){
           lock.lock();
           try{
            //保证线程安全的代码;
           }
           finally{
              lock.unlock();
           }
     }
}

3.3. synchronized 与 Lock 的对比

四、线程的通信

1. 线程通信的例子：使用两个线程打印1-100，线程1 线程2 交替打印

package org.zhanghl.examples;


/*
 * 线程通信的例子：使用两个线程打印1-100，线程1 线程2 交替打印
 * 涉及到的三个方法
 * wait():一旦执行此方法，当前线程进入阻塞状态，并释放同步监视器
 * notify()：执行此方法，会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的
 * notifyAll()：执行此方法，就会唤醒所有被wait的线程。
 *
 * 说明：
 * 1.wait notify notifyAll 三个方法，必须使用在同步代码块，或同步方法中。
 * 2.wait notify notifyAll 三个方法的调用者必须是同步代码快或同步方法中的同步监视器。
 *      否则会出现 java.lang.IllegalMonitorStateException 异常
 * 3.wait notify notifyAll 三个方法 是定义在  java.lang.Object类中的
 *
 * 面试题：sleep()和wait()的异同
 * 1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
 * 2.不同点，1）两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait()
 *          2)调用的要求不同：sleep() 可以再任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中。
 *          3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep不会释放锁，wait会释放锁
 *
 * */
class Number implements Runnable {
    private int number = 1;
    private Object obj=new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                obj.notify();
                if (number <= 100) {

                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        //使得调用wait()方法的线程进入阻塞状态 wait释放锁
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

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

    }
}

2. wait() 与 notify() 和 notifyAll()

这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

3. wait() 方法

在当前线程中调用方法：对象名.wait()
使当前线程进入等待（某对象）状态，直到另一线程对该对象发出 notify(或notifyAll) 为止。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
调用此方法后，当前线程将释放对象监控权，然后进入等待
在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

4. notify()/notifyAll()

在当前线程中调用方法：对象名.notify()
功能：唤醒等待该对象监控权的一个/所有线程。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

5.经典例题：生产者/消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题：
- 生产者比消费者快时，消费者会漏掉一些数据没有取到。
- 消费者比生产者快时，消费者会取相同的数据

/*
* 线程通信的应用-生产者消费者例题，
* 生产者（Productor）将产品交给店员（Clerk）,而消费者Customer从店员处取走产品
* 店员一次只能持有固定数量的产品（比如：20），如果生产者视图生产更多的产品，店员会叫生产者停一下，
* 如果店中有空位放产品了，再通知生产者继续生产；
* 如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了，再通知消费者来取走产品。
*
* 分析：
* 1.是否多线程问题？ 是，生产者线程，消费者线程
* 2.是否有共享数据？是，店员（或产品）
* 3.如果解决线程的安全问题？同步机制，有三种方法
* 4.是否涉及线程的通信？是
*
* */

class Clerk{
    private int productCount=0;
    /*生产产品*/
    public synchronized void produceProduct(){
        if(productCount<20){
            productCount++;
            System.out.println(
                    Thread.currentThread().getName()+
                    "：开始生产第"+productCount+"个产品");
            notify();
        }else {
            /*等待*/
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /*消费产品*/
    public synchronized void consumeProduct(){
        if(productCount>0){
            System.out.println(
                    Thread.currentThread().getName()+
                            "：开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else {
            /*等待*/
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/*生产者*/
class Producer extends  Thread{
     private  Clerk clerk;
     public Producer(Clerk clerk){
         this.clerk=clerk;
     }

    @Override
    public void run() {
        System.out.println(getName()+":开始生产产品");
        while (true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.produceProduct();
        }
    }
}
/*消费者*/
class Customer extends  Thread{
    private  Clerk clerk;
    public Customer(Clerk clerk){
        this.clerk=clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":开始消费产品");
        while (true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }
    }
}

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");
        Customer c1 = new Customer(clerk);
        c1.setName("消费者1");
        Customer c2 = new Customer(clerk);
        c2.setName("消费者2");
        p1.start();
        c1.start();
        c2.start();
    }
}

五、 JDK5.0新增线程创建方式

1.新增方式一、实现Callable接口

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

相比run()方法，可以有返回值
方法可以抛出异常
支持泛型的返回值
需要借助FutureTask类，比如获取返回结果

1.2. Future接口

可以对具体Runnable、 Callable任务的执行结果进行取消、查询是否完成、获取结果等。
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值

1.3.示例代码

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;


public class ThreadCallableTest {
    public static void main(String[] args) {
        /*3.创建Callable接口实现类的对象*/
        NumThread numThread = new NumThread();
        /*4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask对象*/
        FutureTask futureTask = new FutureTask(numThread);
        /*5.将FutureTask的对象作为参数 传递到Thread类的构造器中，创建Thread对象，并调用start（）*/
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            /*6.获取Callable中的call方法的返回值*/
            /*get()返回值即为FutureTask构造器参数Callable实现类重写的Call的返回值*/
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
/*
 * 1 创建一个实现Callable的实现类
 * */
class NumThread implements Callable{
/*2.实现call方法，将此线程需要执行的操作声明再call方法中
*
* */
    @Override
    public Object call() throws Exception {
        int sum =0;
        for (int i = 0; i <=100 ; i++) {
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}

2.新增方式二、使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：体检创建好多个线程，放入线程池中，使用时直接获取，使用完放回池内。可以避免频繁
    销毁、实现重复利用。
好处：
    提高响应速度（减少了创建新线程的时间）
    降低资源消耗（重复利用线程池中线程 ，不需要每次都创建）
    便于线程管理
        corePoolSize:核心池的大小
        maximumPoolSize:最大线程数
        keepAliveTime:线程没有任务时最多保持多长时间后会终止
JDK 5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService:真正的线程池接口。常见子类 ThreadPoolExecutor
    void execute(Runable command): 执行任务/命令，没有返回值，一般来执行Runable
    <T>  Future<T> submit(Callable<T> task):执行任务，有返回值，一般用来执行Callable
    void shutdown(): 关闭连接池
Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池
    Executors.newCachedThreadPool():   创建一个可根据需要创建新线程的线程池
    Executors.newFixedThreadPool(n):    创建一个可重用固定线程数的线程池
    Executors.newSingleThreadExecutor():创建一个 只有一个线程的线程池
    Executors.newScheduledThreadPool(n):创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。示例

示例代码：

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+" : "+i);
            }
        }
    }
}
class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; 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为 ExecutorService的实现类
        ThreadPoolExecutor service1=(ThreadPoolExecutor)service;
        //service1.setCorePoolSize(15);
       // service1.setKeepAliveTime();
        //System.out.println(service.getClass());
        /*1.1 设置线程池的属性*/
        /*2、执行指定的线程的操作。需要提供实现Runable接口或Callable接口实现类的对象*/
        service.execute(new NumberThread());//适合使用与Runable
        service.execute(new NumberThread1());//适合使用与Runable
//        service.submit();//适合使用与Callable
        /*3.关闭线程池*/
        service.shutdown();//
    }
}

张宏良

<span style="color:#2980b9">一、线程的创建和使用</span>