多线程详解

Process与Thread

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
而进程则是程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是cpu调度和执行的单位。

注意：很多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

概念

线程就是独立的执行路径
在程序运行时，即使没有自己创建的线程，后台也会有多个线程，如主线程，gc线程
main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如cpu调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程的创建

三种实现方式：

继承Thread类
实现Runnable接口
实现Callable接口

Thread

自定义线程类集继承Thread类
重写run()方法，编写线程执行体
创建线程对象，条用线程start()方法启动线程
不建议使用：避免oop单继承局限性

继承Thread类demo

用到了一个下载文件的jar包：commons-io。

package com.bestrookie;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/**
 * @author : bestrookie
 * @date : 14:06 2021/1/18
 */
public class ThreadDemo2 extends Thread{
    private String url;
    private String name;
    public ThreadDemo2(String url,String name){
        this.url = url;
        this.name = name;
    }
    @Override
    public void run() {
        super.run();
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为"+name);
    }

    public static void main(String[] args) {
        ThreadDemo2 t1 = new ThreadDemo2("https://bkimg.cdn.bcebos.com/pic/0ff41bd5ad6eddc451da99709f91a1fd5266d11695ac?x-bce-process=image/resize,m_lfit,w_268,limit_1/format,f_jpg","1.jpg");
        ThreadDemo2 t2 = new ThreadDemo2("https://bkimg.cdn.bcebos.com/pic/0ff41bd5ad6eddc451da99709f91a1fd5266d11695ac?x-bce-process=image/resize,m_lfit,w_268,limit_1/format,f_jpg","2.jpg");
        ThreadDemo2 t3 = new ThreadDemo2("https://bkimg.cdn.bcebos.com/pic/0ff41bd5ad6eddc451da99709f91a1fd5266d11695ac?x-bce-process=image/resize,m_lfit,w_268,limit_1/format,f_jpg","3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}
class WebDownloader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，download方法异常");
        }
    }
}

执行结果：根据结果显示并不是按照代码顺序所执行的。

Runnable接口实现

自定义一个类实现Runnable接口
实现run()方法，编写先后曾执行体
创建线程对象，调用start()方法启动线程
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

package com.bestrookie;

/**
 * @author : bestrookie
 * @date : 20:38 2021/1/18
 */
public class RunnableDemo implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        RunnableDemo runnableDemo = new RunnableDemo();
        Thread thread = new Thread(runnableDemo);
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

Runnable实例龟兔赛跑

package com.bestrookie;

/** 模拟龟兔赛跑
 * @author : bestrookie
 * @date : 15:21 2021/1/19
 */
public class Race implements Runnable{
    //胜利者
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && i == 99){
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->已经跑了"+i+"米");
        }
    }
    //判断比赛是否结束
    private boolean gameOver(int steps){
        if(winner != null){
            return true;
        }{
            if (steps >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();

    }
}

实现Callable接口

实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务：ExecutprService ser = Executors.newFixedThreadPool(1);
提交执行：Future result = ser.submit(t1);
获取结果：boolean r = result.get()
关闭服务：ser.shutdownNow()

callable实例

package com.bestrookie.lesson02;

import com.bestrookie.lesson01.ThreadDemo2;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * @author : bestrookie
 * @date : 15:49 2021/1/19
 */
public class CallableDemo implements Callable<Boolean> {
    private String url;
    private String name;
    public CallableDemo(String url,String name){
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableDemo t1 = new CallableDemo("https://bkimg.cdn.bcebos.com/pic/0ff41bd5ad6eddc451da99709f91a1fd5266d11695ac?x-bce-process=image/resize,m_lfit,w_268,limit_1/format,f_jpg","1.jpg");
        CallableDemo t2 = new CallableDemo("https://bkimg.cdn.bcebos.com/pic/0ff41bd5ad6eddc451da99709f91a1fd5266d11695ac?x-bce-process=image/resize,m_lfit,w_268,limit_1/format,f_jpg","2.jpg");
        CallableDemo t3 = new CallableDemo("https://bkimg.cdn.bcebos.com/pic/0ff41bd5ad6eddc451da99709f91a1fd5266d11695ac?x-bce-process=image/resize,m_lfit,w_268,limit_1/format,f_jpg","3.jpg");
        //创建服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> result = ser.submit(t1);
        Future<Boolean> result1 = ser.submit(t2);
        Future<Boolean> result2 = ser.submit(t3);
        //获取结果
        boolean r1 = result.get();
        boolean r2 = result1.get();
        boolean r3 = result2.get();
        //关闭服务
        ser.shutdownNow();
    }
}
class WebDownloader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，download方法异常");
        }
    }
}

静态代理模式

真实对象和代理对象都要实现一个接口
代理对象要代理真实对象

好处：代理对象可以做很多真实对象做不了的事情，真实对象可以专注做自己的事情。

Lambda表达式

为什么要使用lambda表达式

避免匿名内部类定义过多
可以让你的代码看起来很简洁
去掉了一堆没有意义的代码，只留下核心的逻辑

简单的小demo展示为何衍变出lambda表达式

package com.bestrookie.lesson03;

/**
 * @author : bestrookie
 * @date : 21:07 2021/1/19
 */
public class TestLambda {
    //3.使用静态内部类
    static class Like2 implements ILike{

        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }
    public static void main(String[] args) {
        Like like = new Like();
        like.lambda();
        new Like2().lambda();

        //4.局部内部类
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        new Like3().lambda();
        //5.匿名内部类
        ILike iLike = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        iLike.lambda();
        //6.lambda简化
        ILike like1 = ()->{
            System.out.println("i like lambda5");
        };
        like1.lambda();
    }
}

/**
 *1. 定义一个接口
 */
interface ILike{
    void lambda();
}

/**
 * 2.实现类
 */
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

线程的五个状态

创建状态

线程对象一旦创建就进入到了新生状态
就绪状态

当调用start()方法，线程就进入就绪状态，但不以为着立即调度执行
运行状态

当cpu开始调度，线程进入运行状态，线程进入运行状态，线程才真正执行线程体的代码块
阻塞状态

当调用sleep，wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞解除后，重新进入就绪状态，等待cpu调度执行。
死亡状态

线程中断或者结束，一旦进入死亡状态，就不能再次启动。

停止线程

不推荐使用jdk提供的stop()、destory()方法。
推荐线程自己停下来
建议使用一个标志位进行终止变量，当flg=false，则终止线程运行。

线程休眠 sleep()

sleep(时间)指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会释放锁

线程礼让 yield()

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让cpu重新调度，礼让不一定成功

Join()插队

join()合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
可以想象成插队

Java中线程的六种状态

**初始(NEW)**：新创建了一个线程对象，但还没有调用start()方法。
**运行(RUNNABLE)**：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
**阻塞(BLOCKED)**：表示线程阻塞于锁。
**等待(WAITING)**：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
**超时等待(TIMED_WAITING)**：该状态不同于WAITING，它可以在指定的时间后自行返回。
**终止(TERMINATED)**：表示该线程已经执行完毕。

守护线程（daemon）

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
例如：后台记录操作日志，监控内存，垃圾挥手等待…

线程同步

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问的正确性，在访问加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题
- 一个线程持有锁会导致其他所需要此锁的线程挂起
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法synchronized方法和synchronized块
synchronized方法控制“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个所，继续执行

缺陷：若将一个大的方法声明为synchronized将会影响效率

同步块

同步块：synchronized(obj){}
obj称之为同步监视器
- obj可以是任何对象，但是推荐使用公共资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者class
同步监视器的执行过程
1. 第一个线程访问，锁定同步监视器，执行其中代码
2. 第二个线程访问，发现同步监视器被锁定，无法访问
3. 第一个线程访问完毕，解锁同步监视器
4. 第二个线程访问，发现同步监视器没有锁，然后锁定访问

同步方法案例

package com.bestrookie.syn;

/**
 * @author : bestrookie
 * @date : 21:57 2021/1/21
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        ByTicket byTicket = new ByTicket();
        new Thread(byTicket,"黄牛").start();
        new Thread(byTicket,"学生").start();
        new Thread(byTicket,"路人").start();
    }
}
class ByTicket implements Runnable{
    private int ticket = 10;
    boolean flg = true;

    @Override
    public void run() {
        while (flg){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
    private synchronized void buy() throws InterruptedException {
        if (ticket <= 0){
            flg = false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"买到了第"+ticket--);

    }
}

同步块案例

package com.bestrookie.syn;

/**
 * @author : bestrookie
 * @date : 22:47 2021/1/21
 */
public class UnSafeBank {
    public static void main(String[] args) {
        Account account = new Account(1000,"存款");
        Drawing you = new Drawing(account,50,"你");
        Drawing gg = new Drawing(account,100,"gg");
        you.start();
        gg.start();
    }
}

class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
class Drawing extends Thread{
    Account account;
    int drawMoney;
    int nowMoney;
    public Drawing(Account account,int drawMoney,String name){
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        synchronized (account){
            if (account.money-drawMoney < 0){
                System.out.println(Thread.currentThread().getName()+"存款不足");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.money - drawMoney;
            nowMoney = nowMoney + drawMoney;
            System.out.println(account.name+"余额为"+account.money);
            System.out.println(this.getName()+"手里的钱为:"+nowMoney);
        }
    }
}

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题

死锁的例子

package com.bestrookie.syn;

/**
 * @author : bestrookie
 * @date : 22:22 2021/1/22
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"1");
        Makeup g2 = new Makeup(1,"2");
        g1.start();
        g2.start();
    }
}
class Lipstick{

}
class Mirror{

}
class Makeup extends Thread{
    static  Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    int choice;
    String girlName;
    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }
    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void makeup() throws InterruptedException {
        if (choice == 0){
            synchronized (lipstick){
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(100);
                synchronized (mirror){
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }
        }else {
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(200);
                synchronized (lipstick){
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }
}

死锁避免的方法

产生死锁的四个必要条件
1. 互斥条件：一个资源每次只能被一个进程使用
2. 请求与保持条件：一个进程请求资源而阻塞时，对已获得的资源保持不放
3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

Lock(锁)

从JDL5.0开始，java提供了更强大的线程同步机制—通过显示定义同步锁定对象来实现同步。同步锁使用Lock对象充当
java.util.com.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock（可重入锁）类实现了Lock,它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显示加锁、释放锁。

class A{
    private final ReenreantLock lock = new Reen TrantLock();
    private void m(){
        lock.lock();
        try{
         //保证线程安全的代码   
        }
        finally{
            lock.unlock();
            //如果同步代码有异常，要将unlock()写入finally语句块
        }
    }
}

synchronized与Lock的对比

Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：
- Lock>同步代码块(已经进入了方法体，分配了相应资源)>同步方法（在方法体之外）

线程通信（生产者消费者问题）

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，知道仓库中的产品被消费者取走为止
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，知道仓库中再次放入产品为止

分析：

这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件

对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
在生产者消费者问题中，仅有synchronized是不够的
- synchronized可阻止并更新同一个资源，实现了同步
- synchronized不能用来实现不同线程之间的消息传递（通信）

java提供了几个方法解决线程之间的通信问题

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegalMonitorStateException

解决方式（一）

并发协作模型“生产者/消费者模式”–>管程法

生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

package com.bestrookie.syn;

/**
 * @author : bestrookie
 * @date : 22:14 2021/1/23
 */
public class TestPc {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Producers(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Producers extends Thread{
    SynContainer container;
    public Producers(SynContainer container){
        this.container = container;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                container.push(new Goods(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产了"+i+"个商品");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                System.out.println("消费了-->"+container.pop().id+"个商品");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//产品
class Goods{
    int id;
    public Goods(int id){
        this.id = id;
    }

}
//缓冲区
class SynContainer{
    //定义一个容器的大小
    Goods [] goods = new Goods[10];
    int count = 0;
    public synchronized void push(Goods good) throws InterruptedException {
        //如果容器满了，等待消费者消费
        while (count == goods.length){
            this.wait();
        }
        //如果没有满，我们就需要丢入产品
        goods[count] = good;
        count++;
        //可以通知消费者消费了
        this.notifyAll();
    }
    public synchronized Goods pop() throws InterruptedException {
        //判断等否消费
        while (count == 0){
            //等待生产者生产
            this.wait();
        }
        //如果可以消费
        count--;
        //消费完了通知生产者生产
        this.notifyAll();
        return goods[count];
    }
}

解决方式（二）

并发协作模型“生产者/消费者模式”–>信号灯法

package com.bestrookie.syn;

/**信号灯法，通过标志位解决
 * @author : bestrookie
 * @date : 13:08 2021/1/26
 */
public class TestPc2 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
class Player extends Thread{
    Tv tv;
    public Player(Tv tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2 == 0){
                try {
                    this.tv.play("快乐大本营");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                try {
                    this.tv.play("广告时间");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class Watcher extends Thread{
    Tv tv;
    public Watcher(Tv tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                tv.watch();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Tv{
    //演员表演，观众等待 T
    //观众观看，演员等待 F
    String voice; //表演的节目
    boolean flg = true;
    //表演
    public synchronized void play(String voice) throws InterruptedException {
        if (!flg){
            this.wait();
        }
        System.out.println("演员表演了"+voice);
        //通知观众观看
        this.notifyAll();
        this.voice = voice;
        this.flg = !this.flg;
    }
    //观看
    public synchronized void watch() throws InterruptedException {
        if (flg){
            this.wait();
        }
        System.out.println("观看了"+voice);
        //通知演员表演
        this.notifyAll();
        this.flg = !this.flg;
    }
}

线程池

背景：经常创建和销毁、使用量特别的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
- 提高相应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
  - corePoolSize：表示线程池的常驻核心线程数。如果设置为 0，则表示在没有任何任务时，销毁线程池；如果大于 0，即使没有任务时也会保证线程池的线程数量等于此值。但需要注意，此值如果设置的比较小，则会频繁的创建和销毁线程（创建和销毁的原因会在本课时的下半部分讲到）；如果设置的比较大，则会浪费系统资源，所以开发者需要根据自己的实际业务来调整此值
  - maximunPoolSize：表示线程池在任务最多时，最大可以创建的线程数。官方规定此值必须大于 0，也必须大于等于 corePoolSize，此值只有在任务比较多，且不能存放在任务队列时，才会用到
  - keepAliveTime：表示线程的存活时间，当线程池空闲时并且超过了此时间，多余的线程就会销毁，直到线程池中的线程数量销毁的等于 corePoolSize 为止，如果 maximumPoolSize 等于 corePoolSize，那么线程池在空闲的时候也不会销毁任何线程。

使用线程池

JDK5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadToolExecutor
- void execute(Runnable command)：执行任务/命令,没有返回值，一般用来执行Runnable
- Futursubmit(Callable task)：执行任务，有返回值，一般用来执行Callable
- void shutdown()：关闭连接池
Executors：工具类、线程池的工厂类，用户创建并返回不同类型的线程池

package com.bestrookie.syn;

import java.util.concurrent.*;

/**
 * @author : bestrookie
 * @date : 15:04 2021/1/26
 */
public class TestPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.shutdown();
    }
}
class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}