多线程

⬅前排提示：左侧导航栏是有目录的，可以快速定位

一、程序、进程、线程

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

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

二、线程创建

1、继承 Thread 类

• 自定义线程类继承 Thread 类

• 重写 run() 方法，编写线程执行体

• 创建线程对象，调用 start() 方法启动线程

public class ThreadTest extends Thread {
    @Override
    public void run() {
        // run 方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("Robot" + i + "号");
        }
    }

    public static void main(String[] args) {

        // 创建一个线程对象
        ThreadTest threadTest = new ThreadTest();

        // 调用 start() 方法开启线程
        threadTest.start();

        // main 线程，主线程
        for (int i = 0; i < 700; i++) {
            System.out.println("Rororobot" + i + "号");
        }
    }
}

总结：注意点，线程开启不一定立即执行，由 CPU 调度执行

多线程下载器练习：

/**
 * 练习 Thread，实现多线程同步下载图片
 * @author Cyril.P
 * @description
 * @date 2021-03-18-22:22
 */
public class ThreadExer extends Thread {

    /**
     * 网络图片地址
     */
    private String url;
    /**
     * 保存的文件名
     */
    private String name;

    public ThreadExer(String url, String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为："+name);
    }

    public static void main(String[] args) {
        ThreadExer t1 = new ThreadExer("",""); //第一个参数：资源的url，第二个参数：文件名
        ThreadExer t2 = new ThreadExer("","");
        ThreadExer t3 = new ThreadExer("","");

        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异常：downloader方法出现问题");
        }
    }
}

2、实现 Runnable 接口

• 定义 MyRunnable 类实现 Runnable 接口
• 实现 run() 方法，编写线程执行体
• 创建线程对象，调用 start() 方法启动线程

public class RunnableTest implements Runnable {
    @Override
    public void run() {
        // run 方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("Robot" + i + "号");
        }
    }

    public static void main(String[] args) {

        // 创建 runnable 接口的实现类对象
//        RunnableTest threadTest = new RunnableTest();
        // 创建线程对象，通过线程对象来开启我们的线程，代理
//        Thread thread = new Thread(threadTest);
        // 调用 start() 方法开启线程
//        thread.start();
        new Thread(new RunnableTest()).start();

        // main 线程，主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("Rororobot" + i + "号");
        }
    }
}

小结：

• 继承 Thread 类
  • 字类继承 Thread 类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免 OOP 单继承局限性
• 实现 Runnable 接口
  • 实现接口 Runnable 具备多线程能力
  • 启动线程：传入目标对象 + Thread 对象.start()
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

经典抢票问题：

public class Tickets implements Runnable {

    private int ticketNum = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                break;
            }

            // 模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");

        }
    }

    public static void main(String[] args) {
        Tickets tickets = new Tickets();

        new Thread(tickets,"赵露思").start();
        new Thread(tickets,"迪丽热巴").start();
        new Thread(tickets,"古力娜扎").start();
    }
}

案例：龟兔赛跑

1. 设置赛道距离，并且需要离终点越来越近
2. 判断比赛是否结束
3. 打印出胜利者
4. 比赛开始
5. 通过线程 sleep 模拟兔子睡觉
6. 结果达成乌龟获胜

public class Race implements Runnable {

    /**
     * 胜利着
     */
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            // 模拟兔子偷懒
            if (("兔子").equals(Thread.currentThread().getName()) && i % 50 == 0) {
                try {
                    Thread.sleep(1);
                } 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("The 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();
    }
}

3、实现 Callable 接口

1. 实现 Callable 接口，需要返回值类型

2. 重写 call 方法，需要抛出异常

3. 创建目标对象

4. 创建执行服务：

   ExecutorService ser = Executor.newFixedThreadPool(1);
   

5. 提交执行：

   Future<Boolean> result = ser.submit(t1);
   

6. 获取结果：

   boolean r1 = result1.get();
   

7. 关闭服务：

   ser.shutdownNow();
   

Demo：

public class CallableTest implements Callable<Boolean> {
    /**
     * 网络图片地址
     */
    private String url;
    /**
     * 保存的文件名
     */
    private String name;

    public CallableTest(String url, String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        WebDownloader2 webDownloader = new WebDownloader2();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableTest t1 = new CallableTest("","");
        CallableTest t2 = new CallableTest("","");
        CallableTest t3 = new CallableTest("","");

        //1. 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //2. 提交执行
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);
        //3. 获取结果
        boolean resultStatus1 = result1.get();
        boolean resultStatus2 = result2.get();
        boolean resultStatus3 = result3.get();
        //4. 关闭服务
        ser.shutdownNow();
    }
}

/**
 * 下载器
 */
class WebDownloader2{
    // 下载方法
    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异常：downloader方法出现问题");
        }
    }
}

callable 创建线程的好处：

• 可以定义返回值
• 可以抛出异常
  
  

4、线程池创建

在业务代码中，一般都不采取以上三种启动线程的方式，因为进来一个就 new 一个 Thread 然后 start，若干个就是对应若干个，而分配的堆、栈空间确实有限的，就很有可能会导致资源耗尽。

应该将所有的多线程异步任务都交给线程池执行，达到资源的可控制，保证性能的稳定性；

并且最好确保当前系统中只有一两个线程池，每个异步任务都提交给线程池，让线程池去执行

public static ExecutorService service = Executors.newFixedThreadPool(10);
service.submit(Callable / Runnable<T>);	// 可以获取到返回值
service.execute(Runnable);	// 执行异步任务，没有返回值

三、线程状态

观察线程状态

public class State {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("===========");
        });

        // 观察 new 状态
        Thread.State state = thread.getState();
        // NEW
        System.out.println(state);

        // 观察启动后
        // 启动线程
        thread.start();
        state = thread.getState();
        // RUNNABLE
        System.out.println(state);

        //
        while (state != Thread.State.TERMINATED) {
            // 只要线程不终止，就一直输出状态
            Thread.sleep(100);
            // 更新线程状态
            state = thread.getState();
            System.out.println(state);

        }

        //线程一旦进入死亡状态，就不能再次启动 start
    }

}

四、线程方法

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long mills)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其它线程
【禁用】void interrupt()	中断线程。不能用此方法！
boolean isAlive()	测试线程是否处于活动状态

1、线程停止

• 建议线程正常停止 ----> 利用次数，不建议死循环
• 建议使用标识位 ----> 设置一个标识位
• 不要使用 stop 或 destory 等 过时 或者 JDK不建议使用的方法

Demo：

/**
 * 测试 STOP
 * 1、建议线程正常停止  ---->  利用次数，不建议死循环
 * 2、建议使用标识位  ---->  设置一个标识位
 * 3、不要使用 stop 或 destory 等 过时 或者 JDK不建议使用的方法
 *
 * @author Cyril.P
 * @description
 * @date 2021-03-19-23:24
 */
public class Stop implements Runnable {

    // 1、设置一个标识位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println(i++ + "、我爱迪丽热巴啊！");
        }
    }

    // 2、设置一个公开的方法停止线程，转换标识位
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        Stop stop = new Stop();
        new Thread(stop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main开！" + i);
            if (i == 726) {
                // 调用 stop 方法切换标识位，让线程停止
                stop.stop();
                System.out.println("虽然呢确实停下来了，但我还是爱迪丽热巴！");
            }
        }
    }
}

2、线程休眠

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

模拟延时

/**
 * 模拟延时：放大问题的发生行
 * @author Cyril.P
 * @description
 * @date 2021-03-20-0:24
 */
public class Sleep implements Runnable {
    private int ticketNum = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                break;
            }

            // 模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");

        }
    }

    public static void main(String[] args) {
        Tickets tickets = new Tickets();

        new Thread(tickets,"赵露思").start();
        new Thread(tickets,"迪丽热巴").start();
        new Thread(tickets,"古力娜扎").start();
    }
}

模拟倒计时

/**
 * 模拟倒计时
 * @author Cyril.P
 * @description
 * @date 2021-03-20-0:34
 */
public class Sleep2 {

    public static void main(String[] args) {
//        try {
//            tenCountDown();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        // 打印当前系统时间
        Date systemTime = new Date(System.currentTimeMillis());
        while (true) {
            try {
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(systemTime));
                Thread.sleep(1000);
                // 更新当前系统时间
                systemTime = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 模拟10秒倒计时
    public static void tenCountDown() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }
    }

}

3、线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态，重新跟其他线程进行抢夺
• 让 CPU 重新调度，礼让不一定成功！看 CPU 心情。

/**
 * 礼让线程
 * 礼让不一定成功，看 CPU 心情
 * @author Cyril.P
 * @description
 * @date 2021-03-20-1:11
 */
public class Yield {
    public static void main(String[] args) {
        new Thread(new MyYield(),"A").start();
        new Thread(new MyYield(),"B").start();

    }
}

class MyYield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" Start");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+" End");
    }
}

4、线程插队

• join 合并线程，待此线程执行完成后，再执行其它线程，其他线程阻塞；
• 可以想象成插队

public class Join implements Runnable {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Join());
        t1.start();
        for (int i = 0; i < 200; i++) {
            if (i == 100) {
                t1.join();
            }
            System.out.println("main"+i);
        }
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+"迪丽热巴");
        }
    }
}

五、线程优先级

• Java 提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
• 线程的优先级用数字表示，范围从1~10
  • Thread.MIN_PRIORITY = 1;
  • Thread.NORM_PRIORITY = 5;
  • Thread.MAX_PRIORITY = 10;
• 使用以下方式获取或改变线程优先级
  • getPriority() setPriority(int)

建议在 start() 调度线程前设置线程优先级

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，线程调度是要看 CPU 的，也并不一定优先级高的线程先被调度

六、守护（daemon）线程

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程实行完毕
• 守护线程如后台记录操作日志、监控内存、垃圾回收等待

七、线程同步

并发：同一个对象被多个线程同时操作

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

八、同步方法及同步块

一、同步方法

• 由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

  同步方法：public synchronized void method(int args){}

• synchronized 方法控制对“对象”的访问，每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

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

方法里面需要修改的内容才需要所，不然锁的太多，会造成资源的浪费

Synchronized 方法默认锁的是调用方法的 this 对象。

二、同步块

• 同步块：synchronized(Obj) {//需要被同步的代码}

  1. 操作共享数据的代码，即为需要被同步的代码

  2. 共享数据：多个线程共同操作的变量，比如：tickets就是共享数据

  3. 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

     要求：多个线程必须要共同用同一把锁！

• Obj 称之为 同步监视器

  • Obj 可以是任何对象，但是推荐使用共享资源作为同步监视器，需要是进行增删改的对象
  • 同步方法中无需指定同步监视器，因为同步方法的同步监视就是 this，就是这个对象本身，或者是 class【反射设计的知识点】

• 同步监视器的执行过程

  1. 第一个线程访问，锁定同步监视器，执行其中代码
  2. 第二个线程访问，发现同步监视器被锁定，无法访问
  3. 第一个线程访问完毕，解锁同步监视器
  4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

Synchronized 代码块锁的对象应该是变化的量或者 class，变化的量涉及到增删改，称为同步监视器

九、JUC

JUC 是关于并发编程的包【java.util.concurrent】，提供一些并发同步的类，后期学习并记录

十、死锁

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

Demo

/**
 * 死锁：多个线程相互抱着对方需要的资源，然后形成僵持，导致死锁
 *
 * @author Cyril.P
 * @description
 * @date 2021-03-20-17:06
 */
public class DeadLock {

    public static void main(String[] args) {
        Exchange p1 = new Exchange(0, "迪丽热巴");
        Exchange p2 = new Exchange(1, "古力娜扎");

        p1.start();
        p2.start();
    }

}

/**
 * 钱
 */
class Money {

}

/**
 * 货
 */
class Goods {

}

class Exchange extends Thread {

    /**
     * 需要的资源只有一份，用 static 来保证只有一份
     */
    static Money money = new Money();
    static Goods goods = new Goods();

    /**
     * 选择钱或者货物
     */
    int choice;
    /**
     * 角色
     */
    String people;

    Exchange(int choice, String people) {
        this.choice = choice;
        this.people = people;
    }

    @Override
    public void run() {
        // 交换
        try {
            exchange();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 交换，互相持有对方的锁，需要拿到对方的资源
    public void exchange() throws InterruptedException {
        if (choice == 0) {
            // 获得 钱 的锁
            synchronized (money) {
                System.out.println(this.people + " 获得 钱 的锁");
                Thread.sleep(1000);

                // 互相抱住资源，会导致死锁
//                // 一秒钟后想获得 货
//                synchronized (goods) {
//                    System.out.println(this.people + " 一秒钟后获得 货 的锁");
//                }
            }
            // 在外面不抱住锁，不会产生死锁
            // 一秒钟后想获得 货
            synchronized (goods) {
                System.out.println(this.people + " 一秒钟后获得 货 的锁");
            }
        } else {
            // 获得 货 的锁
            synchronized (goods) {
                System.out.println(this.people + " 获得 货 的锁");
                Thread.sleep(2000);

                // 互相抱住资源，会导致死锁
//                // 两秒钟后想获得 钱
//                synchronized (money) {
//                    System.out.println(this.people + " 两秒钟后获得 钱 的锁");
//                }
            }
            // 在外面不抱住锁，不会产生死锁
            // 两秒钟后想获得 钱
            synchronized (money) {
                System.out.println(this.people + " 两秒钟后获得 钱 的锁");
            }
        }
    }
}

死锁避免条件

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

上面列出了死锁的四个必要条件，我们只要想办法打破其中的任意一个或多个条件就可以避免死锁发生

十一、Lock（锁）

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

public class LockTest {
    public static void main(String[] args) {
        LockTest2 lockTest2 = new LockTest2();

        new Thread(lockTest2).start();
        new Thread(lockTest2).start();
        new Thread(lockTest2).start();
    }
}

class LockTest2 implements Runnable {

    int ticketNums = 10;

    /**
     * 定义 lock 锁
     */
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {

            try {
                lock.lock(); // 加锁

                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+ticketNums--);
                } else {
                    break;
                }
            } finally {
                lock.unlock(); // 释放锁
            }

        }
    }
}

synchronized 与 Lock 的对比

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

十二、线程通信及线程协作

1、线程通信

wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器

notify()：一旦执行此方法，就会唤醒被 wait 的一个线程。如果有多个线程被 wait，就唤醒优先级高的线程

notifyall()：一旦执行此方法，就会唤醒所有被 wait 的线程

说明：

1. wait()，notify()，notifyall() 三个方法必须使用在同步代码块或同步方法中。
2. wait()，notify()，notifyall() 三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则会出现IllegalMonitorStateException异常
3. wait()，notify()，notifyall() 三个方法是定义在 java.lang.Object 类中。

线程中 sleep() 和 wait() 的异同：

同：一旦执行完成，都可以使得当前的线程进入阻塞状态

不同：

1. 两个方法声明的位置不同：Thread 类中声明了 sleep()；Object 类中声明了 wait()；

2. 调用的要求不同：sleep() 可以在任何需要的场景下调用；wait() 必须在同步代码块或同步方法中调用；

3. 关于是否释放同步监视器（锁）：

   如果两个方法都是用在同步代码块或同步方法中，sleep() 不会释放同步监视器（锁），wait() 会释放同步监视器（锁）

2、生产者消费者模式

1）、并发协作模型“生产者 / 消费者模式”——>管程法

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

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

Demo:

/**
 * 生产者-消费者模式 ——> 利用缓冲区解决：管程法
 * @author Cyril.P
 * @description
 * @date 2021-03-20-20:06
 */
public class ProductorConsumer {

    public static void main(String[] args) {
        SyncContainer container = new SyncContainer();

        new Productor(container).start();
        new Consumer(container).start();
        new Consumer(container).start();
    }

}

/**
 * 生产者
 */
class Productor extends Thread {

    SyncContainer container;

    public Productor(SyncContainer container) {
        this.container = container;
    }

    // 生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Hamburg(i));
            System.out.println("生产了"+i+"个汉堡");
        }
    }
}

/**
 * 消费者
 */
class Consumer extends Thread {
    SyncContainer container;

    public Consumer(SyncContainer container) {
        this.container = container;
    }

    // 消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了ID为"+container.pop().id+"的汉堡");
        }
    }
}

/**
 * 产品
 */
class Hamburg {
    int id;

    public Hamburg(int id) {
        this.id = id;
    }
}

/**
 * 缓冲区
 */
class SyncContainer {

    /**
     * 容器大小
     */
    Hamburg[] hamburgs = new Hamburg[10];

    /**
     * 容器计数器
     */
     int count = 0;
     

    // 生产者放入产品
    public synchronized void push(Hamburg hamburg) {
        // 如果容器满了，就需要等待消费者消费
        while (count == hamburgs.length) {
            // 通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 如果没有满，就需要丢入产品
        hamburgs[count] = hamburg;
        count++;

        // 有产品放入了，可以通知消费者消费了
        this.notifyAll();

    }

    // 消费者消费产品
    public synchronized Hamburg pop() {
        // 判断能否消费
        while (count == 0){
            // 等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 如果可以消费
        count--;
        Hamburg hamburg = hamburgs[count];

        // 消费了，通知生产者进行生产
        this.notifyAll();

        return hamburg;
    }

}

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

Demo：

/**
 * 生产者-消费者模式 ——> 信号灯法，通过标识位解决
 *
 * @author Cyril.P
 * @description
 * @date 2021-03-20-21:53
 */
public class ProductorConsumer2 {

    public static void main(String[] args) {
        Movie movie = new Movie();

        new Actor(movie).start();
        new Audience(movie).start();
    }

}

/**
 * 生产者 ——> 演员
 */
class Actor extends Thread {
    Movie movie;
    public Actor(Movie movie){
        this.movie = movie;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.movie.makingMovie("《我爱迪丽热巴》");
            } else {
                this.movie.makingMovie("《迪丽热巴爱我》");
            }
        }
    }
}

/**
 * 消费者
 */
class Audience extends Thread {
    Movie movie;
    public Audience(Movie movie){
        this.movie = movie;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            movie.watchMovie();
        }
    }
}

/**
 * 产品
 */
class Movie {
    // 演员拍戏时，观众等待   true
    // 观众观看时，演员等待   false

    String movie;
    boolean flag = true;

    // 拍戏
    public synchronized void makingMovie(String movie) {

        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("迪丽热巴拍了" + movie);
        // 通知观众观看，并将 movie 更新，将标识符 flag 更新
        this.notifyAll();
        this.movie = movie;
        this.flag = !this.flag;
    }

    // 观看
    public synchronized void watchMovie() {

        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("我观看了"+movie);
        // 通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }

}

十三、线程池

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

Demo：

public class ThreadPool {

    public static void main(String[] args) {
        //1、创建服务，创建线程池
        //newFixedThreadPool    参数为 线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        // 执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        // 2、关闭连接
        service.shutdown();
    }

}

class MyThread implements Runnable {

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

补充（阿里巴巴文档）：

手动创建线程池，效果会更好。
Inspection info:
线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:
  允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool:
  允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

Positive example 1：

//org.apache.commons.lang3.concurrent.BasicThreadFactory
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
        new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());

Positive example 2：

ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();

//Common Thread Pool
ExecutorService pool = new ThreadPoolExecutor(5, 200,
    0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

pool.execute(()-> System.out.println(Thread.currentThread().getName()));
pool.shutdown();//gracefully shutdown

Positive example 3：

<bean id="userThreadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <property name="corePoolSize" value="10" />
    <property name="maxPoolSize" value="100" />
    <property name="queueCapacity" value="2000" />
    <property name="threadFactory" value= threadFactory />
    <property name="rejectedExecutionHandler">
        <ref local="rejectedExecutionHandler" />
    </property>
</bean>

//in code
userThreadPool.execute(thread);