java之阻塞队列BlockingQueue解析

更新时间：2023年10月24日 10:18:11 作者：强强爱java

这篇文章主要介绍了java之阻塞队列BlockingQueue解析,阻塞队列是一种线程安全的数据结构,用于在多线程环境下进行数据交换,它提供了一种阻塞的机制,当队列为空时,消费者线程将被阻塞,直到队列中有数据可供消费,需要的朋友可以参考下

一、阻塞队列概念

阻塞队列，顾名思义，首先它是一个队列（先进先出），而一个阻塞队列在数据结构所起到的作用大致如下图：

在这里插入图片描述

线程1往阻塞队列中添加元素，而线程2从阻塞队列中移除元素
当阻塞队列是空是，从队列中获取元素的操作会被阻塞
当阻塞队列是满时，从队列中添加元素的操作会被阻塞
试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。
试图网已满的阻塞队列中添加新元素的线程同样会被阻塞，直到其他的线程从列中移除一个或者多个元素或者完全清空队列后使队列重新变得空闲起来并后续新增

二、阻塞队列的好处

1.在多线程领域：所谓阻塞，在某些情况下会挂起线程，一旦满足条件，被挂起的线程又会自动被唤醒。

2.我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue（阻塞队列）都给你一手包办了

PS：在concurrent包发布以前，在多线程环境下，我们每个程序员都必须自己控制这些细节，尤其还要兼顾效率和线程安全，而这回给我们程序带来不小的复杂度

三、阻塞队列种类

ArrayBlockingQueue：由数据结构组成的有界阻塞队列
LinkedBlockingQueue：由链表结构组成的有界（但大小默认值为 Integer.MAX_VALUE )阻塞队列
PriorityBlockingQueue：支持优先级排序的无界阻塞队列
DelayQueue：使用优先级队列实现的延迟无界阻塞队列
SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列
LinkedTransferQueue：由链表结构组成的无界阻塞队列
LinkedBlockingDeque：由历览表结构组成的双向阻塞队列

PS：重点掌握ArrayBlockingQueue、LinkedBlockingQueue、SychronousQueue三种

四、BlockingQueue的核心方法

方法类型	抛出异常	特殊值	一直阻塞	超时退出
插入	add(e)	offer(e)	put(e)	offer(e,time,unit)
移除	remove()	poll()	take	poll(time,unit)
检查	element()	peek()	不可用	不可用

说明：

方法类型	情况
抛出异常	当阻塞队列满时，再往队列中add会抛 IllegalStateException: Queue full；当阻塞队列空时，再从队列里remove会抛 NoSuchElementException
特殊值	offer(e)插入方法，成功true失败false poll() 移除方法，成功返回出队列的元素，队列里没有就返回null
一直阻塞	当阻塞队列满时，生产者线程继续往队列里put元素，队列会一直阻塞线程直到take数据或响应中断退出当阻塞队列空时，消费者线程试图从队列take元素，队列会一直阻塞消费者线程直到队列可用
超时退出	当阻塞队列满时，队列会阻塞生产者线程一定时间，超过限时后生产者线程会退出

五、示例代码

1.使用SychronousQueue队列

package com.jian8.juc.queue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/*
 * 阻塞队列SynchronousQueue演示
 * */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();

        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "\t put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "\t put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "\t put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "\t take" + blockingQueue.take());

                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "\t take" + blockingQueue.take());

                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "\t take" + blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "BBB").start();
    }
}

运行结果：

在这里插入图片描述

2.传统版生产者消费者模式

package com.jian8.juc.queue;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 一个初始值为零的变量，两个线程对其交替操作，一个加1一个减1，来5轮
 * 1. 线程  操作  资源类
 * 2. 判断  干活  通知
 * 3. 防止虚假唤起机制
 */
public class ProdConsumer_TraditionDemo {
    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "ProductorA " + i).start();
        }

        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "ConsumerA  " + i).start();
        }

        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "ProductorB " + i).start();
        }

        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "ConsumerB  " + i).start();
        }

    }
}

//资源类
class ShareData {
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //生产
    public void increment() throws Exception {
        lock.lock();
        try {
            //1.判断
            while (number != 0) {
                //等待中，不能生产
                condition.await();
            }
            //2.干活
            number++;
            System.out.println(Thread.currentThread().getName() + "\t" + number);
            //3.通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //消费
    public void decrement() throws Exception {
        lock.lock();
        try {
            //1.判断
            while (number == 0) {
                //等待中，不能消费
                condition.await();
            }
            //2.消费
            number--;
            System.out.println(Thread.currentThread().getName() + "\t" + number);
            //3.通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

运行结果（部分）：

在这里插入图片描述

3.阻塞队列版（以ArrayBlockingQueue为例）生产者消费者模式

package com.jian8.juc.queue;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ProdConsumer_BlockQueueDemo {
    public static void main(String[] args) {
        MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t生产线程启动");
            try {
                myResource.myProd();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Prod").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t消费线程启动");
            try {
                myResource.myConsumer();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Consumer").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("5s后main叫停，线程结束");

        try {
            myResource.stop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//资源类
class MyResource {
    private volatile boolean flag = true;//默认开启，进行“生产+消费”活动
    private AtomicInteger atomicInteger = new AtomicInteger();
    BlockingQueue<String> blockingQueue = null;//消息队列

    public MyResource(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
        System.out.println(blockingQueue.getClass().getName());
    }

    //生产
    public void myProd() throws Exception {
        String data = null;
        boolean retValue;
        while (flag) {
            data = atomicInteger.incrementAndGet() + "";
            //超过2s没生产成功，退出生产
            retValue = blockingQueue.offer(data, 2, TimeUnit.SECONDS);
            if (retValue) {
                System.out.println(Thread.currentThread().getName() + "\t插入队列" + data + "成功");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t插入队列" + data + "失败");
            }
            TimeUnit.SECONDS.sleep(1);
        }
        System.out.println(Thread.currentThread().getName() + "\t大老板叫停了，flag=false，生产结束");
    }

    //消费
    public void myConsumer() throws Exception {
        String result = null;
        while (flag) {
            //超过2s没从队列获取数据，消费退出
            result = blockingQueue.poll(2, TimeUnit.SECONDS);
            if (null == result || result.equalsIgnoreCase("")) {
                flag = false;
                System.out.println(Thread.currentThread().getName() + "\t超过2s没有取到蛋糕，消费退出");
                System.out.println();
                return;
            }
            System.out.println(Thread.currentThread().getName() + "\t消费队列" + result + "成功");
        }
    }

    public void stop() throws Exception {
        flag = false;
    }
}

运行结果：

在这里插入图片描述

到此这篇关于java之阻塞队列BlockingQueue解析的文章就介绍到这了,更多相关java阻塞队列BlockingQueue内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

gateway基本配置教程
路由(Route)由一个ID，一个目标URI(最终路由到的url地址)，一组断言(匹配条件判断)和一组过滤器定义，这篇文章主要介绍了gateway基本配置,需要的朋友可以参考下
2023-05-05
java实现二维码扫码授权登陆
这篇文章主要为大家详细介绍了java实现二维码扫码授权登陆，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2018-10-10
Java中接口和抽象类的区别与相同之处
这篇文章主要介绍了Java中接口和抽象类的区别与相同之处,本文讲解了抽象类的概念、接口的概念、接口和抽象类的区别与联系等内容,需要的朋友可以参考下
2015-06-06
nacos配置注册中心时指定命名空间不起作用的问题
这篇文章主要介绍了nacos配置注册中心时指定命名空间不起作用的问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教。
2022-01-01
springboot如何通过controller层实现页面切换
在Spring Boot中,通过Controller层实现页面切换背景,Spring Boot的默认注解是@RestController,它包含了@Controller和@ResponseBody,@ResponseBody会将返回值转换为字符串返回,因此无法实现页面切换,将@RestController换成@Controller
2024-12-12
java中HashMap的原理分析
HashMap在Java开发中有着非常重要的角色地位，每一个Java程序员都应该了解HashMap。详细地阐述HashMap中的几个概念，并深入探讨HashMap的内部结构和实现细节，讨论HashMap的性能问题
2016-03-03
SpringBoot快速入门及起步依赖解析(实例详解)
SpringBoot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化 Spring 应用的初始搭建以及开发过程，这篇文章主要介绍了SpringBoot快速入门及起步依赖解析,需要的朋友可以参考下
2022-10-10
基于多线程并发的常见问题(详解)
下面小编就为大家带来一篇基于多线程并发的常见问题(详解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-10-10
使用try-with-resource的输入输出流自动关闭
这篇文章主要介绍了使用try-with-resource的输入输出流自动关闭方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-07-07
Java后端实现短链接生成功能
短链接生成主要在于把指定的接口和参数实现加密生成比较短的字符串,再进行拼接通过指定的域名或者ip实现链接的跳转,下面我们来看看如何使用Java实现这一功能吧
2025-03-03