ArrayBlockingQueue源码分析

最新推荐文章于 2023-06-10 17:41:49 发布
原创 最新推荐文章于 2023-06-10 17:41:49 发布 · 299 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ArrayBlockingQueue #lock #Condition

本文深入解析了ABQ（ArrayBlockingQueue）的工作原理，包括其构造方法、核心操作如add、offer、put和take，以及内部实现细节。通过对比改造前后的代码逻辑，展示了ABQ在提高程序性能和降低耦合度方面的优势。

前言

  如果说CHM的源码对并发分片和CAS操作运用的淋漓尽致，那么ABQ则是Lock & Condition类的使用参考书~

阻塞队列的应用

  见名知义，ABQ是基于数组实现的阻塞队列。
  大家常用的MQ、Kafka使得程序之间实现解耦。同理，阻塞队列使得线程之间进行数据通信与解耦。
  举一个熟悉场景——用户注册成功后，增加积分。通常，我们可以通过MQ来实现注册、积分操作的异步与解耦。但假如我们的程序规模比较小，采用阻塞队列会更加方便。

  • 改造前的代码逻辑
	public class UserService {
		public boolean register(){
			User user=new User();
			user.setName("Jeremy");
			addUser(user);//注册用户
			sendPoints(user);//增加积分
		return true;
	}

	public static void main(String[] args) {
		new UserService().register();
	}
	
	private void addUser(User user){
		System.out.println("添加用户： "+user);
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	private void sendPoints(User user){
		System.out.println("发送积分给指定用户:"+user);
		try {
			Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
  • 改造后的逻辑
	public class UserService {
		private final ExecutorService single = Executors.newSingleThreadExecutor();
		private volatile boolean isRunning = true;
		ArrayBlockingQueue arrayBlockingQueue=new
		ArrayBlockingQueue(10);
		
		{
			init();
		}
		
		public void init(){
			single.execute(()->{
				while(isRunning){
					try {
						//阻塞的方式获取队列中的数据
						User user=(User)arrayBlockingQueue.take();
						sendPoints(user);
					} catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
			});
		}
		
		public boolean register(){
			User user=new User();
			user.setName("Mic");
			addUser(user);
			arrayBlockingQueue.add(user);//添加到异步
			队列
			return true;
		}
		
		public static void main(String[] args) {
			new UserService().register();
		}

		private void addUser(User user){
			System.out.println("添加用户： "+user);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
			e.printStackTrace();
			}
		}
		
		private void sendPoints(User user){
			System.out.println(" 发送积分给指定用户:"+user);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
  • 优化后流程图
    在这里插入图片描述

  修改之后的代码在性能 & 耦合度方面都有提高。
  阻塞队列主要应用于生产者、消费者场景中。

JUC中的阻塞队列

阻塞队列原理
ArrayBlockingQueue数组实现的有界阻塞队列，FIFO
LinkedBlockingQueue链表实现的有界阻塞队列，FIFO
PriorityBlockingQueue支持优先级排序的无界阻塞队列，可通过实体类实现compareTo()或构造参数Comparator实现排序
DelayQueue优先级排序的无界阻塞队列
SynchronousQueue不存储元素的阻塞队列
LinkedTransferQueue链表实现的无界阻塞队列
LinkedBlockingDeque链表实现的双向阻塞队列

阻塞队列的操作方法

  阻塞队列中，插入和删除操作都提供了四种处理方式。

  • 插入操作
    • add(e) → 队列满了，继续插入会报错，IllegalStateException
    • offer(e) → 返回元素是否成功插入，成功返回true
    • put(e) → 队列满了，生产者继续put，会阻塞生产者线程，直到队列可用
    • offer(e,time,unit) → 队列满了继续添加元素，则生产者线程被阻塞指定时间，超时后，线程退出
  • 移除操作
    • remove() → 队列为空，返回false；移除成功，返回true
    • poll() → 队列为空，返回null
    • take() → 队列为空，阻塞take()，直到队列中有数据消费
    • poll(time,unit) → 队列为空，等待指定时间，在获取数据

ABQ源码分析

构造方法

  ABQ提供三个构造方法：

  1. capacity → 队列长度
	public ArrayBlockingQueue(int capacity) {
        this(capacity, false);//默认非公平锁
    }
  1. fair → 是否为公平的阻塞队列
	public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);//重入锁，出队&入队持有同一把锁
        notEmpty = lock.newCondition();//初始化非空等待队列
        notFull =  lock.newCondition();//初始化非满等待队列
    }
  1. 接受初始数据

Add方法

add() → 父类AbstractQueue的add()

	public boolean add(E e) {
        return super.add(e);//调用父类的模板方法 → 解决通用性问题
    }

AbstractQueue的add()

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

offer方法

  1. 判断添加数据是否为空
  2. 添加重入锁
  3. 判断队列长度，如果队列长度=数组长度，表示满了，直接返回false
  4. 否则，调用enqueue()将元素添加到队列
	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();
        }
    }
enqueue方法

  核心逻辑，通过putIndex索引直接将元素添加到数组队列中。

	private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;//通过putIndex对数据赋值
        //当putIndex等于数组长度时，将putIndex重置为0
        if (++putIndex == items.length)
            putIndex = 0;
        count++;//记录队列元素的个数
        //唤醒notEmpty队列中的线程
        //表明当前队列中元素不为空，如果存在消费者线程阻塞，就可以开始取元素了
        notEmpty.signal();
        
    }

  这里需要注意的是，putIndex超过数组长度时，重新从数组头节点插入数据，但并不会出现数据覆盖的情况。这是因为：

  • 元素个数由count统计。满了后，无法继续添加，会报错。
  • 队列中的元素会有消费者通过take()等方法获取，获取后会从队列中移除。

put方法

  队列满了，会阻塞。

	public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //等待时，可中断的锁
        lock.lockInterruptibly();
        try {
            while (count == items.length)
            	//队列满了的情况下，当前线程会被挂起，加入到notFull等待队列
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

take方法

  有就删除，没有就阻塞。

	public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();//队列为空，加入notEmpty等待队列
            return dequeue();
        } finally {
            lock.unlock();
        }
    }
dequeue方法

  出队列，删除队列头部元素并返回给客户端索引值。

	private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];//默认获取0位置元素
        items[takeIndex] = null;//将该位置元素设置为空
        if (++takeIndex == items.length)//拿到数组最大值，索引重置为0
            takeIndex = 0;
        count--;//元素个数递减
        if (itrs != null)
            itrs.elementDequeued();//更新迭代器中元素
        notFull.signal();//触发 因队列满了导致阻塞的notFull等待队列
        return x;
    }
itrs.elementDequeued()

remove方法

  移除一个指定元素。

	public boolean remove(Object o) {
        if (o == null) return false;
        final Object[] items = this.items;//获取数组元素
        final ReentrantLock lock = this.lock;
        lock.lock();//获得锁
        try {
            if (count > 0) {//如果队列不为空
            	//获取下一个添加元素时索引
                final int putIndex = this.putIndex;
                //获取当前要移除元素索引
                int i = takeIndex;
                do {
                	//从takeIndex下标开始，找到要被删除的元素
                    if (o.equals(items[i])) {
                        removeAt(i);//移除指定元素
                        return true;//返回执行结果
                    }
                    //当前删除索引+1后，判断是否与数组长度相等
                    //若为true，说明索引已到数组尽头，重置为0
                    if (++i == items.length)
                        i = 0;
                } while (i != putIndex);//继续查找，直到最后一个元素
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

总结

  ABQ的设计也是精妙的。

  • 通过成员变量count获取队列中元素个数
  • 通过两个阻塞队列notEmpty、notFull控制添加和获取元素时的阻塞
  • 两个阻塞队列与ABQ之间通过Condition的await()&signal()完成通信
Java集合（20）——并发集合（8）——阻塞队列（1）——ArrayBlockingQueue源码分析
波波鱼的博客
10-02 560
目录 1.概述 2.使用案例 3.源码分析 3.1 重要属性 3.2 构造方法 3.3 私有方法入队与出队 （1）入队 （2）出队 3.4 put和take方法 （1）put （2）take 3.5 offer和poll （1）offer （2）poll 3.6 peek 3.7 remainingCapacity 3.8 remove 4.总结 1.概述 ...
从源码解析-Android数据结构ArrayBlockingQueue
Mango先生的博客
06-23 1217
上一篇文章Android之阻塞队列LinkedBlockingQueue使用及源码解析讲到了LinkedBlockingQueue，与之相关的一个队列就是今天要讲到的ArrayBlockingQueue。 ArrayBlockingQueue也是一个阻塞队列，内部使用一个定长数组保存数据，在构造这个队列的时候必须要指定长度，如果队列已满再执行入队将会阻塞；如果队列为空再执行出队将会阻塞。 看看...
并发编程7-ArrayBlockingQueue底层实现和原理
应学欣的博客
05-02 2032
ArrayBlockingQueue的原理和底层实现的数据结构 ： ArrayBlockingQueue是数组实现的线程安全的有界的阻塞队列，可以按照 FIFO（先进先出）原则对元素进行排序。 线程安全是指，ArrayBlockingQueue内部通过“互斥锁”保护竞争资源，实现了多线程对竞争资源的互斥访问。而有界，则是指ArrayBlockingQueue对应的数组是有界限的。 阻塞队列，是指多...
ArrayBlockingQueue源码讲解
数据结构和算法
09-18 821
尊重原创，转载请标明出处   http://blog.youkuaiyun.com/abcdef314159 源码：\sources\android-25 ArrayBlockingQueue是一个数组阻塞队列，这个队列的元素是先进先出，head元素是最先加入的，tail是最后加入的，并且新的元素加入到tail，获取元素从head开始。他有两个int指针，putIndex指向队尾的下一个，是空，表示下一个
java并发编程：ArrayBlockingQueue详解
初念初恋的博客
06-10 2504
ArrayBlockingQueue 顾名思义是基于数组的阻塞队列。数组是要指定长度的，所以使用 ArrayBlockingQueue 时必须指定长度，也就是它是一个有界队列。它实现了 BlockingQueue 接口，有着队列、集合以及阻塞队列的所有方法。ArrayBlockingQueue 是线程安全的，内部使用 ReentrantLock 来保证。ArrayBlockingQueue 支持对生产者线程和消费者线程进行公平的调度。
java多线程 阻塞队列的使用的 arrayBlockQueue
Hi, Sun
02-22 318
我们在平时的时候使用的是队列，指定好个数以后，如果放的数据超过了队列设定的个数的时候会报错误的。 那么多线程中，有一个阻塞队列的叫arrayBlockQueue。这个类是对queue在多线程中使用的扩展， 也就是说，当作为临界资源的时候，这个队列是安全，存放数据如果超过了队列设定好的初始的数据的时候， 放入数据的线程将会被等待着的。 下面来看例子。   场景模拟： 现在有两个线程，一...
ArrayBlockingQueue源码分析.docx
06-16
下面我们将深入分析其主要的实现机制、方法以及源码。 1. **数据结构与容量** `ArrayBlockingQueue` 内部使用一个数组 `items` 来存储元素，因此它的容量在创建时就需要指定，且不可改变。这个容量限制确保了队列...
【集合】ArrayBlockingQueue 源码分析
yhl_jxy的博客
12-21 620
前言 Github：https://github.com/yihonglei/jdk-source-code-reading（java-concurrent） 一概述 ArrayBlockingQueue基于数组实现的有界顺序队列。 二 ArrayBlockingQueue 实例 三 ArrayBlockingQueue 底层实现 主要分析 put()/offer() 入队操作，take()/poll() 出队操作。 重要属性 public class ArrayBlocking...
ArrayBlockingQueue源码详解
Apollo的博客
02-20 750
阻塞队列 插入方法： add(E e) : 添加成功返回true，失败抛IllegalStateException异常 offer(E e) : 成功返回 true，如果此队列已满，则返回 false。 put(E e) :将元素插入此队列的尾部，如果该队列已满，则一直阻塞 删除方法: remove(Object o) :移除指定元素,成功返回true，失败返回false poll() : 获取并移除此队列的头元素，若队列为空，则返回 null take()：获取并移除此队列头元素，若没有元素则一
JAVA并发编程使用ArrayBlockingQueue实现生产者消费者模型
cijiong5172的博客
02-05 307
在学习多线程时，有一个模型大家应该非常熟悉，就是生产者和消费者模型，可以对可享变量进行保护，从而实现多线程的同步与互斥。今天用并发集合框架来实现这个模型。在介绍之前，先来看一个并发框架类ArrayBlockin...
ArrayBlockingQueue详解
热门推荐
qq_23359777的博客
04-12 2万+
1.介绍 ArrayBlockingQueue是一个阻塞式的队列，继承自AbstractBlockingQueue,间接的实现了Queue接口和Collection接口。底层以数组的形式保存数据(实际上可看作一个循环数组)。常用的操作包括 add ,offer,put，remove,poll,take,peek。 前三者add offer put 是插入的操作。后面四个方法是取出的操作。他们之
ArrayBlockingQueue源码分析总结
技术成就人生
04-26 1692
1，在说ArrayBlockingQueue之前，我们先说一下ReentrantLock：   ReentrantLock和Synchronized的作用差不多， java在编写多线程程序时，都是为了保证线程安全，需要对数据同步       1）相似点：            这两种同步方式有很多相似之处，它们都是加锁方式同步，而且都是阻塞式的同步，也就是说当如果一个线程获得了对象锁，进入了同步块...
ArrayBlockingQueue和ExecutorService的理解与感悟
秋香的博客
06-02 1706
package test;import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.u
Executors.newFixedThreadPool和ArrayBlockingQueue一点使用心得
chivalry
06-17 2万+
http://heipark.iteye.com/blog/1393847
ArrayBlockingQueue 深入分析
街角下的蚂蚁
08-15 450
导语 ArrayBlockingQueue 是一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。新元素插入到队列的尾部，队列检索操作则是从队列头部开始获得元素。 分析要点 是否线程安全？ 数据结构是怎样的？ 怎么实现阻塞和非阻塞插入和获取元素？ 怎么实现插入和获取元素平衡的？ 应用与哪些场景？ 深入剖析 成员变量 // 元素存放的对象，可以看出其数据结构仍然为数组 final Object[] items; // 获取下一个元素的数组下标 int takeIndex.
线程池ExecutorService结合ArrayBlockingQueue的使用
02-23 345
public boolean updateCaseInfo() { List<String> htids=csMapper.getHtId();//取出合同号空的数据 if (htids==null || htids.isEmpty()){ loger.info("当...
并发容器之ArrayBlockingQueue和LinkedBlockingQueue实现原理详解
weixin_33671935的博客
05-06 819
1. ArrayBlockingQueue简介 在多线程编程过程中，为了业务解耦和架构设计，经常会使用并发容器用于存储多线程间的共享数据，这样不仅可以保证线程安全，还可以简化各个线程操作。例如在“生产者-消费者”问题中，会使用阻塞队列（BlockingQueue）作为数据容器，关于BlockingQueue可以看这篇文章。为了加深对阻塞队列的理解，唯一的方式是对其实验原理进行理解，这篇文章就主要来...
Thread学习(九) 并发的Queen学习ArrayBlockingQueue,LinkedBlockingQueue
我是个少年的博客
11-29 1984
并发的Queue 在并发队列上，JDK实现了两套实现，一套是以ConcurrentLinkedQueue为代表的高性能非阻塞队列，另一套是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。 在Java多线程应用中，队列的使用率很高，多数生产消费模型的首选数据结构就是队列(先进先出)。Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列，其中阻塞队列的典
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值