BolckingQueue

最新推荐文章于 2024-10-17 23:32:38 发布
最新推荐文章于 2024-10-17 23:32:38 发布
阅读量1k 收藏 18
点赞数 29
分类专栏： java并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41163858/article/details/142304155
版权
队列

队列的特点先进先出（FIFO）。
如图： 进入队列的顺序是1，2，3，那么出队列的顺序只能是1，2，3，不可能是其他顺序，这是由队列的特点保证的。
在这里插入图片描述
保存数据的基本数据结构有数组和链表，基于此，实现队列分为数组队列（ArrayQueue）和链表队列（LinkedQueue）。

BolckingQueue分类

从名称可知 Blocking Queue 阻塞队列，具体可分为数组阻塞队列和链表阻塞队列。
在这里插入图片描述
ArrayBlockingQueue源码：

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {

		//存储元素的数组
		final Object[] items;
		
		//锁  因此是多线程安全
		final ReentrantLock lock;
	
		//条件队列
		private final Condition notEmpty;
		private final Condition notFull;
	
		...
}

从ArrayBlockingQueue 源码中不难看出，使用Object数组存储元素，使用ReentrantLock 保证多线程操作安全，
阻塞功能通过“条件锁”Condition 实现。

LinkedBlockingQueue源码：

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
		
		//节点定义
		static class Node<E> {
	        E item;
			//只有尾指针 --> 单线链表
	        Node<E> next;
	        Node(E x) { item = x; }
	    }
	
		//指向头节点
		transient Node<E> head;
		
		//尾节点
		private transient Node<E> last;
	
		private final ReentrantLock takeLock = new ReentrantLock();
	
		private final Condition notEmpty = takeLock.newCondition();
		private final ReentrantLock putLock = new ReentrantLock();
		private final Condition notFull = putLock.newCondition();
	
		...
}

从LinkedBlockingQueue源码中不难看出，使用单项链表存储元素，使用ReentrantLock 保证多线程操作安全，
阻塞功能通过“条件锁”Condition 实现。

BolckingQueue 常用方法

首先初始化一个容量为5的队列：

BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(5);
1、add(E e);

函数说明：向队列中添加一个元素，当队列为空时抛NPE异常，队列满时，抛IllegalStateException异常。
返回true 表示添加元素成功，其他返回值均不成功；
该方法不会阻塞当前线程往下执行！

 for (int i = 0; i < 8; i++) {
   try {
         System.out.println(blockingQueue.add("aaa"));
     } catch (Exception e) {

     }
     System.out.println("继续执行....");
 }

结果：

true
继续执行…
true
继续执行…
true
继续执行…
true
继续执行…
true
继续执行…
继续执行… //这里此时队列元素已满，会抛出异常，由于对异常进行了处理，因此可以继续往下执行
继续执行…
继续执行…

add(E e)底层调用offer(E e)。

public boolean add(E e) {
   if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}
2、offer(E e)

向队列中添加元素， 若队列为空，抛NPE异常；
true:添加元素成功；
false: 添加元素失败
不会阻塞当前线程执行

for (int i = 0; i < 8; i++) {
   System.out.println(blockingQueue.offer("aaa"));
    System.out.println("插入操作  继续执行...");
}

结果：

true
插入操作 继续执行…
true
插入操作 继续执行…
true
插入操作 继续执行…
true
插入操作 继续执行…
true
插入操作 继续执行…
false ------------------------------------------队列满后，插入失败
插入操作 继续执行…
false
插入操作 继续执行…
false
插入操作 继续执行…

 public boolean offer(E e) {
 		//元素非空判断
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //获取互斥锁  因此是线程安全的
        lock.lock();
        try {
            //队列已满
            if (count == items.length)
                return false;
            else {
                //插入队列
                enqueue(e);
                return true;
            }
        } finally {
        	//释放锁
            lock.unlock();
        }
    }

	//插入队列
    private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        //元素插入成功后，唤醒条件队列中的线程！ ********
        notEmpty.signal();
    }
2、offer(E e, long timeout, TimeUnit unit)

在指定时间内成功插入元素返回true, 失败返回false;
与offer(E e)的不同点在于，offer(E e)只插入一次，成功或者失败立即返回；
offer(E e, long timeout, TimeUnit unit) 先判断队列是否已满，若已满，则等待一定时间后再尝试插入元素。
不会阻塞当前线程执行

for (int i = 0; i < 10; i++) {
     System.out.println(blockingQueue.offer("aaa",3, TimeUnit.SECONDS));
     System.out.println("继续执行...");
 }

结果：

true
继续执行…
true
继续执行…
true
继续执行…
true
继续执行…
true
继续执行…
false
继续执行…
false
继续执行…
false
继续执行…
false
继续执行…
false
继续执行…

public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {
        checkNotNull(e);
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            /**
             * 如果此时队列已满
             * 等待一段时间再操作
             */
            while (count == items.length) {
                if (nanos <= 0)
                    return false;
                //处理等待时间的操作
                nanos = notFull.awaitNanos(nanos);
            }
            
            //元素插入到队列中
            enqueue(e);
            return true;
        } finally {
            lock.unlock();
        }
    }
3、put(E e)

向队列中放入元素；
会阻塞当前线程执行


for (int i = 0; i < 10; i++) {
    blockingQueue.put("aaa");
    System.out.println("继续执行...");
}

结果：

继续执行…
继续执行…
继续执行…
继续执行…
继续执行…
程序在此卡住不再执行…

public void put(E e) throws InterruptedException {
  checkNotNull(e);
    final ReentrantLock lock = this.lock;

    lock.lockInterruptibly();
    try {
        /**
         * 如果此时队列已满，当前线程加入到条件队列中(进行阻塞)
         */
        while (count == items.length)
            notFull.await();
        //当前队列未满，元素进队
        enqueue(e);
    } finally {
        lock.unlock();
    }
}
4、take()

获取队首元素，若元素为空，
则阻塞等待

for (int i = 0; i < 10; i++) {
    System.out.println(blockingQueue.take());
    System.out.println("获取操作  继续执行...");
}

 public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
     lock.lockInterruptibly();
     try {
         //队列为空
         while (count == 0)
             //阻塞等待
             notEmpty.await();
         return dequeue();
     } finally {
         lock.unlock();
     }
 }
5、poll()

获取队首元素，如果此时队列为空，返回null;
不会阻塞当前线程执行!

for (int i = 0; i < 10; i++) {
    System.out.println(blockingQueue.poll());
    System.out.println("获取操作  继续执行...");
}

public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return (count == 0) ? null : dequeue();
    } finally {
        lock.unlock();
    }
}
6、poll(long timeout, TimeUnit unit)

同poll(); 只不过当队列为空时，等待一定时间再获取队首元素

 for (int i = 0; i < 10; i++) {
   System.out.println(blockingQueue.poll(3, TimeUnit.SECONDS));
     System.out.println("获取操作  继续执行...");
 }

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
  long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        //队列为空
        while (count == 0) {
            if (nanos <= 0)
                return null;
            nanos = notEmpty.awaitNanos(nanos);
        }
        //获取队首元素
        return dequeue();
    } finally {
        lock.unlock();
    }
}
7、drainTo(Collection<? super E> c);

获取队列中的全部元素，保存到指定的集合中，结果返回元素个数。
不会阻塞当前线程执行

  List<String> list = new ArrayList<>();
  int i = blockingQueue.drainTo(list);
  System.out.println(i);
  list.stream().forEach(str -> {
       System.out.println(str);
   });
8、drainTo(Collection<? super E> c, int maxElements);

从队列中获取指定数量的元素，保存在给定的集合中

 List<String> list = new ArrayList<>();
 int i = blockingQueue.drainTo(list, 3);
 System.out.println(i);
 list.stream().forEach(str -> {
     System.out.println(str);
 });

OK，对上述所有方法做个总结可如下图所示：
在这里插入图片描述
存/取 搭配使用。

使用BolckingQueue实现生产者消费者模式
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumerExample {
    private static final int QUEUE_CAPACITY = 5; // 队列容量
    private static final int TOTAL_ITEMS = 10; // 生产和消费的总数量

    public static void main(String[] args) {
        // 创建一个大小为 QUEUE_CAPACITY 的阻塞队列
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(QUEUE_CAPACITY);

        // 创建生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < TOTAL_ITEMS; i++) {
                    String item = "Item " + i;
                    queue.put(item); // 如果队列已满，生产者线程会被阻塞
                    System.out.println("Produced: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println("Producer interrupted");
            }
        });

        // 创建消费者线程
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < TOTAL_ITEMS; i++) {
                    String item = queue.take(); // 如果队列为空，消费者线程会被阻塞
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println("Consumer interrupted");
            }
        });

        // 启动生产者和消费者线程
        producer.start();
        consumer.start();

        // 等待线程结束
        try {
            producer.join();
            consumer.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("Main thread interrupted");
        }

        System.out.println("Production and consumption completed.");
    }
}

在这里插入图片描述

ArrayBlockingQueue是在哪一步唤醒等待条件的线程的 ？
唤醒生产者线程：

//获取队头元素
private E dequeue() {
    // assert lock.getHoldCount() == 1;
     // assert items[takeIndex] != null;
     final Object[] items = this.items;
     @SuppressWarnings("unchecked")
     E x = (E) items[takeIndex];
     items[takeIndex] = null;
     if (++takeIndex == items.length)
         takeIndex = 0;
     count--;
     if (itrs != null)
         itrs.elementDequeued();
     //唤醒生产者线程 ****************
     notFull.signal();
     return x;
 }

生产者放入元素后会唤醒消费者

    private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;

        //唤醒消费者
        notEmpty.signal();
    }
日拱一卒ZHD
关注
专栏目录
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 289
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
java 异常包装
fdvvg的博客
10-17 207
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 346
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 668
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 512
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
Springboot api http并发测试请求
nsa65223的专栏
10-11 343
【代码】Springboot api http并发测试请求。
spring task的使用场景
qq_40603125的博客
10-13 322
spring任务调度框架约定的时间。
【Java 22 | 8】 深入解析Java 22 ：Pattern Matching 特性详解
颜淡慕潇
10-17 1079
Java 22 进一步扩展了模式匹配（Pattern Matching）功能，简化了类型检查和条件表达式的使用。此特性不仅提升了代码的可读性，还减少了常见的错误。以下是对 Java 22 中模式匹配的详细介绍，包括基础概念、增强特性、使用场景、示例代码，以及如何在实际项目中有效利用模式匹配
代理模式、BigDecimal详解
Mr.W的博客
10-14 998
BigDecimal可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过BigDecimal来做的。浮点数之间的等值判断，基本数据类型不能用 == 来比较，包装数据类型不能用 equals 来判断。想要解决浮点数运算精度丢失这个问题，可以直接使用BigDecimal来定义浮点数的值，然后再进行浮点数的运算操作即可​​// 0。
Backend - Java 基础
是萝卜干呀的博客
10-11 842
知识量决定了未来能走多远
Hex编码
weixin_74305514的博客
10-13 274
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
pyserini安装&使用
DreamLike_zzg的博客
10-14 535
代码。
JavaWeb Servlet--09深入：注册系统04--修改页面
weixin_62189092的博客
10-16 333
这里就会获取要修改的用户的id，返回用户，再把这个用户重定向跳转到update.jsp页面。在再UserServlet里书写修改的代码。分析：点击修改超链接，就跳转到一个修改界面，要显示原本的数据，且密码显示出来，在该页面将对用户的数据的进行修改，最后提交。findUserByID()----显示原本的内容，update()---修改数据库内容的方法。注意：修改信息是要展示密码的文本内容，所以在password处type="text";写法和register没有太大的区别，主要是对文本框获得值。
初始Python篇（2）——逻辑控制、序列
我要学编程的博客
10-14 1142
程序的组织结构：顺序、选择、循环 pass空语句 猜数字小游戏 序列、序列相关操作
delphi中TBytesToTJavaArray的使用
最新发布
tanqth的专栏
10-17 242
在使用delphi开发过程中，多数情况下使用TJavaArray数据类型的时候，应该是可以直接用TBytesToTJavaArray进行数据类型的转换并使用，但涉及到与流处理相关的时候，需要在使用完成后去释放清理。
JavaScript前端开发技术
Chujun123528的博客
10-12 1021
JavaScript前端开发是一个充满挑战和机遇的领域。随着技术的不断进步和用户需求的变化，前端开发者需要不断学习新知识、掌握新技能，以应对日益复杂和多样化的开发需求。同时，注重性能优化和安全实践也是前端开发不可或缺的一部分。通过不断探索和创新，我们可以为用户创造更加优质、高效和安全的Web体验。在JavaScript前端开发的学习过程中，建议从基础语法入手，逐步掌握DOM操作、事件处理、Ajax通信等核心技能。同时，关注最新的前端框架和库的发展动态，尝试将它们应用到实际项目中。
若依框架中spring security的完整认证流程，及其如何使用自定义用户表进行登录认证，学会轻松实现二开，嘎嘎赚块乾
Zwwxd666的博客
10-17 479
由于后续需要将自定义实体设置给LoginUser，需要定义对应的构造函数，方便后面验证成功后设置值，然后全文调用因为我们是用自己的业务类判断的嘛，因此我们要找到调用loadUserByUsername那家伙，也就是AuthenticationManager（ProviderManager），给他设置provider的时候，set我们自己的UserDetailServiceImpl。
JAVA八股
m0_55764111的博客
10-17 751
volatile关键字是Java中的一个修饰符，用于保证多线程环境下共享变量的可见性。当一个变量被声明为volatile时，它告诉Java编译器和运行时环境，任何对该变量的读写操作都要直接从主内存中进行，而不是从线程的本地缓存中读取。写入：如果不使用volatile关键字，线程会将修改的值保存到缓存中，如果使用了volatile关键字，线程会将修改的值刷新到主内存中。保证多线程环境下共享变量的可见性。读取：如果不使用volatile关键字，线程会从缓存中读取该变量，因为一般线程会将修改的值保存到缓存中。
springcloud微服务基本概念
牧风人的博客
10-11 896
微服务架构的4个核心问题 ​ 1.服务很多，客户端怎么访问 ​ 2.这么多的服务，服务之间怎么通信 ​ 3.这么多的服务，怎么统一治理 ​ 4.服务挂了怎么办 解决方案： SpringCloud 生态 1.Spring Cloud NetFlix 一站式解决方案！ 但停更了 api网关，zuul组件 Feign---...
Java实现实体类转树形结构
yd的博客
10-17 81
实现通用方法，将实体类转树形结构（简化）以及部分树相关函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值