【JavaEE】阻塞队列

已于 2024-07-28 22:29:38 修改
阅读量397 收藏 12
点赞数 23
分类专栏： java 文章标签： java 开发语言 java-ee
于 2024-07-28 22:22:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhyhgx/article/details/140751522
版权

目录

一.阻塞队列(Blocking Queue)

1.什么是阻塞队列

2.特性

二.生产者消费者模型

1.什么是生产者消费者模型？

2.生产者消费模型的好处

2.1解耦合  

2.2削峰填谷

三.如何在java中使用阻塞队列

 四.模拟实现阻塞队列

1.加锁

2.阻塞等待实现

3.解决interrupt唤醒waitting问题

4.处理因指令重排序而导致的线程安全问题

测试

 在前一篇中，我们讲到了单例模式中的饿汉模式和懒汉模式，本篇我们来讲在多线程常用的阻塞队列。

一.阻塞队列(Blocking Queue)

1.什么是阻塞队列

阻塞队列是一种特殊的队列，也有着“先进先出”的性质。

2.特性

阻塞队列是一种线程安全的数据结构，具有以下的特性：

  • 当队列满时，继续入队列就会进行阻塞等待，直到其他线程从队列中取出元素
  • 当队列为空时，继续出队列也会进行阻塞对待，直到队列中的元素不为空

阻塞在实际开发应用中，一个典型的应用场景就是“生产者消费者模型”。

二.生产者消费者模型

1.什么是生产者消费者模型？

生产者消费者模型就是通过一个容器来解决生产者和消费者之间的强耦合问题。生产者和消费者之间不直接联系，而是通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，而是直接给队列，消费者就不直接找生产者，而是直接从阻塞队列里取。

2.生产者消费模型的好处

  1. 解耦合：生产者和消费者之间不再直接联系，而是通过阻塞队列。
  2. 削峰填谷：阻塞队列就相当于一个缓冲区，平衡了生产者和消费者之间的处理能力。

2.1解耦合  

我们在开发中， 有些时候可能需要两个或者多个模块或者组件之间的依赖关系不要太紧密，那我们就需要进行解耦合。

解耦合的好处：

  1. 易于维护：当一个模块发生改变时，不会影响到其他模块，减少了修改一处bug而导致多重地方出现bug的风险。
  2. 可扩展性：可以轻松地将新的功能或者模块添加到系统中，无需对系统重构。
  3. 可重用性：独立的模块可以中不同的场景或者项目中使用，提高了代码的复用率。
  4. 简化测试：独立的模块更容易进行单元测试，因为它们不需要依赖复杂的外部环境或状态。

示例：假设现有服务器A和服务器B是直接相联的

服务器A和服务器B是交互是直接的，之间的耦合度是非常高的，若服务器A或者B崩溃，会直接导致服务器B或A也崩溃。

对于上述这种情况，我们就可以使用生产者消费者模型来解决，通过一个阻塞队列，来间接地传递和接受信息。

当服务器A想要向服务器B传递信息时，就将信息传递到阻塞队列中，服务器B再从阻塞队列中将信息取出。通过这个方式，服务器之间的耦合度就大大降低，服务器A若崩溃，服务器B也不会崩溃。

若我们想要添加一个服务器C，那么也不需要对其他服务器做任何修改，直接向阻塞队列请求即可。

2.2削峰填谷

 在高并发的情况下，系统短时间内可能会面临大量数据请求，导致系统资源耗尽。可以使用阻塞队列来削峰填谷，将请求存储在阻塞队列中，按照系统处理能力逐渐消费信息，从而达到削峰填谷的效果，避免系统崩溃或性能降低。

示例：依旧是以上图为例，假设现有大量请求涌进服务器A中，那么此时服务器A不会直接将请求传递给服务器B，若直接传输，会导致服务器B处理不过来直接崩溃。服务器A会将请求传递到阻塞队列中，当阻塞队列满之后，此时阻塞队列不再会接收服务器A的入队请求，而是要等阻塞队列中不为满时才接收服务器A的请求；服务器B从阻塞队列中接收请求并进行处理，直到队列中的请求被服务器B处理完。

三.如何在java中使用阻塞队列

 在java中给我们提供BlockingQueue接口

由于BlockingQueue使一个接口，不能直接去实例化，java中有以下类实现了该接口。

同时我们可以看到，BlockingQueue继承了Queue,所以Queue中offer和poll在BlockingQueue中也有，但我们不使用这两个，需要使用put和take方法才具有阻塞。

 这里我们使用第一个类来做演示：

实现一对一的生产者消费者模型。

public class Demo12 {
    /**
     * 程序的入口点。
     * 创建一个ArrayBlockingQueue，并启动两个线程。一个线程负责生产数字字符串，另一个线程负责消费这些字符串。
     * 这个示例展示了生产者-消费者模式的使用，其中ArrayBlockingQueue作为共享资源，用于在生产者和消费者之间同步数据。
     *
     * @param args 命令行参数
     * @throws InterruptedException 如果线程在执行过程中被中断
     */
    public static void main(String[] args) throws InterruptedException {
        // 创建一个容量为1000的ArrayBlockingQueue，用于生产者和消费者之间的通信
        BlockingQueue<String> BQ = new ArrayBlockingQueue<>(1000);

        // 创建生产者线程，负责向队列中添加数字字符串
        Thread t1 = new Thread(() -> {
            int i = 0;
            while (true) {
                try {
                    // 将数字字符串添加到队列中，如果队列满，则阻塞直到有空间可用
                    BQ.put("" + i);
                    i++;
                } catch (InterruptedException e) {
                    // 如果线程被中断，抛出运行时异常
                    throw new RuntimeException(e);
                }
                System.out.println("生产了" + i);
            }
        });

        // 创建消费者线程，负责从队列中取出数字字符串并消费
        Thread t2 = new Thread(() -> {
            while (true) {
                try {
                    // 从队列中取出一个数字字符串，如果队列为空，则阻塞直到有元素可用
                    String s = BQ.take();
                    System.out.println("消费了" + s);
                    // 模拟消费过程，让线程休眠1秒
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // 如果线程被中断，抛出运行时异常
                    throw new RuntimeException(e);
                }
            }
        });

        // 启动生产者和消费者线程
        t1.start();
        t2.start();
    }

}

 四.模拟实现阻塞队列

阻塞队列的容量是有一定大小的，所以我们首先需要实现一个循环队列。

判空判满条件：

当size==0时，说明队列为空

当size==q.length时，说明队列满了。

如何解决当head或者ptail走到队列末尾，但size不等于队列长度的情况？

当head走到末尾之后，若head等于q.length时，让head=0即可。

同理，当ptail等于q.length时，让ptail=0即可。

/**
 * MyBlockingQueues 类实现了阻塞队列的数据结构。
 * 阻塞队列是一种线程安全的队列，当队列为空时，take 方法会阻塞，直到队列有元素可用；
 * 当队列满时，put 方法会阻塞，直到队列有空闲位置。
 */
class MyBlockingQueues {

    // 存储队列元素的数组
    private String[] q;
    // 指向队列头部的索引
    private int head;
    // 指向队列尾部的索引
    private int ptail;
    // 当前队列中元素的数量
    private int size;
    
    /**
     * 构造函数初始化阻塞队列。
     * 
     * @param capacity 队列的容量，即队列最多可以存储的元素数量。
     */
    public MyBlockingQueues(int capacity) {
        q = new String[capacity];
        size = 0;
    }
    
    /**
     * 将元素添加到队列中。
     * 如果队列已满，则此方法会阻塞，直到队列有空闲位置。
     * 
     * @param s 要添加到队列的元素。
     */
    public void put(String s){
        // 判断队列是否已满，如果已满则返回，否则继续添加元素
        //判断队列是否满了
        if(size==q.length){
            return;
        }
        q[ptail++]=s;
        // 如果尾部索引超过数组长度，则重置为0，实现循环队列
        if(ptail>=q.length){
            ptail=0;
        }
        size++;
    }
    
    /**
     * 从队列中取出一个元素。
     * 如果队列为空，则此方法会阻塞，直到队列有元素可用。
     * 
     * @return 取出的元素。
     */
    public String take(){
        String ret="";
        // 判断队列是否为空，如果为空则返回空字符串，否则继续取出元素
        if(size==0){
            return ret;
        }
        ret=q[head++];
        // 如果头部索引超过数组长度，则重置为0，实现循环队列
        if(head>=q.length){
            head=0;
        }
        size--;
        return ret;
    }

}

1.加锁

当我们实现玩一个循环之后，接下来要实现的就是阻塞队列，阻塞队列，顾名思义就是在队列空/满的时候进行等待，但阻塞队列通常是在多线程下使用的，所以我们需要考虑线程安全问题。

在入队列和出队列的时候，代码块中的代码基本都涉及到了修改操作，因此，我们可以直接对整个代码块进行加锁。

class MyBlockingQueues {

    // 存储队列元素的数组
    private String[] q;
    // 指向队列头部的索引
    private int head;
    // 指向队列尾部的索引
    private int ptail;
    // 当前队列中元素的数量
    private int size;

    /**
     * 构造函数初始化阻塞队列。
     *
     * @param capacity 队列的容量，即队列最多可以存储的元素数量。
     */
    public MyBlockingQueues(int capacity) {
        q = new String[capacity];
        size = 0;
    }

    /**
     * 将元素添加到队列中。
     * 如果队列已满，则此方法会阻塞，直到队列有空闲位置。
     *
     * @param s 要添加到队列的元素。
     */
    public void put(String s){
        synchronized(this) {
            // 判断队列是否已满，如果已满则返回，否则继续添加元素
            //判断队列是否满了
            if (size == q.length) {
                return;
            }
            q[ptail++] = s;
            // 如果尾部索引超过数组长度，则重置为0，实现循环队列
            if (ptail >= q.length) {
                ptail = 0;
            }
            size++;
        }
    }

    /**
     * 从队列中取出一个元素。
     * 如果队列为空，则此方法会阻塞，直到队列有元素可用。
     *
     * @return 取出的元素。
     */
    public String take(){
        String ret="";
        synchronized (this) {
            // 判断队列是否为空，如果为空则返回空字符串，否则继续取出元素
            if (size == 0) {
                return ret;
            }
            ret = q[head++];
            // 如果头部索引超过数组长度，则重置为0，实现循环队列
            if (head >= q.length) {
                head = 0;
            }
            size--;
        }
        return ret;
    }

}

2.阻塞等待实现

当线程安全问题解决之后，我们现在要考虑的就是如何让队列能够进行阻塞等待，我们需要用到wait和notify方法来实现。

在put方法中，当size==q.length时，说明此时队列中已满，需要进行阻塞等待。若没有满则进行入队操作，当入完队之后就可以通知take进行出队操作。

在take方法中，当size==0时，说明此时队列为空，此时同样需要进行阻塞等待（等put通知），若队列不为空，则进行出队操作，当出完队之后就可以通知put进行入队操作。

/**
 * MyBlockingQueues 类实现了阻塞队列的数据结构。
 * 阻塞队列是一种线程安全的队列，当队列为空时，take 方法会阻塞，直到队列有元素可用；
 * 当队列满时，put 方法会阻塞，直到队列有空闲位置。
 */
class MyBlockingQueues {

    // 存储队列元素的数组
    private String[] q;
    // 指向队列头部的索引
    private int head;
    // 指向队列尾部的索引
    private int ptail;
    // 当前队列中元素的数量
    private int size;

    /**
     * 构造函数初始化阻塞队列。
     *
     * @param capacity 队列的容量，即队列最多可以存储的元素数量。
     */
    public MyBlockingQueues(int capacity) {
        q = new String[capacity];
        size = 0;
    }

    /**
     * 将元素添加到队列中。
     * 如果队列已满，则此方法会阻塞，直到队列有空闲位置。
     *
     * @param s 要添加到队列的元素。
     */
    public void put(String s) throws InterruptedException {
        synchronized(this) {
            // 判断队列是否已满，如果已满则返回，否则继续添加元素
            //判断队列是否满了
            if (size == q.length) {
                this.wait();
            }
            q[ptail++] = s;
            // 如果尾部索引超过数组长度，则重置为0，实现循环队列
            if (ptail >= q.length) {
                ptail = 0;
            }
            size++;
        }
    }

    /**
     * 从队列中取出一个元素。
     * 如果队列为空，则此方法会阻塞，直到队列有元素可用。
     *
     * @return 取出的元素。
     */
    public String take() throws InterruptedException {
        String ret="";
        synchronized (this) {
            // 判断队列是否为空，如果为空则返回空字符串，否则继续取出元素
            if (size == 0) {
                this.wait();
            }
            ret = q[head++];
            // 如果头部索引超过数组长度，则重置为0，实现循环队列
            if (head >= q.length) {
                head = 0;
            }
            size--;
        }
        return ret;
    }

}

3.解决interrupt唤醒waitting问题

唤醒wait的不仅有notify，而且还有interrupt，能够唤醒阻塞之后中断线程并且抛出InterruptedException。

在put方法中，如果size==q.length，此时调用put的线程进入阻塞等待(waitting)状态，如果此时使用interrupt会唤醒阻塞并将线程终止。

在take方法中，如果size==0，此时调用take的线程就也会进入阻塞等待(waitting)状态，如果此时使用interrupt会唤醒阻塞并将线程终止。

若对于我们上面的代码中，调用interrupt，线程确实会终止。

我们可以查看一下wait方法的文档说明。

我们可以看到java中建议我们使用while循环来检查等待条件。

为什么可以使用if，还建议使用while？

假设在判断队列是否为空/满的时候。调用wait的方法的时候使用try-catch语句来抛异常，但在catch中忘记添加抛出异常的语句，再调用interrupt会发生什么？

同理，在take方法中，当size=0时，此时wait正在等待，若被唤醒，就会进行出队操作，但由于此时队列中没有数据，出队列操作没有意义。

为了防止这些bug出现，所以我们使用while更加稳妥，当wait被interrupt唤醒之后，会再次判断当前size是否满足判断条件，若满足则继续执行wait，而不会直接执行后序的代码。反之，若size不为0或者q.length,则会跳出循环，执行后序代码。

    public void put(String s)  {
        synchronized(this) {
            // 判断队列是否已满，如果已满则返回，否则继续添加元素
            //判断队列是否满了
            while (size == q.length) {
                try {
                    this.wait();
                } catch (InterruptedException e) {

                }
            }
            q[ptail++] = s;
            // 如果尾部索引超过数组长度，则重置为0，实现循环队列
            if (ptail >= q.length) {
                ptail = 0;
            }
            size++;
        }
    }

修改后的完整代码：

/**
 * 自定义阻塞队列类，用于实现具有固定容量的线程安全队列。
 * 队列满时，生产者线程会被阻塞，直到队列有空位；队列空时，消费者线程会被阻塞，直到队列有元素。
 */
class MyBlockingQueues {

    // 存储队列元素的数组
    private String[] q;
    // 指向队列头部的索引
    private int head;
    // 指向队列尾部的索引
    private int ptail;
    // 当前队列中元素的数量
    private int size;

    /**
     * 构造函数初始化阻塞队列。
     *
     * @param capacity 队列的容量，即队列最多可以存储的元素数量。
     */
    public MyBlockingQueues(int capacity) {
        q = new String[capacity];
        size = 0;
    }

    /**
     * 将一个字符串元素添加到队列中。
     * 如果队列已满，则当前线程被阻塞，直到队列有空位。
     *
     * @param s 要添加到队列的字符串元素。
     * @throws InterruptedException 如果线程在等待时被中断。
     */
    public void put(String s) throws InterruptedException {
        synchronized(this) {
            // 当队列满时，等待直到有空位
            // 判断队列是否已满，如果已满则返回，否则继续添加元素
            //判断队列是否满了
            while (size == q.length) {
                this.wait();
            }
            q[ptail++] = s;
            // 当尾部索引达到数组长度时，重置为0
            // 如果尾部索引超过数组长度，则重置为0，实现循环队列
            if (ptail >= q.length) {
                ptail = 0;
            }
            size++;
            // 唤醒等待的消费者线程
            this.notifyAll();
        }
    }

    /**
     * 从队列中取出一个字符串元素。
     * 如果队列为空，则当前线程被阻塞，直到队列有元素。
     *
     * @return 从队列中取出的字符串元素。
     * @throws InterruptedException 如果线程在等待时被中断。
     */
    public String take() throws InterruptedException {
        String ret="";
        synchronized (this) {
            // 当队列空时，等待直到有元素
            // 判断队列是否为空，如果为空则返回空字符串，否则继续取出元素
            while (size == 0) {
                this.wait();
            }
            ret = q[head++];
            // 当头部索引达到数组长度时，重置为0
            // 如果头部索引超过数组长度，则重置为0，实现循环队列
            if (head >= q.length) {
                head = 0;
            }
            size--;
            // 唤醒等待的生产者线程
            this.notifyAll();
        }
        return ret;
    }

}

4.处理因指令重排序而导致的线程安全问题

在编译器和处理器层面，为了提高性能，可能会对指令进行重排序。由于阻塞队列常用于多线程中，且在put和take要对字段进行频繁的读写操作，为了防止因指令重排序而导致的问题，这里我们需要使用volatie来修饰成员变量，来防止编译器的优化。

/**
 * 自定义阻塞队列类，用于实现具有固定容量的线程安全队列。
 * 队列满时，生产者线程会被阻塞，直到队列有空位；队列空时，消费者线程会被阻塞，直到队列有元素。
 */
class MyBlockingQueues {

    // 存储队列元素的数组
    private volatile String[] q;
    // 指向队列头部的索引
    private volatile int head;
    // 指向队列尾部的索引
    private volatile int ptail;
    // 当前队列中元素的数量
    private volatile int size;

    /**
     * 构造函数初始化阻塞队列。
     *
     * @param capacity 队列的容量，即队列最多可以存储的元素数量。
     */
    public MyBlockingQueues(int capacity) {
        q = new String[capacity];
        size = 0;
    }

    /**
     * 将一个字符串元素添加到队列中。
     * 如果队列已满，则当前线程被阻塞，直到队列有空位。
     *
     * @param s 要添加到队列的字符串元素。
     * @throws InterruptedException 如果线程在等待时被中断。
     */
    public void put(String s) throws InterruptedException {
        synchronized(this) {
            // 当队列满时，等待直到有空位
            // 判断队列是否已满，如果已满则返回，否则继续添加元素
            //判断队列是否满了
            while (size == q.length) {
                this.wait();
            }
            q[ptail++] = s;
            // 当尾部索引达到数组长度时，重置为0
            // 如果尾部索引超过数组长度，则重置为0，实现循环队列
            if (ptail >= q.length) {
                ptail = 0;
            }
            size++;
            // 唤醒等待的消费者线程
            this.notifyAll();
        }
    }

    /**
     * 从队列中取出一个字符串元素。
     * 如果队列为空，则当前线程被阻塞，直到队列有元素。
     *
     * @return 从队列中取出的字符串元素。
     * @throws InterruptedException 如果线程在等待时被中断。
     */
    public String take() throws InterruptedException {
        String ret="";
        synchronized (this) {
            // 当队列空时，等待直到有元素
            // 判断队列是否为空，如果为空则返回空字符串，否则继续取出元素
            while (size == 0) {
                this.wait();
            }
            ret = q[head++];
            // 当头部索引达到数组长度时，重置为0
            // 如果头部索引超过数组长度，则重置为0，实现循环队列
            if (head >= q.length) {
                head = 0;
            }
            size--;
            // 唤醒等待的生产者线程
            this.notifyAll();
        }
        return ret;
    }

}

测试

这里我们设置阻塞队列长度为100.

先让生产者生成100个产品再进行消费。

/**
 * 自定义阻塞队列类，用于实现具有固定容量的线程安全队列。
 * 队列满时，生产者线程会被阻塞，直到队列有空位；队列空时，消费者线程会被阻塞，直到队列有元素。
 */
class MyBlockingQueues {

    // 存储队列元素的数组
    private volatile String[] q;
    // 指向队列头部的索引
    private volatile int head;
    // 指向队列尾部的索引
    private volatile int ptail;
    // 当前队列中元素的数量
    private volatile int size;

    /**
     * 构造函数初始化阻塞队列。
     *
     * @param capacity 队列的容量，即队列最多可以存储的元素数量。
     */
    public MyBlockingQueues(int capacity) {
        q = new String[capacity];
        size = 0;
    }

    /**
     * 将一个字符串元素添加到队列中。
     * 如果队列已满，则当前线程被阻塞，直到队列有空位。
     *
     * @param s 要添加到队列的字符串元素。
     * @throws InterruptedException 如果线程在等待时被中断。
     */
    public void put(String s) throws InterruptedException {
        synchronized(this) {
            // 当队列满时，等待直到有空位
            // 判断队列是否已满，如果已满则返回，否则继续添加元素
            //判断队列是否满了
            while (size == q.length) {
                this.wait();
            }
            q[ptail++] = s;
            // 当尾部索引达到数组长度时，重置为0
            // 如果尾部索引超过数组长度，则重置为0，实现循环队列
            if (ptail >= q.length) {
                ptail = 0;
            }
            size++;
            // 唤醒等待的消费者线程
            this.notifyAll();
        }
    }

    /**
     * 从队列中取出一个字符串元素。
     * 如果队列为空，则当前线程被阻塞，直到队列有元素。
     *
     * @return 从队列中取出的字符串元素。
     * @throws InterruptedException 如果线程在等待时被中断。
     */
    public String take() throws InterruptedException {
        String ret="";
        synchronized (this) {
            // 当队列空时，等待直到有元素
            // 判断队列是否为空，如果为空则返回空字符串，否则继续取出元素
            while (size == 0) {
                this.wait();
            }
            ret = q[head++];
            // 当头部索引达到数组长度时，重置为0
            // 如果头部索引超过数组长度，则重置为0，实现循环队列
            if (head >= q.length) {
                head = 0;
            }
            size--;
            // 唤醒等待的生产者线程
            this.notifyAll();
        }
        return ret;
    }
}
class Demos{
    /**
     * 程序的入口点。
     * 创建一个容量为100的MyBlockingQueues实例，用于生产者和消费者之间的通信。
     * 分别启动两个线程，一个负责生产物品，另一个负责消费物品。
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 创建一个容量为100的阻塞队列
        MyBlockingQueues BQ=new MyBlockingQueues(100);

        // 创建生产者线程，负责向队列中添加物品
        Thread t1=new Thread(()->{
            int i=0;
            while(true){
                try {
                    // 将物品添加到队列中，并打印生产信息
                    BQ.put(""+i);
                    System.out.println("生产者生产了"+i);
                    i++;
                } catch (InterruptedException e) {
                    // 打印异常信息
                    e.printStackTrace();
                }
            }
        });

        // 创建消费者线程，负责从队列中取出物品
        Thread t2=new Thread(()->{
            while(true){
                try {
                    // 模拟消费者等待一段时间
                    Thread.sleep(1000);
                    // 从队列中取出物品，并打印消费信息
                    System.out.println("消费者消费了"+BQ.take());
                } catch (InterruptedException e) {
                    // 打印异常信息
                    e.printStackTrace();
                }
            }
        });

        // 启动生产者和消费者线程
        t1.start();
        t2.start();
    }

}

阻塞队列就先到这里了~

若有不足，欢迎指正~ 

zhyhgx
关注
  • 23
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
JAVAEE 7，手册chm格式的
08-21
1. **Servlet 3.1**：增强了异步处理能力，允许在Servlet容器中进行非阻塞I/O操作，提高了高并发场景下的性能。此外，还引入了注解配置，简化了部署描述符。 2. **JSP 2.3**：提供了对EL（Expression Language）3.0...
JavaEE7.API
03-06
1. **Servlet 3.1**：引入了异步Servlet处理，使得服务器可以更好地处理高并发场景，同时允许在后台执行长时间运行的任务，而不阻塞客户端。此外，它还提供了更好的URL映射和注解支持。 2. **JSP 2.3**：增强了...
[JavaEE]阻塞队列
Node_Hao的博客
01-16 1317
阻塞队列是一种特殊的队列 , 也遵循"先进先出"的原则.阻塞队列是一种线程安全的数据结构.
【JAVAEE】阻塞队列的实现
m0_57248752的博客
05-11 439
生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取。而这里，生产者就是擀皮的人，消费者使包饺子的人，放饺子皮的地方是一个交易场所，用阻塞队列来是实现。在流量激增的时候用消息队列缓冲，在流量减少的时候，把消息队列中存储的消息一点一点的消费。在流量激增的时候用消息队列缓冲，在流量减少的时候，把消息队列中存储的信息一点一点消费。1.实现一个普通队列，底层用了两种数据结构，一个是链表，一个是循环数组。
[JAVAee]阻塞队列
weixin_67719939的博客
07-23 434
阻塞队列的介绍,与模拟实现
阻塞队列-消息队列
weixin_53714478的博客
04-18 410
队列是一种数据的组织形式，它可以用链表活数组的形式实现，队列的规则是先入队的元素会先出队（先进先出）阻塞队列在队列的基础上又加入了一些条件：当插入元素时，先进行判断，队列是否已满，如果满了那就阻塞，等队列有空余位置的时候再进行插入操作当取出元素时，先进行判断，队列是否为空，如果为空那就阻塞，等队列中有元素的时候再进行取出操作。
【javaEE】阻塞队列、定时器、线程池
m0_72161237的博客
03-27 945
被拒绝的任务的处理程序，丢弃最旧的未处理请求，然后重试 execute ，除非执行程序关闭，在这种情况下，任务被丢弃。：线程池里要管理的任务很多，这些任务也是通过阻塞队列来组织，程序员可以手动指定线程池一个队列，此时程序员就很方便的可以控制/获取队列中的信息，submit 方法就是把任务放到该队列中。当然，当前代码中，没有 interrupt ，但是一个更复杂的项目，就不能保证没有了，更稳妥的做法，是在 wait 唤醒之后，在判定一次条件。被拒绝的任务的处理程序静默地丢弃被拒绝的任务。
JavaEE在线学习系统.zip
03-06
6. **JMS（Java Message Service）**：在大型系统中，JMS可能用于实现异步处理，例如，当用户提交作业或参加在线考试时，系统可以将这些操作作为消息放入队列，然后由后台服务处理，避免阻塞前端用户。 7. **Spring...
javaEE 异步消息处理
07-21
JavaEE异步消息处理是一种高效的应用程序间通信方式，它允许服务器执行非阻塞操作，提高系统的可伸缩性和响应速度。在这个系统架构中，客户端和服务器之间通过消息传递进行交互，而消息的处理则在后台异步进行，不...
Java JavaEE开源应用服务器 wildfly新特性与未来规划 共30页.pdf
06-09
Wildfly不仅提供了标准的中间件服务，如JDBC（Java Database Connectivity）用于数据库访问，Hibernate作为ORM（对象关系映射）工具，提高了数据库操作的效率，还包含了RPC（远程过程调用）机制，消息队列，持久化层...
golang 接口
m0_70982551的博客
07-24 868
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 454
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 542
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 471
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 343
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 397
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 834
java、数据类型、循环、选择等
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 166
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 852
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhyhgx

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值