各种Queue分析

Queue主要方法的区别：

	抛出异常	返回特殊值
插入	add(e)插入成功则返回true,没有可用空间则IllegalStateException	offer(e)
移除	remove(e)获取并移除，不存在则抛异常	poll(e)
检查	element()获取元素，但并不移除，队列为空则抛出异常	peek()

Queue既可以是FIFO，也可以是按照一定优先级顺序排列，BlockingQueue区别在于对于空队列获取等待，满队列加入等待，适用于生产者消费者模型：

/**
 * Created by itworker365 on 6/2/2017.
 */
public class ThreadWNTest {
    public static void main (String[] args) throws InterruptedException {
        BlockingQueue blockingQueue = new ArrayBlockingQueue(10);
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    int i = 0;
                    while (i < 100) {
                        System.out.println("put :" + i++);
                        blockingQueue.put(i++);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        System.out.println("take: " + blockingQueue.take());
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();
        System.out.println("start");
    }
}

ArrayBlockingQueue: 主要方法学习

包含一个object数组存放元素，takeIndex和putIndex分别包含放入和取出元素的位置，count表示当前元素个数，全局锁lock分别创建notFull和notEmpty（await/singnal）完成当元素满时添加等待，元素空时取元素等待。

class BasicBlockingQueue<E> {
    final Object[] items;
    int takeIndex;
    int putIndex;
    int count;
    final ReentrantLock lock;
    private final Condition notEmpty;
    private final Condition notFull;

    public BasicBlockingQueue (int capacity, boolean fair){
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }
    //添加元素,如果添加元素为null则抛出异常，如果非null则获取全局锁
    // 看添加元素后是否满足队列总长度限制，超出返回false，未超出则将元素添加到对应的items[putIndex]位置，并唤醒notEmpty.signal()
    private boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }
    //带超时设定的这种
    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 {
            while (count == items.length) {
                if (nanos <= 0)
                    return false;
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(e);
            return true;
        } finally {
            lock.unlock();
        }
    }
    //添加元素时，offer如果满了返回false，而add不能添加时则抛出异常
    public boolean add(E e) {
        if (offer(e))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }

    private void enqueue(E x) {
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        notEmpty.signal();
    }
    //取出元素,带超时的，获取全局锁，当元素为0，等待超时时间，一直没有就返回null,有的话就取出队列元素
    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0) {
                if (nanos <= 0)
                    return null;
                nanos = notEmpty.awaitNanos(nanos);
            }
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

    private E dequeue() {
        final Object[] items = this.items;
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        //不断循环使用
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        notFull.signal();
        return x;
    }
}

LinkedBlockingQueue: 主要方法学习

元素存放在单向列表中，记录首尾节点，统计元素数目用atomicInteger，takelock和putlock分离,添加只需要修改last，取出只需要修改head

class BasicLinkedBlockingQueue<E> {
    private final int capacity = Integer.MAX_VALUE;
    //统计元素数目用AtomicInteger
    private final AtomicInteger count = new AtomicInteger(0);
    private transient Node<E> head;
    private transient Node<E> last;
    //分别创建takeLock和putLock
    private final ReentrantLock takeLock = new ReentrantLock();
    private final Condition notEmpty = takeLock.newCondition();

    private final ReentrantLock putLock = new ReentrantLock();
    private final Condition notFull = putLock.newCondition();

    //加入元素，包含超时，先获取putlock，跟array基本一样，元素数目用count.getAndIncrement()统计，然后释放锁，发放signalNotEmpty通知
    public boolean offer(E e, long timeout, TimeUnit unit)
            throws InterruptedException {

        if (e == null) throw new NullPointerException();
        long nanos = unit.toNanos(timeout);
        int c = -1;
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            while (count.get() == capacity) {
                if (nanos <= 0)
                    return false;
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(new Node<E>(e));
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return true;
    }
    //取得元素，带超时，先拿到takelock，和别的也一样
    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        E x = null;
        int c = -1;
        long nanos = unit.toNanos(timeout);
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();
        try {
            while (count.get() == 0) {
                if (nanos <= 0)
                    return null;
                nanos = notEmpty.awaitNanos(nanos);
            }
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }
    //添加只需要修改last
    private void enqueue(Node<E> node) {
        last = last.next = node;
    }
    //取出只需要修改head
    private E dequeue() {
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }
    private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }
    private void signalNotFull() {
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            notFull.signal();
        } finally {
            putLock.unlock();
        }
    }
}
class Node<E> {
    E item;
    Node<E> next;
    Node(E x) { item = x; }
}