Java并发之ArrayBlockingQueue

最新推荐文章于 2024-03-06 16:13:41 发布
最新推荐文章于 2024-03-06 16:13:41 发布
阅读量316 收藏
点赞数
分类专栏： 我所了解的Java 文章标签： java
本文深入解析ArrayBlockingQueue的实现原理，包括其构造方法、添加、获取及移除元素的方法等，帮助读者理解如何使用这一有界阻塞队列。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

        ArrayBlockingQueue是一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部是在队列中存在时间最长的元素。队列的尾部是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。 

        ArrayBlockingQueue继承自 AbstractQueue并实现 BlockingQueue接口。

 

        ArrayBlockingQueue是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞，试图从空队列中提取元素将导致类似阻塞。 

        ArrayBlockingQueue支持对等待的生产者线程和使用者线程进行排序的可选公平策略。默认情况下，不保证是这种排序。然而，通过将公平性 (fairness) 设置为 true 而构造的队列允许按照 FIFO 顺序访问线程。公平性通常会降低吞吐量，但也减少了可变性和避免了“不平衡性”。 公平性通过创建 ArrayBlockingQueue实例时指定。

 

        1.成员变量

/** 队列数组实现 */
private final E[] items;
/** 已取出元素索引，用于下一个元素的 take, poll or remove */
private int takeIndex;
/** 已插入元素索引，用于下一个元素的 put, offer, or add */
private int putIndex;
/** 队列中项目数 */
private int count;
/** 保护所有访问的主锁 */
private final ReentrantLock lock;
/** Condition 实例，用于等待中 take */
private final Condition notEmpty;
/** Condition 实例，用于等待中 put*/
private final Condition notFull;

        之前我们已经学习了锁相关的知识，所以几个成员变量不难理解。

        1）其中E[] items;是数组式的队列实现；

        2）takeIndex 用于记录 take操作的次数；

        3）putIndex 用于记录 put操作的次数；

        4）count 用于记录队列中元素数目；

        5）ReentrantLock lock 是用于控制访问的主锁；

        6）Condition notEmpty 获取操作时的条；

        7）Condition notFull 插入操作时的条件；

 

        2.构造方法

        ArrayBlockingQueue的构造方法有3个。

        1）最简单的构造方法：

//指定队列大小
public ArrayBlockingQueue(int capacity) {
	this(capacity, false);
}

        此种构造方法最为简单也最为常用，在创建 ArrayBlockingQueue实例时只需指定其大小即可。

BlockingQueue<Object> q = new ArrayBlockingQueue<Object>(10);

        2）增加访问策略的构造方法，除了指定队列大小外还可指定队列的访问策略：

//指定队列大小、访问策略
public ArrayBlockingQueue(int capacity, boolean fair) {
	if (capacity <= 0)
		throw new IllegalArgumentException();
	this.items = (E[]) new Object[capacity];
	lock = new ReentrantLock(fair);
	notEmpty = lock.newCondition();
	notFull = lock.newCondition();
}

        fair如果为 true，则按照 FIFO 顺序访问插入或移除时受阻塞线程的队列；如果为 false，则访问顺序是不确定的。

        构造方法中首先初始化了 items数组，然后根据fair创建 ReentrantLock实例，最后返回 notEmpty与 notFull两个 Condition实例，分别用于等待中的获取与添加操作。

        3）带初始元素的构造方法：

//指定队列大小、访问策略、初始元素
public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c) {
	this(capacity, fair);
	if (capacity < c.size())
		throw new IllegalArgumentException();

	for (Iterator<? extends E> it = c.iterator(); it.hasNext();)
		add(it.next());
}

        除了可以指定容量和访问策略外，还可以包含给定 collection 的元素，并以 collection 迭代器的遍历顺序添加元素。

        代码也可以观察到，在实例化队列之后还使用了add方法将 collection 中的元素按原有顺序添加到实例中。

 

        3.添加元素

        1）add方法

        ArrayBlockingQueue的add方法调用的是父类方法，而父类 add方法则调用的是 offer方法，以下是add方法的源代码：

public boolean add(E e) {
	//调用父类add方法
	return super.add(e);
}

        2）offer方法

        offer方法将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则返回 false。此方法通常要优于 add(E) 方法，后者可能无法插入元素，而只是抛出一个异常。 

/**
 * 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），
 * 在成功时返回 true，如果此队列已满，则返回 false。
 * 此方法通常要优于 add(E) 方法，后者可能无法插入元素，而只是抛出一个异常。
 */
public boolean offer(E e) {
	//判断e是否为null
	if (e == null)
		throw new NullPointerException();
	final ReentrantLock lock = this.lock;
	//获取锁
	lock.lock();
	try {
		//判断队列是否已满
		if (count == items.length)
			return false;
		else {
			//如果未满则插入
			insert(e);
			return true;
		}
	} finally {
		//释放锁
		lock.unlock();
	}
}

        因为 add方法在队列已满时会抛出异常，所以 offer方法一般优于 add方法使用。

        首先，判断要添加的元素是否为 null，如果为null则抛出空指针异常。

        接着，创建一个 ReentrantLock实例，ReentrantLock是可重入锁实现。更详细介绍参考http://286.iteye.com/blog/2296191

        然后，获取锁。

        最后，判断队列是否已满，如果已满则返回 false；如果未满则调用insert方法插入元素，返回true。

        所有操作完成后释放锁。

        offer方法的处理流程可以参照以下流程图：



        从代码中就可以看到，offer方法利用了ReentrantLock来实现队列阻塞的功能，所以多线程操作相同队列时会排队等待。

        offer的另一个重载方法是 offer(E e, long timeout, TimeUnit unit)，此重载方法将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。其源代码为：

/**
 * 将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。
 */
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {

	if (e == null)
		throw new NullPointerException();
	long nanos = unit.toNanos(timeout);
	final ReentrantLock lock = this.lock;
	lock.lockInterruptibly();
	try {
		for (;;) {
			if (count != items.length) {
				insert(e);
				return true;
			}
			if (nanos <= 0)
				return false;
			try {
				nanos = notFull.awaitNanos(nanos);
			} catch (InterruptedException ie) {
				notFull.signal(); // propagate to non-interrupted thread
				throw ie;
			}
		}
	} finally {
		lock.unlock();
	}
}

        与普通offer方法不同之处在于：offer(E e, long timeout, TimeUnit unit)方法利用循环在指定时间内不断去尝试添加元素，如果成功则返回true，如果指定时间已到则退出返回 false。

        3）insert方法

        insert方法在当前位置（putIndex）插入元素。

/**
 * 在当前位置（putIndex）插入元素（在获得锁的情况下调用）
 */
private void insert(E x) {
	//设置 putIndex位置 items数组元素为x
	items[putIndex] = x;
	//返回putIndex新值，如果已满则返回0，未满则+1
	putIndex = inc(putIndex);
	//增加元素数量
	++count;
	//唤醒获取线程
	notEmpty.signal();
}

        因为 ArrayBlockingQueue内部队列实现为数组items，而 putIndex则记录了队列中已添加元素的位置，所以新添加的元素就直接被添加到数组的指定位置。随后修改 putIndex值，如果队列未满则+1，如果已满则从0重新开始。最后唤醒 notEmpty中的一个线程。

 

        4）put方法

        将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间。

        以下是put方法的源代码：

/**
 * 将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间
 */
public void put(E e) throws InterruptedException {
	//判断e是否为null
	if (e == null)
		throw new NullPointerException();
	final E[] items = this.items;
	final ReentrantLock lock = this.lock;
	//获取中断锁
	lock.lockInterruptibly();
	try {
		try {
			//利用循环判断队列是否已满
			while (count == items.length)
				//如果已满则调用await方法阻塞等待
				notFull.await();
		} catch (InterruptedException ie) {
			notFull.signal(); // propagate to non-interrupted thread
			throw ie;
		}
		//队列未满则插入
		insert(e);
	} finally {
		//释放锁
		lock.unlock();
	}
}

        put方法与其他方法类似，其中会循环判断队列是否已满，如果已满则阻塞 notFull，如果未满则调用 insert方法添加元素。因为其中运用了循环判断队列是否有位置添加新元素，如果队列已满则产生阻塞等待，直至可以添加元素为止。

        将本文开始时的例子修改一下，去掉消费者，只留下生产者，这样当队列满了之后没有消费者去消费产品，生产者就不会再向队列中插入了：

class Producer implements Runnable {
	private final ArrayBlockingQueue<Integer> queue;
	private int i;

	Producer(ArrayBlockingQueue<Integer> q) {
		queue = q;
	}

	public void run() {
		try {
			while (true) {
				int p=produce();
				queue.put(p);// 将产品放入缓冲队列
				System.out.println("插入成功:"+p);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	int produce() {
		return i++;// 生产产品
	}
}

public class Runner {
	public static void main(String[] args) {
		ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(10);
		Producer p = new Producer(q);
		new Thread(p).start();
	}
}
//结果：
插入成功:0
插入成功:1
插入成功:2
插入成功:3
插入成功:4
插入成功:5
插入成功:6
插入成功:7
插入成功:8
插入成功:9

        此时程序并不会退出，而是阻塞在那里等待队列有位置插入。

 

        4.获取元素

        1）peek方法

        获取但不移除此队列的头；如果此队列为空，则返回 null。以下是peek方法的源代码：

/**
 * 获取但不移除此队列的头；如果此队列为空，则返回 null
 */
public E peek() {
	final ReentrantLock lock = this.lock;
	//获取锁
	lock.lock();
	try {
		//判断队列中是否有元素，如果没有则返回null，如果存在则返回该元素
		return (count == 0) ? null : items[takeIndex];
	} finally {
		//释放锁
		lock.unlock();
	}
}

 

        peek代码比较简单，首先判断队列是否有元素，即count==0，如果为空则返回null，非空则返回相应元素。

        2）poll方法

        获取并移除此队列的头，如果此队列为空，则返回 null。以下是poll方法的源代码：

/**
 * 获取并移除此队列的头，如果此队列为空，则返回 null
 */
public E poll() {
	final ReentrantLock lock = this.lock;
	//获取锁
	lock.lock();
	try {
		//判断是否存在元素
		if (count == 0)
			return null;
		//调用extract方法返回元素
		E x = extract();
		return x;
	} finally {
		//释放锁
		lock.unlock();
	}
}

        poll方法调用的是 extract()方法来获取头元素。

        3）extract方法

        以下是extract()方法的源代码：

/**
 * 从 takeIndex位置获取元素（在获得锁的情况下调用）
 */
private E extract() {
	final E[] items = this.items;
	//获取元素
	E x = items[takeIndex];
	//移除原位置元素
	items[takeIndex] = null;
	//计算 takeIndex新值
	takeIndex = inc(takeIndex);
	--count;
	//唤醒添加线程
	notFull.signal();
	return x;
}

        4）take方法

        获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。

/**
 * 获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）
 */
public E take() throws InterruptedException {
	final ReentrantLock lock = this.lock;
	// 获取中断锁
	lock.lockInterruptibly();
	try {
		try {
			// 如果队列未空则阻塞等待，直到有元素为止
			while (count == 0)
				notEmpty.await();
		} catch (InterruptedException ie) {
			notEmpty.signal(); // 唤醒获取线程
			throw ie;
		}
		// 调用extract方法返回元素
		E x = extract();
		return x;
	} finally {
		// 释放锁
		lock.unlock();
	}
}

        与put方法类似，take方法也是利用循环阻塞的方式来获取元素，如果没有元素则等待，直至获取元素为止。

        与put方法的例子类似，生产者只生产5个产品，消费完这5个产品后，消费者就不得不等待队列有元素可取：

class Producer implements Runnable {
	private final ArrayBlockingQueue<Integer> queue;
	private int i;

	Producer(ArrayBlockingQueue<Integer> q) {
		queue = q;
	}

	public void run() {
		try {
			for (int i = 0; i < 5; i++) {
				int p = produce();
				queue.put(p);// 将产品放入缓冲队列
				System.out.println("插入成功:" + p);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	int produce() {
		return i++;// 生产产品
	}
}

class Consumer implements Runnable {
	private final ArrayBlockingQueue<Integer> queue;

	Consumer(ArrayBlockingQueue<Integer> q) {
		queue = q;
	}

	public void run() {
		try {
			while (true) {
				int p = queue.take();
				System.out.println("获取成功:" + p);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	void consume(Object x) {
		System.out.println("消费：" + x);// 消费产品
	}
}

public class Runner {
	public static void main(String[] args) {
		ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(10);// 或其他实现
		Producer p = new Producer(q);
		Consumer c1 = new Consumer(q);
		Consumer c2 = new Consumer(q);
		new Thread(p).start();
		new Thread(c1).start();
		new Thread(c2).start();
	}
}
//结果：
插入成功:0
插入成功:1
插入成功:2
插入成功:3
插入成功:4
获取成功:0
获取成功:1
获取成功:2
获取成功:3
获取成功:4

        之后程序也是会阻塞在那里。

 

        5.移除元素

        1）remove方法

        remove方法从此队列中移除指定元素的单个实例（如果存在）。更确切地讲，如果此队列包含一个或多个满足 o.equals(e) 的元素 e，则移除该元素。如果此队列包含指定的元素（或者此队列由于调用而发生更改），则返回 true。 

/**
 * 从此队列中移除指定元素的单个实例（如果存在）
 */
public boolean remove(Object o) {
	//判断要移除元素是否为空
	if (o == null)
		return false;
	final E[] items = this.items;
	final ReentrantLock lock = this.lock;
	//获取锁
	lock.lock();
	try {
		int i = takeIndex;
		int k = 0;
		for (;;) {
			//判断队列是否含有元素
			if (k++ >= count)
				return false;
			//比较
			if (o.equals(items[i])) {
				//移除
				removeAt(i);
				return true;
			}
			//返回i新值，以便下次循环使用
			i = inc(i);
		}

	} finally {
		//释放锁
		lock.unlock();
	}
}

        remove方法其中利用循环来不断判断该元素的位置，如果找到则调用 removeAt方法移除指定位置的数组元素。

        以下是一个移除的小例子：

ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(10);
// 添加10个元素
for (int i = 0; i < 10; i++) {
	q.add(i);
}
// 移除值为 1,3,5,7,9 的这五个元素
q.remove(1);
q.remove(3);
q.remove(5);
q.remove(7);
q.remove(9);
//又移除了一次 9
q.remove(9);
for (Integer i : q) {
	System.out.println(i);
}
//结果:
0
2
4
6
8

        从结果可以看出，从队列中正确的移除了我们指定的元素，在最后即使指定已经不存在的元素值，remove方法也之后返回false。

        2）drainTo方法

        drainTo方法用于移除此队列中所有可用的元素，并将它们添加到给定 collection 中。此操作可能比反复轮询此队列更有效。在试图向 collection c 中添加元素没有成功时，可能导致在抛出相关异常时，元素会同时在两个 collection 中出现，或者在其中一个 collection 中出现，也可能在两个 collection 中都不出现。如果试图将一个队列放入自身队列中，则会导致 IllegalArgumentException 异常。此外，如果正在进行此操作时修改指定的 collection，则此操作行为是不确定的。 

        以下是 drainTo方法的源代码：

public int drainTo(Collection<? super E> c) {
	//如果指定 collection为 null 抛出异常
    if (c == null)
        throw new NullPointerException();
    //如果指定 collection 是此队列，或者此队列元素的某些属性不允许将其添加到指定 collection 抛出异常
    if (c == this)
        throw new IllegalArgumentException();
    final E[] items = this.items;
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lock();
    try {
    	//take操作的位置
        int i = takeIndex;
        int n = 0;
        //元素数量
        int max = count;
        //利用循环不断取出元素添加到c中
        while (n < max) {
            c.add(items[i]);
            items[i] = null;
            i = inc(i);
            ++n;
        }
        //添加完成后初始化必要值，唤醒添加线程
        if (n > 0) {
            count = 0;
            putIndex = 0;
            takeIndex = 0;
            notFull.signalAll();
        }
        //返回添加元素数量
        return n;
    } finally {
    	//释放锁
        lock.unlock();
    }
}

        代码中并没有添加失败的相关处理，所以结果如上所说并不一定完整。以下是相关实例：

ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(10);
List<Integer> list = new ArrayList<Integer>();
// 添加10个元素
for (int i = 0; i < 10; i++) {
	q.add(i);
	list.add(i + 10);
}
//将q中的元素添加到 list中
q.drainTo(list);
for (Integer i : list) {
	System.out.println(i);
}
//结果：
10
11
12
13
14
15
16
17
18
19
0
1
2
3
4
5
6
7
8
9

        需要值得注意的是 drainTo方法是将队列中的元素按顺序添加到指定 Collection中，别弄反了。

        drainTo(Collection<? super E> c, int maxElements)用法类似，只不过指定了移除元素数。

        3）clear方法

        移除此队列中的所有元素。在此调用返回之后，队列将为空。

/**
 * 移除此队列中的所有元素。在此调用返回之后，队列将为空
 */
public void clear() {
	final E[] items = this.items;
	final ReentrantLock lock = this.lock;
	//获取锁
	lock.lock();
	try {
		int i = takeIndex;
		int k = count;
		//将数组元素置为null
		while (k-- > 0) {
			items[i] = null;
			i = inc(i);
		}
		//初始化其他参数
		count = 0;
		putIndex = 0;
		takeIndex = 0;
		//唤醒添加线程
		notFull.signalAll();
	} finally {
		//释放锁
		lock.unlock();
	}
}

        clear方法比较简单，就是利用循环清除数组中的元素，然后将相关参数置为初始值。

        ArrayBlockingQueue还有一些其他方法，这些方法相对简单这里就不细说了。

 

【java】java 并发编程 ArrayBlockingQueue
九师兄
04-15 315
【java】java 并发编程 BlockingQueue 和 BlockingDequeArrayBlockingQueue是数组实现的线程安全的有界的阻塞队列。线程安全是指，ArrayBlockingQueue内部通过“互斥锁”保护竞争资源，实现了多线程对竞争资源的互斥访问。有界，则是指ArrayBlockingQueue对应的数组是有界限的。阻塞队列，是指多线程访问竞争资源时，当竞争资源已被某线程获取时，其它要获取该资源的线程需要阻塞等待；而且，是按FIFO（先进先出）
Java源码解析阻塞队列ArrayBlockingQueue常用方法
08-26
今天小编就为大家分享一篇关于Java源码解析阻塞队列ArrayBlockingQueue常用方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
ArrayBlockingQueu
lengyuhong的专栏
11-01 802
<br />/* * @(#)ArrayBlockingQueue.java 1.14 06/06/01 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.util.concurrent; import java.util.concurrent.lo
并发容器分析（二）--ArrayBlockingQueue
思过崖
10-13 205
一、简介     BlockingQueue接口定义了一种阻塞的FIFO queue，每一个BlockingQueue都有一个容量，让容量满时往BlockingQueue中添加数据时会造成阻塞，当容量为空时取元素操作会阻塞。ArrayBlockingQueue是对BlockingQueue的一个数组实现，它使用一把全局的锁并行对queue的读写操作，同时使用两个Condition阻塞容量为空时的...
并发阻塞队列ArrayBlockingQueue
lan墨的博客
06-23 547
ArrayBlockingQueue 一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部 是在队列中存在时间最长的元素。队列的尾部 是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。 这是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能再增加其容量...
java queue put take,ArrayBlockingQueue：并发put和take
weixin_29468281的博客
02-13 188
Why ABQ has not been implemented using the way LinkedBlockingQueue. We can use AtomicInteger to keep Track count in ABQ also the same way LBQ does. We can use the Two Locks for ABQ too.I stumble upon ...
java并发之ArrayBlockingQueue详细介绍
08-30
Java并发之ArrayBlockingQueue详细介绍 ArrayBlockingQueue是Java并发编程中常用的线程安全队列，经常被用作任务队列在线程池中。它是基于数组实现的循环队列，具有线程安全的实现。 ArrayBlockingQueue的实现 ...
详细分析Java并发集合ArrayBlockingQueue的用法
08-27
Java并发集合ArrayBlockingQueue的用法详解 Java并发集合ArrayBlockingQueue是Java并发集合框架下的一个重要组件，它提供了阻塞队列的实现，用于多线程环境下的并发操作。下面是对ArrayBlockingQueue的用法详解： ...
并发容器之ArrayBlockingQueue和LinkedBlockingQueue实现原理详解
06-20
ArrayBlockingQueue和LinkedBlockingQueue是Java并发容器中两个常用的阻塞队列实现，分别基于数组和链表存储元素。它们都继承自AbstractQueue类，并实现了BlockingQueue接口，提供了线程安全的队列操作。 ...
Java concurrency集合之ArrayBlockingQueue_动力节点Java学院整理
08-30
ArrayBlockingQueue是Java并发编程中一个重要的集合类，它属于 BlockingQueue 接口的一个实现，主要特点是线程安全、有界以及基于数组的阻塞队列。线程安全得益于其内部使用了Java并发包中的ReentrantLock（可重入锁...
阻塞队列ArrayBlockingQueue
胖胖龙的博客
08-23 225
队列包含固定长度队列和不固定长度队列ArrayBlockingQueue固定长度的阻塞队列 只有put()和take()方法才具有阻塞功能
java中ArrayBlockingQueue集合介绍
qq_36055407的博客
07-23 640
ArrayBlocking 是一个阻塞共享队列； 1.对比offer()与put()方法 ：         offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.（本方法不阻塞当前执行方法的线程） 　　offer(E o, long timeout, TimeUni...
线程池 任务队列 BlockingQueue<Runnable> workQueue
fascinatingGirl的博客
04-01 3335
任务队列（BlockingQueue）指存放被提交但尚未被执行的任务的队列。 包括以下几种类型：直接提交的、有界的、无界的、优先任务队列。 1.1 直接提交的任务队列（SynchronousQueue） （1）SynchronousQueue没有容量。 （2）提交的任务不会被真实的保存在队列中，而总是将新任务提交给线程执行。如果没有空闲的线程，则尝试创建新的线程。如果...
关于ArrayBlockingQueue的一个内部方法——dec(int i)
归歌
11-10 619
今天在翻看JDK时候突然看到一个方法 /** * Circularly decrement i. */ final int dec(int i) { return ((i == 0) ? items.length : i) - 1; } 这是关于一个循环递减的函数实现，技巧给满分，原因在于没有大家都会想到的溢出取模，因为在算术选择...
基于AQS的ArrayBlockingQueue源码实现
瘦子没有夏天
08-26 545
基于AQS的ArrayBlockingQueue源码实现 一、引言 1.1 普通队列 譬如我们经常见到的ArrayList、LinkedList的队列，这些可以称之为简单队列或者普通队列。对它们的使用和理解我们就不做过多介绍。 说明 本人研究的JDK版本为JDK8。不同版本的实现可能略有差异，请读者们周知。 1.2 阻塞队列 JDK5后，Java在J.U.C包下给我们提供了一系列的阻塞队列的...
ArrayBlockingQueue
pengjianglilive的专栏
09-25 344
在java多线程操作中， BlockingQueue<E> 常用的一种方法之一。在看jdk内部尤其是一些多线程，大量使用了blockinkQueue 来做的。 借用jdk api解释下： BlockingQueue方法以四种形式出现，对于不能立即满足但可能在将来某一时刻可以满足的操作，这四种形式的处理方式不同：第一种是抛出一个异常，第二种是返回一个特殊值（null或false，具体取决于操作），第三种是在操作可以成功前，无限期地阻塞当前线程，第四种是在放弃前只在给定的最大时间限制内阻...
【Java】阻塞队列
最新发布
Creativity + Efficiency = Success
03-06 1812
介绍阻塞队列的定义、种类、实现原理以及应用。
Java并发编程：深入理解ArrayBlockingQueue
"ArrayBlockingQueue是Java并发编程中的一个重要组件，它是线程安全的有界阻塞队列，基于数组实现，遵循先进先出（FIFO）原则。在ArrayBlockingQueue中，多线程对资源的竞争由内部的ReentrantLock进行管理，确保了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值