java源码分析

arrayBlockQueue

生成（插入元素）

在往队列中插入数据由下面几个函数,他们的区别就是对队列满的情况处理不同
- put 一直等待着
- offer(无时间) 如果空了直接返回false
- offer(有时间) 等待指定的时间，在指定时间内如果空了，那么插入，负责返回false
- add 抛出一个IllegalStateException异常

首先来看put实现

   public void put(E e) throws InterruptedException {        checkNotNull(e);        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == items.length)                notFull.await();            insert(e);        } finally {            lock.unlock();        }    }

首先需要获取锁，并把锁设置成可中断的。 然后判断是不是有空闲(count == items.length表示满了)，如果没有空闲的空间，就通过await()一直等待着。 一直到有空闲了，通过insert进行插入。因为使用了可重入的锁，需要unlock解锁

然后我们来看下insert的实现

    private void insert(E x) {        items[putIndex] = x;        putIndex = inc(putIndex);        ++count;        notEmpty.signal();    }

把元素放到队列的最后面，对应的下标＋1，数量也＋1，最后通过signal通知其他线程有空闲的了

再来看下offer(无时间的)

    public boolean offer(E e) {        checkNotNull(e);        final ReentrantLock lock = this.lock;        lock.lock();        try {            if (count == items.length)                return false;            else {                insert(e);                return true;            }        } finally {            lock.unlock();        }    }

很简单，就看是否有空，没有空的直接返回false，否则就插入并返回true

然后来看看有时间版本的offer

    public boolean offer(E e, long timeout, TimeUnit unit)        throws InterruptedException {        checkNotNull(e);        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);            }            insert(e);            return true;        } finally {            lock.unlock();        }    }

当没有空间的时候，就等待指定的时间，如果等待时间到了还没有空，返回false，否则就插入并返回true

消费（移除元素）

同样消费也有好几个版本的，他们的区别也都是对队列是空的情况的处理
- take
- poll(有时间)
- poll(没有时间)

我们看下take

    public E take() throws InterruptedException {        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == 0)                notEmpty.await();            return extract();        } finally {            lock.unlock();        }    }

如果队列是空的，那么一直等着，知道有元素可以消费，然后调用extract进行消费，同样最后需要释放锁
我们在看下extract的实现

    private E extract() {        final Object[] items = this.items;        E x = this.<E>cast(items[takeIndex]);        items[takeIndex] = null;        takeIndex = inc(takeIndex);        --count;        notFull.signal();        return x;    }

把队列尾部的数据拿出来，尾部往前面挪动下，数据-1，最后通知其他线程队列有空的了

然后看下没有时间版本的poll

   public E poll() {        final ReentrantLock lock = this.lock;        lock.lock();        try {            return (count == 0) ? null : extract();        } finally {            lock.unlock();        }    }

如果空的，就直接但会空的了

有时间版本的poll

    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 extract();        } finally {            lock.unlock();        }    }

这个如果是空的，那么就等待设置的时间，时间到了还没有就返回空的

其他操作