Bootstrap

初始JavaEE篇——多线程(5):生产者-消费者模型、阻塞队列

在这里插入图片描述

找往期文章包括但不限于本期文章中不懂的知识点:

个人主页:我要学编程程(ಥ_ಥ)-CSDN博客

所属专栏:JavaEE

前面我们学习多线程的经典案例之一:饿汉模式与懒汉模式。两者的区别是创建类的实例的时机不同,前者是迫不及待的去创建类的实例,而后者是迫不得已去创建类的实例。这样就导致了前者在 get 方法中只有"读"操作,不会造成线程安全问题,而后者会出现线程安全问题。最后经过我们的不断深入探索并解决了其中的问题。首先是进行加锁操作,避免了修改操作原子性,其次是加了 if 判断语句,避免了不必要的加锁,从而导致的性能下降,最后,针对指令重排序的问题,在引用变量中加上了 volatile 关键字。如果想更加深入了解,可以点击下面的链接:饿汉模式、懒汉模式、指令重排序等

阻塞队列

现在我们来学习另外一个经典的案例:阻塞队列。
阻塞队列是属于队列的一种,但是和普通的队列相比,它具有以下的特性:
1、它具备线程安全的特点,即使在多线程的环境下,也是可以正常使用的。
2、阻塞特性:1)当队列为空时,如果再去队列中取元素的话,会发生阻塞,直至队列不为
空;2)当队列满了时,如果再去队列中插入元素的话,也会发生阻塞,直至队列不为满。

生产者—消费者模型

阻塞队列的主要应用场景是:“生产者—消费者模型”。那什么是生产者,什么又是消费者呢?简单理解就是,生产者与消费者之间是通过某种资源进行来进行交互的。生产者,就是生产这个资源的,而消费者,就是消耗这个资源的。
例如,在我们日常中,最常见的就是包饺子,包饺子需要擀面皮的人、包饺子的人、放面皮的布。(肉已经被绞肉机给搞好了) 这里就是一个经典的"生产者一消费者模型"。
生产者:擀面皮的人、消费者:包饺子的人、阻塞队列:放面皮的布。这里生产者与消费者进行交互的就是"面皮"这种资源。
我们在日常生活中,有两种包饺子的方式:
1、家里面几个人全部一起参与包饺子的全过程。即每个人都需要 擀面皮、包饺子。而擀面杖只有一个,那么当一个人在进行擀面皮时,另外几个人都得阻塞等待,当这个人把面皮给擀完之后,才会释放,这样下一个人才有机会去使用。这个擀面杖就是我们前面学习的锁。
上面的方式,我们会发现一个很大的缺陷:当其中一个人在生产面皮时,其余的人得阻塞等待,也就是有空闲时间。这对于计算机来说,简直就是浪费,因此下面这种方式更为合理。
2、一个人专门擀面皮,另外的人负责包饺子,这样就不会导致生产者或者消费者会出现空闲的情况(生产速度与消费速度是一致的)。

生产者—消费者模型的优势:

1、解耦合:
生产者与消费者避免了直接交互,而是通过阻塞队列来进行交互,这样有利于代码的解耦合,使得后期的维护成本变低。
2、削峰填谷:
当 生产者—消费者模型 应用于两个服务器时,就可以达到削峰填谷的效果。

在这里插入图片描述

因此为了避免上述的情况,我们需要对用一个阻塞队列来处理这种"突然的大量请求的情况"。例如,学校选课的时候,通常就会出现这样的情况。
解决方法:使用一个阻塞队列来充当缓冲的作用。当A服务器突然接收到有大量的请求时,这个阻塞队列便会接收这些请求,但是还是以平常的速度给到B服务器,这样B服务器还是会正常运行,这就是 “削峰”。当这个峰值过去之后,就是平常少量的请求,而阻塞队列这时候就会来处理在高峰期接收的请求,这样B服务器还是以平常的速度在处理请求,这就是"填谷"。阻塞队列通过降低高峰期的发送请求,而是在低谷期来处理,这样B服务器就是以一个平均的速度在处理请求。
注意:
1、阻塞队列通常可以接收并存放很多的请求。
2、高峰期比较短,所以阻塞队列一般不会出现满的情况。

生产者—消费者模型的劣势:

1、引入阻塞队列之后,整体的结构相交以前更为复杂了,同时也需要更多的机器进行部署,使生产环境的结构更复杂,同时管理起来也更为麻烦了。
2、效率也有一定的影响。之前是A服务器和B服务器直接进行交互,现在多了个阻塞队列,消息的传递所消耗的时间也变多了。

Java标准库中的阻塞队列:

Java的标准库中提供的阻塞队列是:BlockingQueue。

在这里插入图片描述

我们在日常的开发中,主要就是使用:ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue。下面是使用的示例:

在这里插入图片描述

public class Test {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(100);
        // 在多线程中,队列的插入方法要用put。因为其带有阻塞功能,且线程安全
        queue.put(1);
        queue.put(2);
        queue.put(3);
        queue.put(4);
        // 同样多线程中的删除也要用take
        int n = queue.size();
        for (int i = 0; i < n; i++) {
            System.out.print(queue.take()+" "); // 1 2 3 4
        }
    }
}

我们现在可以去看一下阻塞功能。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(1);
        // 在队列为空的情况下,尝试去取元素
        System.out.println(queue.take()); // 由于是单线程,因此会一直阻塞,即死等。

        queue.put(1);
        // 在队列为满足,尝试去插入新元素
        queue.put(2);
    }
}

同样下面去尝试插入新元素时,也是会发生阻塞等待的,也是死等的情况。

public class Test {
    public static void main(String[] args) {
        int n = 1;
        System.out.println("队列的总容量:"+n);
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(n);
        System.out.println("队列此时的容量:"+queue.size());

        Thread t1 = new Thread(()-> {
            try {
                System.out.println("阻塞队列为空,尝试取出元素,等待其他的线程插入元素");
                queue.take();
                System.out.println("成功取出元素~");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread t2 = new Thread(()->{
            try {
                for (int i = 0; i < 3; i++) {
                    Thread.sleep(1000); // 确保t1线程先执行到take方法,并放慢让我们观察
                    System.out.println("正在尝试插入第" + (i + 1) + "个元素");
                    queue.put(i);
                    System.out.println("插入成功~");
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

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

运行结果:
在这里插入图片描述

模拟实现阻塞队列:

要求:我们主要是实现队列的 put方法、take方法、size方法即可。

思路:put、take方法都需要保证线程安全和阻塞的特性。
线程安全,我们直接对代码进行加锁操作即可;
阻塞特性:当队列为满时,要阻塞到其他线程使用掉其中的对头元素,即得等待其他线程调用take方法来唤醒当前因队列满而造成的阻塞,这也就需要用到我们前面学习的wait 和 notify 方法。

阻塞队列代码:

public class MyBlockingQueue {
    // 基于数组去模拟实现
    private static int[] array = null;
    private static int usedSize = 0; // 元素个数
    private int head = 0; // 头指针
    private int tail = 0; // 尾指针

    public MyBlockingQueue() {
        array = new int[10];
    }

    public MyBlockingQueue(int capacity) {
        if (capacity < 0) {
            throw new RuntimeException();
        } else if (capacity >= Integer.MAX_VALUE) {
            array = new int[Integer.MAX_VALUE];
        } else {
            array = new int[capacity];
        }
    }

    // put方法
    public void put(int x) throws InterruptedException {
        synchronized (this) { // 保证线程安全
            while (usedSize >= array.length) { // 满足阻塞队列的特性
                // 阻塞等待
                this.wait(); // 等待其他线程取出元素,使队列不为满
            }
            array[tail] = x;
            tail = (tail+1) % array.length; // 这里是采用循环队列的方式
            usedSize++;
            this.notify(); // 唤醒空的阻塞
        }
    }

    public int take() throws InterruptedException {
        synchronized (this) { // 保证线程安全
            while (usedSize <= 0) { // 满足阻塞队列的特性
                // 阻塞等待
                this.wait(); // 等待其他线程插入元素,使队列不为空
            }
            int ans = array[head];
            head = (head+1) % array.length;
            usedSize--;
            this.notify(); // 唤醒满的阻塞
            return ans;
        }
    }

    public int size() {
        return usedSize;
    }
}

测试代码:

public class Test {
    public static void main(String[] args) throws InterruptedException {
        int n = 1;
        MyBlockingQueue queue = new MyBlockingQueue(n);
        System.out.println("队列的总容量为:"+n);
        System.out.println("队列当前的容量为:"+queue.size());
        Thread t1 = new Thread(()->{
            try {
                Thread.sleep(500);
                System.out.println("队列为空,阻塞等待别的线程插入数据");
                queue.take();
                System.out.println("取出元素~");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println("正在尝试插入第"+(i+1)+"个元素");
                    queue.put(i);
                    System.out.println("插入成功~");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

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

运行结果:

在这里插入图片描述

注意:
1、我们使用加锁操作,是为了避免出现下面这种情况:一个线程在修改,另一个线程在读取,把数据修改之后,可能会造成另一个线程执行有误,因此我们得对代码进行加锁操作,是同一时刻只能有一个线程去进行修改操作(读取操作是不会影响数据的),因此对于修改操作的代码,都得处于 synchronized 代码块中,而上述 put、take 方法的大部分代码都是修改操作,因此我们就将整个代码逻辑都置于 synchronized 代码块中了。

2、put、take 方法中之所以将判断阻塞的条件放到 while 循环中,是因为可能会出现下面这样的情况:有三个线程都是处于put方法的阻塞状态,而这时新来了一个执行take方法的线程,其会随机唤醒三个线程中的一个,当三个线程中,某个线程执行完 notify 方法之后,也会随机唤醒剩下的两个线程,但是此时这个唤醒操作不符合要求,因为我们是希望将处于take方法的阻塞线程所唤醒,因此这个是错误唤醒,所以我们要用 while 循环去再次线程判断到底是不是因为正常唤醒而被唤醒的。

好啦!本期 初始JavaEE篇——多线程(4):生产者-消费者模型、阻塞队列 的学习之旅 就到此结束啦!

;