Java并发阻塞队列之ArrayBlockingQueue

JUC简介

在 Java 5.0 提供了java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类,用于定义类似于线程的自定义子系统,包括线程池,异步IO和轻量级任务框架;还提供了设计用于多线程上下文中的Collection实现等;

今天要讲的ArrayBlockingQueue便是JUC包下的一个工具类。

ArrayBlockingQueue简介

ArrayBlockingQueue是数组实现的线程安全的有界的阻塞队列。线程安全是指类内部通过“互斥锁”保护竞争资源，实现多线程对竞争资源的互斥访问。

“有界”则是指ArrayBlockingQueue对应的数组是有界限且固定的，在创建对象时由构造函数指定，一旦指定则无法更改。

阻塞队列，是指多线程访问竞争资源时，当竞争资源已被某线程获取时，其它要获取该资源的线程需要阻塞等待；

ArrayBlockingQueue是按FIFO（先进先出）原则对元素进行排序，元素都是从尾部插入到队列，从头部开始返回。

ArrayBlockingQueue函数列表

1. // 创建一个带有给定的（固定）容量和默认访问策略的ArrayBlockingQueue。
   
2. ArrayBlockingQueue(int capacity)
   
3. // 创建一个具有给定的（固定）容量和指定访问策略的ArrayBlockingQueue。
   
4. ArrayBlockingQueue(int capacity,boolean fair)
   
5. // 创建一个具有给定的（固定）容量和指定访问策略的 ArrayBlockingQueue，它最初包含给定collection的元素，并以collection迭代器的遍历顺序添加元素。
   
6. ArrayBlockingQueue(int capacity,boolean fair,Collection<?extends E> c)
   
7. 
   
8. // 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回true，如果此队列已满，则抛出IllegalStateException。
   
9. boolean add(E e)
   
10. // 自动移除此队列中的所有元素。
    
11. void clear()
    
12. // 如果此队列包含指定的元素，则返回true。
    
13. boolean contains(Object o)
    
14. // 移除此队列中所有可用的元素，并将它们添加到给定collection中。
    
15. int drainTo(Collection<?super E> c)
    
16. // 最多从此队列中移除给定数量的可用元素，并将这些元素添加到给定 collection中。
    
17. int drainTo(Collection<?super E> c,int maxElements)
    
18. // 返回在此队列中的元素上按适当顺序进行迭代的迭代器。
    
19. Iterator<E> iterator()
    
20. // 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则返回false。
    
21. boolean offer(E e)
    
22. // 将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。
    
23. boolean offer(E e,long timeout,TimeUnit unit)
    
24. // 获取但不移除此队列的头；如果此队列为空，则返回null。
    
25. E peek()
    
26. // 获取并移除此队列的头，如果此队列为空，则返回null。
    
27. E poll()
    
28. // 获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
    
29. E poll(long timeout,TimeUnit unit)
    
30. // 将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间。
    
31. void put(E e)
    
32. // 返回在无阻塞的理想情况下（不存在内存或资源约束）此队列能接受的其他元素数量。
    
33. int remainingCapacity()
    
34. // 从此队列中移除指定元素的单个实例（如果存在）。
    
35. boolean remove(Object o)
    
36. // 返回此队列中元素的数量。
    
37. int size()
    
38. // 获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。
    
39. E take()
    
40. // 返回一个按适当顺序包含此队列中所有元素的数组。
    
41. Object[] toArray()
    
42. // 返回一个按适当顺序包含此队列中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
    
43. <T> T[] toArray(T[] a)
    
44. // 返回此 collection 的字符串表示形式。
    
45. String toString()
    

源代码分析

构造函数

ArrayBlockingQueue提供了三个构造函数。

1.    publicArrayBlockingQueue(int capacity){
   
2.        this(capacity,false);
   
3.    }
   
4. 
   
5.    publicArrayBlockingQueue(int capacity,boolean fair){
   
6.        if(capacity <=0)
   
7.            thrownewIllegalArgumentException();
   
8.        this.items =newObject[capacity];
   
9.        lock=newReentrantLock(fair);
   
10.        notEmpty =lock.newCondition();
    
11.        notFull =  lock.newCondition();
    
12.    }
    
13. 
    
14.    publicArrayBlockingQueue(int capacity,boolean fair,
    
15.                              Collection<?extends E> c){
    
16.        this(capacity, fair);
    
17. 
    
18.        finalReentrantLocklock=this.lock;
    
19.        lock.lock();// Lock only for visibility, not mutual exclusion
    
20.        try{
    
21.            int i =0;
    
22.            try{
    
23.                for(E e : c){
    
24.                    checkNotNull(e);
    
25.                    items[i++]= e;
    
26.                }
    
27.            }catch(ArrayIndexOutOfBoundsException ex){
    
28.                thrownewIllegalArgumentException();
    
29.            }
    
30.            count = i;
    
31.            putIndex =(i == capacity)?0: i;
    
32.        }finally{
    
33.            lock.unlock();
    
34.        }
    
35.    }
    

其中，第一个构造函数只需指定队列（数组）初始化大小，这正是前面提到的“有界”的边界所在。同时，它调用了第二个构造函数，默认将fair参数传值为false。

fair是“可重入的独占锁(ReentrantLock)”的类型。fair为true，表示是公平锁；fair为false，表示是非公平锁。公平性通常会降低吞吐量，但是减少了可变性和避免了“不平衡性”。

构造函数中this.items对应的代码为：

1. /** The queued items */
   
2.    finalObject[] items;
   

这是存储阻塞队列数据的数组。在第三个构造函数中提供了初始化队列数组中数据的方法。

加入队列

ArrayBlockingQueue提供了4个方法将元素添加入队列。

• 
  add(E e) ：如果立即可行且不会超过该队列的容量，将指定的元素插入到队列的尾部。成功返回true，队列已满则抛出IllegalStateException("Queue full")异常。
  
  
• 
  offer(E e) :如果立即可行且不会超过该队列的容量，将指定的元素插入到此队列的尾部。成功返回true，队列已满则返回false。
  
  
• 
  offer(E e, long timeout, TimeUnit unit) :将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间
  
  
• 
  put(E e) :将指定的元素插入此队列的尾部，如果队列已满则等待可用的空间。成功则返回true，等待超时则返回false。
  
  

源代码说明:

1. // 方法一
   
2. publicboolean add(E e){
   
3.    returnsuper.add(e);
   
4. }
   
5. // 方法二
   
6. publicboolean add(E e){
   
7.    if(offer(e))
   
8.        returntrue;
   
9.    else
   
10.        thrownewIllegalStateException("Queue full");
    
11. }
    
12. // 方法三
    
13. publicboolean offer(E e){
    
14.    checkNotNull(e);
    
15.    finalReentrantLocklock=this.lock;
    
16.    lock.lock();  // 一直等到获取锁
    
17.    try{
    
18.        if(count == items.length)  //假如当前容纳的元素个数已经等于数组长度，那么返回false
    
19.            returnfalse;
    
20.        else{
    
21.            enqueue(e);        // 将元素插入到队列中，返回true
    
22.            returntrue;
    
23.        }
    
24.    }finally{
    
25.        lock.unlock();        //释放锁
    
26.    }
    
27. }
    

add方法调用了父类的add方法（方法二），通过父类的add方法可以得出，最终还是调用了offer方法（方法三）。可以看出，父类方法调用offer之后，如果offer返回false，则表示队列已满，父类方法会抛出异常。

而offer方法首先校验添加的对象是否为null，如果null则直接抛出空指针异常。然后获得锁进行队列大小（count记录了队列中元素的个数）比较，如果当前队列中的元素个数与count相等，则返回false，不进行插入。否则，将元素插入队列，并返回true。

下面再看一下offer中调用的enqueue方法：

1. privatevoid enqueue(E x){    
   
2. 
   
3.    //调用enqueue的方法都都已经进行过同步处理
   
4.    // assert lock.getHoldCount() == 1;
   
5.    // assert items[putIndex] == null;
   
6.    finalObject[] items =this.items;
   
7.    items[putIndex]= x;        //putIndex是下一个被添加元素的坐标
   
8.    if(++putIndex == items.length)    
   
9.    //putIndex+1, 并且与数组长度进行比较，相同则从数组开头
   
10.        putIndex =0;            //插入元素，这就是循环数组的奥秘了
    
11.    count++;                //当前元素总量+1
    
12.    notEmpty.signal();            //给等到在数组非空的线程一个信号，唤醒他们。
    
13. }
    

enqueue方法才是所有添加队列方法真正调用来操作添加的方法，其中putIndex是下一个被添加元素的坐标。整个方法的业务逻辑是这样的：首先将待添加的元素添加到putIndex所在的位置，并且对putIndex进行自增（指向下一个待添加的位置)。然后比较下一个待添加的位置是否和数组的长度相同，如果相同则将putIndex指向数组开头（进入此方法的前提条件是队列数组未满）。然后队列总量加1。

通过这段代码我们就可以真正了解到ArrayBlockingQueue是如何循环使用数组的。首先创建一个定长空数组，然后依次填满数组的0，1，2，……，items.length-1 位置。与此同时，队列中的0，1，2，……位置的元素也在不停的被消费掉。当数组的items.length-1也被填充了元素，次数队列依旧未满，那么新增的元素将放置在哪里？对了，就是像上面的代码一样，会从数组的0坐标重新依次开始添加新的元素。通过这种方式，ArrayBlockingQueue实现了在定长数组下FIFO的队列。

取出队列

ArrayBlockingQueue提供了以下方法支持取出队列：

• 
  poll() :获取并移除此队列的头，如果队列为空，则返回null。
  
  
• 
  poll(long timeout, TimeUnit unit) :获取并移除此队列的头部，在指定的等待时间前等待可用的元素，超时则返回null。
  
  
• 
  remove(Object o) :从此队列中移除指定元素的单个实例（如果存在多个则只移除第一个）。如果不存在要移除的元素则返回false。
  
  
• 
  take() :获取并移除此队列的头部，如果队列为空，则一直等待可用元素，也就是说必须要拿到一个元素，除非线程中断。
  
  
• 
  peek（）：获取队列中takeIndex（待获取元素索引）位置的元素，如果为null则返回空。
  
  

源代码：

1. public E poll(){
   
2.    finalReentrantLocklock=this.lock;
   
3.    lock.lock();
   
4.    try{
   
5.        return(count ==0)?null: dequeue();
   
6.    }finally{
   
7.        lock.unlock();
   
8.    }
   
9. }
   
10. 
    
11. public E take()throwsInterruptedException{
    
12.    finalReentrantLocklock=this.lock;
    
13.    lock.lockInterruptibly();
    
14.    try{
    
15.        while(count ==0)
    
16.            notEmpty.await();
    
17.        return dequeue();
    
18.    }finally{
    
19.        lock.unlock();
    
20.    }
    
21. }
    
22. 
    
23. public E poll(long timeout,TimeUnit unit)throwsInterruptedException{
    
24.    long nanos = unit.toNanos(timeout);
    
25.    finalReentrantLocklock=this.lock;
    
26.    lock.lockInterruptibly();
    
27.    try{
    
28.        while(count ==0){
    
29.            if(nanos <=0)
    
30.                returnnull;
    
31.            nanos = notEmpty.awaitNanos(nanos);
    
32.        }
    
33.        return dequeue();
    
34.    }finally{
    
35.        lock.unlock();
    
36.    }
    
37. }
    
38. 
    
39. public E peek(){
    
40.    finalReentrantLocklock=this.lock;
    
41.    lock.lock();
    
42.    try{
    
43.        return itemAt(takeIndex);// null when queue is empty
    
44.    }finally{
    
45.        lock.unlock();
    
46.    }
    
47. }
    
48. 
    
49. publicboolean remove(Object o){
    
50.    if(o ==null)returnfalse;
    
51.    finalObject[] items =this.items;
    
52.    finalReentrantLocklock=this.lock;
    
53.    lock.lock();
    
54.    try{
    
55.        if(count >0){
    
56.            finalint putIndex =this.putIndex;
    
57.            int i = takeIndex;
    
58.            do{
    
59.                if(o.equals(items[i])){
    
60.                    removeAt(i);
    
61.                    returntrue;
    
62.                }
    
63.                if(++i == items.length)
    
64.                    i =0;
    
65.            }while(i != putIndex);
    
66.        }
    
67.        returnfalse;
    
68.    }finally{
    
69.        lock.unlock();
    
70.    }
    
71. }
    

下面重点分析一下取出队列原因调用的dequeue方法：

1. /**
   
2. * Extracts element at current take position, advances, and signals.
   
3. * Call only when holding lock.
   
4. */
   
5. private E dequeue(){
   
6.    // assert lock.getHoldCount() == 1;
   
7.    // assert items[takeIndex] != null;
   
8.    finalObject[] items =this.items;
   
9.    // 取出指定元素
   
10.    @SuppressWarnings("unchecked")
    
11.    E x =(E) items[takeIndex];
    
12.    // 并将取出元素索引内容置为null
    
13.    items[takeIndex]=null;
    
14.    // 将待取出索引+1，并与队列长度做比较，如果超出数组长度则从0重新开始
    
15.    if(++takeIndex == items.length)
    
16.        takeIndex =0;
    
17.    count--;
    
18.    // 如果迭代器不为null，则进行迭代处理
    
19.    if(itrs !=null)
    
20.        itrs.elementDequeued();
    
21.    notFull.signal();
    
22.    return x;
    
23. }
    

在enqueue中解了添加元素进入队列的操作之后就不难理解从队列中取出数据的过程了。首先调用dequeue的取出操作，都会先将元素取出，然后再将数组对应位置置null。然后对takeIndex的位置进行后移1位，如果takeIndex处于数组的最后一位，则重新从0开始。

实战

在学习了基础理论知识之后，我们用一个实例来练习一下。

1. package com.secbro2.juc;
   
2. 
   
3. import java.util.Queue;
   
4. import java.util.concurrent.ArrayBlockingQueue;
   
5. 
   
6. /**
   
7. * @author zzs
   
8. */
   
9. publicclassArrayBlockingQueueDemo{
   
10. 
    
11.    privatestaticQueue<String> queue =newArrayBlockingQueue<String>(20);
    
12. 
    
13.    publicstaticvoid main(String[] args){
    
14.        newQueueThread("QTA").start();
    
15.        newQueueThread("QTB").start();
    
16.    }
    
17. 
    
18.    privatestaticclassQueueThreadextendsThread{
    
19.        QueueThread(String name){
    
20.            super(name);
    
21.        }
    
22. 
    
23.        @Override
    
24.        publicvoid run(){
    
25.            for(int i =0; i <6; i++){
    
26.                // 线程名称+序号
    
27.                String str =Thread.currentThread().getName()+"-"+ i;
    
28.                queue.add(str);
    
29.                printQueue();
    
30.            }
    
31. 
    
32.        }
    
33.    }
    
34. 
    
35.    privatestaticvoid printQueue(){
    
36.        StringBuilder sb =newStringBuilder();
    
37.        for(Object aQueue : queue){
    
38.            sb.append(aQueue).append(",");
    
39.        }
    
40. 
    
41.        System.out.println(sb.toString());
    
42.    }
    
43. }
    

打印结果如下：

1. QTA-0,QTB-0,
   
2. QTA-0,QTB-0,
   
3. QTA-0,QTB-0,QTA-1,
   
4. QTA-0,QTB-0,QTA-1,QTB-1,
   
5. QTA-0,QTB-0,QTA-1,QTB-1,QTA-2,
   
6. QTA-0,QTB-0,QTA-1,QTB-1,QTA-2,QTB-2,
   
7. QTA-0,QTB-0,QTA-1,QTB-1,QTA-2,QTB-2,QTA-3,
   
8. QTA-0,QTB-0,QTA-1,QTB-1,QTA-2,QTB-2,QTA-3,QTB-3,
   
9. QTA-0,QTB-0,QTA-1,QTB-1,QTA-2,QTB-2,QTA-3,QTB-3,QTA-4,QTB-4,
   
10. QTA-0,QTB-0,QTA-1,QTB-1,QTA-2,QTB-2,QTA-3,QTB-3,QTA-4,QTB-4,
    
11. QTA-0,QTB-0,QTA-1,QTB-1,QTA-2,QTB-2,QTA-3,QTB-3,QTA-4,QTB-4,QTB-5,
    
12. QTA-0,QTB-0,QTA-1,QTB-1,QTA-2,QTB-2,QTA-3,QTB-3,QTA-4,QTB-4,QTB-5,QTA-5,