关于线程池中的阻塞队列BlockingQueue

最新推荐文章于 2025-11-28 00:02:34 发布

原创最新推荐文章于 2025-11-28 00:02:34 发布 · 646 阅读

1 ·

CC 4.0 BY-SA版权

Java开发语言专栏收录该内容

106 篇文章

订阅专栏

本文详细解析了Java中BlockingQueue的五种实现：ArrayBlockingQueue、DelayQueue、LinkedBlockingQueue、PriorityBlockingQueue和SynchronousQueue。阐述了每种队列的特点、适用场景及内部实现机制。

接上篇文章https://blog.youkuaiyun.com/GoSaint/article/details/84345210

对于BlockingQueue阻塞队列而言，常用在多线程生产者和消费者模型上。首先我们需要明确的是阻塞队列是线程安全的。或者可以称之为并发队列，是并发容器的一种规范。

上图是BlockingQueue的实现类：我们介绍下这几个相关的实现。

1 ArrayBlockingQueue

ArrayBlockingQueue是基于数组的队列实现。

存在三个构造器：

（1）public ArrayBlockingQueue(int capacity, boolean fair) {}

（2） public ArrayBlockingQueue(int capacity) {}

（3）public ArrayBlockingQueue(int capacity, boolean fair,Collection<? extends E> c) {}

从上面的三个构造器可以看出，要创建一个ArrayBlockingQueue，最起码需要一个参数capacity；从而说明 ArrayBlockingQueue是有界的阻塞队列。当然这里的有界无界是针对Integer.MAX。如果说我们的指定的容量超过Integer.MAX或者说没有容量大小的限制。那么就可以说这个队列是无界的。boolean fair这个参数是指定是否是公平锁还是非公平锁。对于非公平锁而言，吞吐量要高。最后一个参数Collection，可以指定用一个集合来初始化，将此集合中的元素在构造方法期间就先添加到队列中。

　　ArrayBlockingQueue在生产者放入数据和消费者获取数据，都是共用同一个锁对象，由此也意味着两者无法真正并行运行，这点尤其不同于LinkedBlockingQueue；按照实现原理来分析，ArrayBlockingQueue完全可以采用分离锁，从而实现生产者和消费者操作的完全并行运行。Doug Lea之所以没这样去做，也许是因为ArrayBlockingQueue的数据写入和获取操作已经足够轻巧，以至于引入独立的锁机制，除了给代码带来额外的复杂性外，其在性能上完全占不到任何便宜。 ArrayBlockingQueue和LinkedBlockingQueue间还有一个明显的不同之处在于，前者在插入或删除元素时不会产生或销毁任何额外的对象实例，而后者则会生成一个额外的Node对象。这在长时间内需要高效并发地处理大批量数据的系统中，其对于GC的影响还是存在一定的区别。而在创建ArrayBlockingQueue时，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁。

总结：ArrayBlockingQueue是有界的，并且生产者和消费者使用的是同一个锁。因此无法实现真正的并行。

2 DelayQueue(延迟工作队列)

首先要明确的是：延迟队列是无界的工作队列。只有当指定的时间到了之后才能从队列中取到数据。这就是延迟队列。关于使用demo,我给出下面的一种。首先延迟队列，我们也可以初始化一个容器去存储数据。我们定义对象message.去实现Delayed接口。

package com.cmos.communication;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * 消息体定义 实现Delayed接口就是实现两个方法即compareTo 和 getDelay
 * 
 * @author gosaint
 *
 */
public class Message implements Delayed {

	private int id;
	private String body; // 消息内容
	private long excuteTime;// 延迟时长，这个是必须的属性因为要按照这个判断延时时长。

	public Message(int id, String body, long delayTime) {
		this.id = id;
		this.body = body;
		this.excuteTime = TimeUnit.NANOSECONDS.convert(delayTime, TimeUnit.MILLISECONDS) + System.nanoTime();
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getBody() {
		return body;
	}

	public void setBody(String body) {
		this.body = body;
	}

	public long getExcuteTime() {
		return excuteTime;
	}

	public void setExcuteTime(long excuteTime) {
		this.excuteTime = excuteTime;
	}

	@Override
	public int compareTo(Delayed delayed) {
		Message msg = (Message) delayed;
		return Integer.valueOf(this.id) > Integer.valueOf(msg.id) ? 1
				: (Integer.valueOf(this.id) < Integer.valueOf(msg.id) ? -1 : 0);
	}

	// 最重要的就是getDelay方法，这个方法用来判断是否到期……
	@Override
	public long getDelay(TimeUnit unit) {
		return unit.convert(this.excuteTime - System.nanoTime(), TimeUnit.NANOSECONDS);
	}

}

下面的代码是消费者以及测试实例：

    // 延时队列 ,消费者从其中获取消息进行消费  
    private DelayQueue<Message> queue;  
  
    public Consumer2(DelayQueue<Message> queue) {  
        this.queue = queue;  
    }  
  
    @Override  
    public void run() {  
        while (true) {  
            try {  
                Message take = queue.take();  
                System.out.println("消费消息id：" + take.getId() + " 消息体：" + take.getBody());  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

package com.cmos.procon.partten;  
  
import java.util.concurrent.DelayQueue;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class DelayQueueTest {  
     public static void main(String[] args) {    
            // 创建延时队列    
            DelayQueue<Message> queue = new DelayQueue<Message>();    
            // 添加延时消息,m1 延时3s    
            Message m1 = new Message(1, "world", 3000);    
            // 添加延时消息,m2 延时10s    
            Message m2 = new Message(2, "hello", 10000);    
            //将延时消息放到延时队列中  
            queue.offer(m2);    
            queue.offer(m1);    
            // 启动消费线程 消费添加到延时队列中的消息，前提是任务到了延期时间   
            ExecutorService exec = Executors.newFixedThreadPool(1);  
            exec.execute(new Consumer2(queue));  
            exec.shutdown();  
        }    
}

3 LinkedBlockingQueue

基于链表实现的阻塞队列。

public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
}

从构造器来看，LinkedBlockingQueue是无界的阻塞队列。和ArrayBlockingQueue相比较，它是链表的实现，并且生产者和消费者各自使用自己的锁。因此就并发能力来看，它应该更加的高效。对于LinkedBlockingQueue的使用值得注意的是由于LinkedBlockingQueue是无界的，因此如果一旦生产者生产的速度大于消费者消费的速度，那么就很有可能产生内存溢出的。

4 PriorityBlockingQueue优先级队列

public PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator) {}

从构造器可以看出，可以通过某个字段或者其他属性进行比较排序，确定优先级。

5 SynchronousQueue（同步队列）

它是一个特殊的队列，它的名字其实就蕴含了它的特征 – - 同步的队列。为什么说是同步的呢？这里说的并不是多线程的并发问题，而是因为当一个线程往队列中写入一个元素时，写入操作不会立即返回，需要等待另一个线程来将这个元素拿走；同理，当一个读线程做读操作的时候，同样需要一个相匹配的写线程的写操作。这里的 Synchronous 指的就是读线程和写线程需要同步，一个读线程匹配一个写线程。

总结：生产者生产一个，消费者消费一个。

参考：http://www.importnew.com/28053.html