多线程(五)：基本线程完结

学习内容：

提示：这里可以添加要学的内容
例如：
1、 线程的等待和通知
2、 线程wait()与sleep()的区别
3、 生产者消费者模式
4、 线程池

---

线程的等待和通知

Object类中的方法

• wait() 让当前线程进入等待状态，直到被通知为止
• wait(long) 让当前线程进入等待状态，同时设置时间；直到被通知为止或时间结束
• notify() 随机通知一个等待线程
• notifyAll() 通知所有的等待线程

wait()和sleep()的区别

1. 调用对象不同
   wait() 由锁对象调用
   sleep() 由线程调用
2. 锁使用不同
   执行wait后，自动释放锁
   执行sleep后，不会释放锁
3. 唤醒机制不同
   执行wait后，可以被通知唤醒
   执行sleep后，只能等待时间结束后，自动唤醒

等待或通知方法必须是锁对象，否则会抛出IllegalMonitorStateException异常

/**
 * 通过锁对象将线程等待，经过5秒通知该线程来执行
 */
public class WaitDemo {

    public synchronized void print() throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" +i);
            if(i == 50){
                //让当前线程等待
                this.wait();
            }
        }
    }

    public synchronized void notifyTest(){
        //让等待的线程执行
        this.notifyAll();
    }

    public static void main(String[] args) {
        WaitDemo waitDemo = new WaitDemo();
        new Thread(()->{
            try {
                waitDemo.print();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        waitDemo.notifyTest();
    }
}

生产者消费者模式

一种设计模式，不属于GOF23

生产者和消费者

• 生产者
  某些程序/进程/线程负责生产数据就属于生产者
• 消费者
  某些程序/进程/线程负责使用数据就属于消费者

生产者和消费者之间的问题

• 耦合性高，生产者和消费者联系紧密，不利于系统的扩展和维护
• 并发性能低，同时能处理请求量少
• 忙闲不均，生产者和消费者的速度不一致，带来系统资源的浪费
  
  实现过程：

1. 通过添加缓冲区，设置上限
2. 生产者生产数据，向缓冲区存放，如果满了，生产者进入等待，直到缓冲区有空的位置通知生产者生产；
3. 消费者从缓冲区取数据进行消费，如果空了，消费者进入等待，直到缓冲区有数据再通知消费者消费。

解决问题：

• 解耦
• 提高并发性能
• 解决忙闲不均

package com.hopu.thread;

import java.util.ArrayList;
import java.util.List;

/**
 * 包子铺
 */
public class BaoziShop {
    /**
     * 包子
     */
    class Baozi{
        private int id;
        public Baozi(int id) {
            this.id = id;
        }

        @Override
        public String toString() {
            return "包子--" + id;
        }
    }
    //上限
    public static final int MAX_COUNT = 100;
    //缓冲区 存放数据
    private List<Baozi> baozis = new ArrayList<>();

    /**
     * 做包子
     */
    public synchronized void makeBaozi() throws InterruptedException {
        //判断缓冲区是否满了
        if(baozis.size() == MAX_COUNT){
            System.out.printf("缓冲区满了，%s等待%n",Thread.currentThread().getName());
            //让生产者线程等待
            this.wait();
        }else{
            //通知生产者线程生产
            this.notifyAll();
        }
        //创建包子
        Baozi baozi = new Baozi(baozis.size() + 1);
        System.out.println(Thread.currentThread().getName()+"做了"+baozi);
        //保存到缓冲区
        baozis.add(baozi);
    }

    /**
     * 拿包子
     */
    public synchronized void takeBaozi() throws InterruptedException {
        //判断缓冲区是否空了
        if(baozis.size() == 0){
            System.out.printf("缓冲区空了，%s等待%n", Thread.currentThread().getName());
            //让消费者等待
            this.wait();
        }else{
            //通知消费者消费
            this.notifyAll();
        }
        //获得第一个包子，并删除
        if(baozis.size() > 0){
            Baozi baozi = baozis.remove(0);
            System.out.println(Thread.currentThread().getName()+"吃了"+baozi);
        }
    }

    public static void main(String[] args) {
        BaoziShop baoziShop = new BaoziShop();
        //一个生产者
        Thread productor = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    baoziShop.makeBaozi();
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        productor.start();
        //10个消费者吃10个包子
        for (int i = 0; i < 10; i++) {
            Thread consumer = new Thread(() ->{
                try {
                    for (int j = 0; j < 10; j++) {
                        baoziShop.takeBaozi();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            consumer.start();
        }
    }
}

应用场景：

• 12306售票
• 消息队列
• 线程池
• 等等

阻塞队列

应用了生产者消费者模式的集合，他可以在缓存区满或者空，自动通知线程执行等待和通知，里面有个接口
BlockingQueue 接口

• put 添加数据，达到上限会自动让线程等待
• take 取并删除数据，数据空了会自动让线程等待

实现类

ArrayBlockingQueue 类 数据结构为数组

LinkedBlockingQueue类 链表结构

/**
 * 包子铺
 */
public class BaoziShop2 {
    /**
     * 包子
     */
    static class Baozi{
        private int id;
        public Baozi(int id) {
            this.id = id;
        }

        @Override
        public String toString() {
            return "包子--" + id;
        }
    }


    public static void main(String[] args) {
        //阻塞队列
        BlockingQueue<Baozi> baozis = new ArrayBlockingQueue<>(100);
        //生产者线程
        new Thread(() -> {
            for (int i = 0; i < 200; i++) {
                //创建包子，添加到阻塞队列，满了就自动阻塞线程
                Baozi baozi = new Baozi(baozis.size() + 1);
                try {
                    baozis.put(baozi);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"生产了"+baozi);
            }
        }).start();
        //消费者线程
        for(int i = 0;i < 5;i++){
            new Thread(() -> {
                //取包子,空了会自动阻塞
                for (int j = 0; j < 40; j++) {
                    try {
                        Baozi baozi = baozis.take();
                        System.out.println(Thread.currentThread().getName()+"消费了"+baozi);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

线程池

线程池的创建跟类别可以看前面多线程(二)

线程池的优化配置

线程池的实现类

ThreadPoolExecutor

线程池的构造方法参数：

• corePoolSize 核心线程数，创建线程池后自带线程，不会进行销毁
• maximumPoolSize 最大线程数
• keepAliveTime 存活时间，非核心线程能够闲置的时间，超过后被销毁
• timeUnit 时间单位
• blockingQueue 阻塞队列 存放任务（Runnable）的集合
  优化配置

1. 核心线程数 应该和CPU内核数量相关 CPU内核数 * N （N和任务执行需要时间和并发量相关）

   Runtime.getRuntime().availableProcessors()
   

2. 最大线程数可以和核心线程数一样，避免频繁创建和销毁线程

3. 如果存在非核心线程，设置大一点，避免频繁创建和销毁线程

4. 阻塞队列使用LinkedBlockingQueue，插入和删除任务效率更高

线程池的实现原理

问题：线程池是如何对线程进行回收利用的？
所有线程保存在HashSet中

/**
 * Set containing all worker threads in pool. Accessed only when
 * holding mainLock.
 */
private final HashSet<Worker> workers = new HashSet<Worker>();