Java基础--阻塞队列ArrayBlockingQueue

ArrayBlockingQueue是阻塞队列的一种，基于数组实现，长度固定，队尾添加，队首获取，

构造函数：

ArrayBlockingQueue(int capacity)

ArrayBlockingQueue(int capacity, boolean fair)

ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)

其中capacity为队列的容量，初始化后不可变化。

fair表示多线程操作时是否排队，默认为false，即不保证等待最久的线程优先唤醒。

public方法：

boolean add(E e)　　在队尾添加，若队列已满则抛出异常，成功返回true

void put(E e) 在队尾添加，成功返回true，队列已满则等待

boolean offer(E e)　　在队尾添加，成功返回true，队列已满返回false

boolean offer(E e, long timeout, TimeUnit unit) 在队尾添加，成功返回true，队列已满等待时间为timeout

E take()　　　　从队首取元素，如果队列为空，则等待；

E peek()　　　　获取队首元素，若成功，则返回队首元素；否则返回null

E poll()　　　　移除并获取队首元素，若成功，则返回队首元素；否则返回null

E poll(long timeout, TimeUnit unit) 　　　　　　　　移除并获取队首元素，队列已满等待时间为timeout

int size() 　　　　　　　　返回已使用空间大小

int remainingCapacity()　　　　返回剩余空间大小

boolean remove(Object o) 　　移除一个equals(o)的元素

boolean contains(Object o) 返回是否包含equals(o)

void clear()　　清空队列

实现原理：

--------put

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 {

            lock.unlock();

        }

    }

private void enqueue(E x) {

        final Object[] items = this.items;

        items[putIndex] = x;

        if (++putIndex == items.length)

            putIndex = 0;

        count++;

        notEmpty.signal();

    }

--------

首先元素判空，然后获取了单线程可中断锁，然后判断队列是否已满，是则notFull状态等待，否则放入元素并激活等待notEmpty状态的线程，最后解锁。

-------take

public E take() throws InterruptedException {

        final ReentrantLock lock = this.lock;

        lock.lockInterruptibly();

        try {

            while (count == 0)

                notEmpty.await();

            return dequeue();

        } finally {

            lock.unlock();

        }

    }

private E dequeue() {

        final Object[] items = this.items;

        @SuppressWarnings("unchecked")

        E x = (E) items[takeIndex];

        items[takeIndex] = null;

        if (++takeIndex == items.length)

            takeIndex = 0;

        count--;

        if (itrs != null)

            itrs.elementDequeued();

        notFull.signal();

        return x;

    }

-------

首先获取可中断锁，然后判断队列中是否为空，是则notEmpty状态等待，否则取出元素并激活等待notFull状态的线程，最后解锁。

其他阻塞队列：

----------------------------

//链表实现的队列，动态大小

BlockingQueue<String> queue2 = new LinkedBlockingQueue<String>();

//有优先级的阻塞队列

BlockingQueue<String> queue3 = new PriorityBlockingQueue();

//队列中只能有一个元素

BlockingQueue<String> queue4 = new SynchronousQueue();

---------------------------

一个例子：

------

巴特西

Java基础--阻塞队列ArrayBlockingQueue

最新文章

热门文章