Concurrent--阻塞队列

原文地址：http://www.cnblogs.com/dolphin0520/p/3932906.html

前言

非阻塞队列的一个问题就是，它不会对当前线程产生阻塞，那么在面对类似消费者-生产者的模型时，就必须额外的实现同步策略及线程间唤醒策略，这个实现起来就非常麻烦。但是有了阻塞队列就不一样，它会对当前线程产生阻塞，比如一个线程从一个空的阻塞队列中取数据，此时这个线程会被阻塞直到阻塞队列中有元素，被阻塞的线程就会被自动唤醒(不需要我们辨编写代码去唤醒)，这样极大地提高了方便性。

自从jdk 1.5之后，在java.util.concurrent包下提供了若干个阻塞队列

ArrayBlockingQueue:基于数组实现的一个阻塞队列，在创建ArrayBlockingQueue对象时必须指定容量大小。并且可以指定公平性与非公平性，默认情况下为非公平的。

LinkedBlockingQueue:基于链表实现的一个阻塞队列，在创建LinkedBlockingQueue对象时如果不指定容量大小，则默认大小为Integer.MAX_VALUE

PriorityBlockingQueue:以上2中队列都是先进先出队列，而PriorityBlockingQueue却不是，它会按照元素的优先级对元素进行排序，按照优先级顺序出队，每次出队的元素都是优先级最高的元素。注意，此阻塞队列为无界阻塞队列，即容量没有上限(通过源码可知，它没有容器满的信号标志)。前两种都是有界队列。

DelayQueue:基于PriorityQueue,一种延时阻塞队列，DelayQueue中的元素只有当其指定的延时时间到了，才能够从队列中获取该元素。DelayQueue也是一个无界队列，因此往队列中插入数据的操作(生产者)永远不会被阻塞，而只有获取数据的操作(消费者)才会被阻塞。

核心方法

插入

put(E e)向队尾插入元素，若队列已满则进入阻塞状态等待

add(E e)如果队列已满则抛出异常

offer(E e)如果队列已满，则返回false，插入成功则返回true

offer(E e,long timeout, TimeUnit unit) 向队尾插入元素，如果队列已满，则等待一定时间，当时间期限达到时，如果还没有插入成功则返回false，否则返回true

取出/移除

remove(E e)移除队首元素，若移除成功则返回true，如果队列为空导致插入失败则抛出异常

poll(E e）获取并且移除队首元素，如果队列为空导致失败则返回false

poll(long timeout, TimeUnit unit)获取并移除队首元素，如果队列为空导致失败， 则等待一定的时间，如果在指定时间内队列中有了数据则返回队首元素。否则返回false

take(E e)获取队首的元素，若队列为空，则进入阻塞状态，直到队列中有数据，线程执行

drainTo(Collect c,int x)一次性获取队列中所有的元素，也可以指定获取的个数

原理分析

我们只分析ArrayBlockingQueue，其他的原理类似

首先看它的几个成员变量

 /** 底层存储数据的数组 */
    final Object[] items;

    /** 队首元素，下一次取出的元素位置 */
    int takeIndex;

    /** 队尾元素 ，下一次插入元素的位置*/
    int putIndex;

    /** 队列中元素的个数 */
    int count;

    /*
     * 并发控制条件
     */

    /** 可重入的锁 */
    final ReentrantLock lock;

    /** 取出元素的等待条件(takes) */
    private final Condition notEmpty;

    /** 插入元素时的等待条件(puts) */
    private final Condition notFull;

构造器

//只有一个参数用来指定容量
 public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }
    //第一个参数指定容量，第二个参数指定是否公平，底层通过ReetrantLock的公平和非公平锁实现。
 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();
    }
    //指定容量、公平性、以及用另外一个集合进行初始化
 public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
        this(capacity, fair);

        final ReentrantLock lock = this.lock;
        lock.lock(); // Lock only for visibility, not mutual exclusion
        try {
            int i = 0;
            try {
                for (E e : c) {
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();
        }
    }

关键方法的实现：put()和take():

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 {
        	//最终在finally()方法中释放锁
            lock.unlock();
        }
    }

private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        //将元素插入到队尾
        items[putIndex] = x;
        //插入之后,队尾索引+1，判断+1之后是否等于队列的长度
        if (++putIndex == items.length)
        	//如果等于队列的长度，队尾索引置0
            putIndex = 0;
        //队列元素个数+1
        count++;
        //通过条件唤醒等待取出元素的线程
        notEmpty.signal();
    }

take()方法的实现

public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        //通过阻塞等待锁获取锁标记，可被中断阻塞状态
        lock.lockInterruptibly();
        try {
        	//判断当前队列中的元素个数是否为空
            while (count == 0)
            	//如果为空则通过条件阻塞取元素的线程
                notEmpty.await();
             //如果不为空则调用dequeue()方法取出队首元素并返回
            return dequeue();
        } finally {
        	//释放锁标记
            lock.unlock();
        }
    }

private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        //取出队首元素
        E x = (E) items[takeIndex];
        //将队首元素置为null
        items[takeIndex] = null;
        //将队首元素的索引位置+1，并判断+1之后是否等于队列的总容量的值
        if (++takeIndex == items.length)
        	//如果等于总容量的值，则将队首元素置为0
            takeIndex = 0;
         //队列元素-1
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        //通过条件notFull，唤醒等待插入元素的线程
        notFull.signal();
        return x;
    }

通过阻塞队列实现生产者-消费者模型

package cn.tedu.concurrent2;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class ProConDemo1 {
    int queueSize = 10;
    private ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(queueSize);

    int count = 0;




    class Producer extends Thread{
        @Override
        public void run() {

            while (true){
                try {
                    queue.put(count++);
                    System.out.println("生产数据...队列中剩余空间"+(queueSize-queue.size()));

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class Consumer extends Thread{

        @Override
        public void run() {

            while (true){
                try {
                    queue.take();
                    System.out.println("消费数据...队列中剩余空间"+(queueSize-queue.size()));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public static void main(String[] args) {

        ProConDemo1 test = new ProConDemo1();
        Producer p = test.new Producer();

        Consumer c = test.new Consumer();

        p.start();
        c.start();

    }

}