深入解析Java多线程下 ArrayBlockingQueue

相关文章：
JAVA多线程创建、使用看这一篇就够了
Java多线程进阶实战

一.ArrayBlockingQueue 介绍

ArrayBlockingQueue是一个阻塞式的队列，继承自AbstractBlockingQueue,实现了BlockingQueue接口。
底层以数组的形式保存数据(Object [])。常用的操作包括 add，offer，put，remove，poll，take，peek。

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {}  

根据 ArrayBlockingQueue 的名字我们都可以看出，它是一个队列，并且是一个基于数组的阻塞队列。
ArrayBlockingQueue 是一个有界队列，有界也就意味着，它不能够存储无限多数量的对象。
所以在创建 ArrayBlockingQueue 时，必须要给它指定一个队列的大小。

二、创建ArrayBlockingQueue

ArrayBlockingQueue 为我们提供了三种创建方式：

2.1 默认非公平阻塞队列

示例：
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(10);
源码：
public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

这里内部调用了公平锁方法，只是默认未开启

2.2 公平阻塞队列

示例：
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(10,true);
源码：
 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();
    }

2.3 给定集合的元素，按集合迭代器的遍历顺序添加

这个看你参数的传达是公平还是非公平，内部是for循环添加，也进行加锁处理

示例：
ArrayBlockingQueue<String> blockingQueue2 = new ArrayBlockingQueue<String>(10, true, new ArrayList<>());
源码：
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();
        }
    }

三、使用ArrayBlockingQueue

3.1 添加

这里添加也为我们提供了三种方式，我们一一说来；

3.1.1 offer()方法

示例 ：
blockingQueue.offer("Java有货");

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

解析： 首先会对我们的参数进行非空检验，之后获取全局锁，获取之后判断是否达到最大长度，到达返回false，否则进行新增，成功返回true

3.1.2 add()方法

示例 ：
blockingQueue.add("Java有货");

源码：
public boolean add(E e) {
        return super.add(e);
    }
 public boolean add(E e) {
        if (offer(e))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }

解析： 这里也会调用offer()，不同之处在于，**add()**方法添加失败，会报错，不是很友好

3.1.3 put()方法

示例 ：
   try {
        blockingQueue.put("Java有货");
   } catch (InterruptedException e) {
       e.printStackTrace();
   }

源码：
    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();
        }
    }

解析：大家可以看出，调用**put()**方法他调用了 notFull.await();，也就是说，当队列，长多到达最大值时，在进行新增操作，会使对了阻塞，直到条件不满足时在新增，否则一直阻塞；

3.1.4 总结

根据以上几种方式的介绍，与使用，**add()**方法会直接报错，put()方法如果一直阻塞，对服务器的性能消耗太大，所以个人觉得使用offer() 方法更加有利于系统的性能，毕竟失败我们也知道，可以做后续的处理

3.2 删除

3.2.1 remove()

示例：
blockingQueue.remove("Java有货");
源码：
 public boolean remove(Object o) {
        if (o == null) return false;
        final Object[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count > 0) {
                final int putIndex = this.putIndex;
                int i = takeIndex;
                do {
                    if (o.equals(items[i])) {
                        removeAt(i);
                        return true;
                    }
                    if (++i == items.length)
                        i = 0;
                } while (i != putIndex);
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

解析：首先判断我们的元素是否为null，不为null，则通过final Object[] items = this.items;获取当前对列，然后进行 do while 循环操作，进行删除，成功为true，否则为false

3.2.2 poll()

获取对列的首个元素

示例：
blockingQueue.poll("Java有货");
源码：
    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : 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];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        notFull.signal();
        return x;
    }

解析：这里主要dequeue()方法，如果获取的对列无元素，直接返回null，否则就是获取对列的第一个元素，赋值给E 然后将获取后的下标元素重置为null,之后就是下标，长度的加减操作

3.2.3 take()

获取对列的首个元素

示例：
        try {
            blockingQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

解析：这里不多做解释，和之前的新增类

3.3 检查方法

3.3.1 element()

获取但不移除此队列的头元素，没有元素则抛异常

3.3.2 peek()

获取但不移除此队列的头；若队列为空，则返回 null。

这里也不多说，和之前的都差不多

扩展

下面这段代码大家应该也很熟悉，判断是否包含，内容和之前解说的差不多，也是获取元素，进行循环判定，

    public boolean contains(Object o) {
        if (o == null) return false;
        final Object[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count > 0) {
                final int putIndex = this.putIndex;
                int i = takeIndex;
                do {
                    if (o.equals(items[i]))
                        return true;
                    if (++i == items.length)
                        i = 0;
                } while (i != putIndex);
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

今天的分享就到这里，希望对大家有所帮助

关注 Java有货领取更多资料

联系小编。微信：372787553，带您进群互相学习
左侧小编微信，右侧获取免费资料

技术博客：https://blog.csdn.net/weixin_38937840

SpringCloud学习代码： https://github.com/Dylan-haiji/javayh-cloud

Redis、Mongo、Rabbitmq、Kafka学习代码： https://github.com/Dylan-haiji/javayh-middleware

AlibabaCloud学习代码：https://github.com/Dylan-haiji/javayh-cloud-nacos

SpringBoot+SpringSecurity实现自定义登录学习代码：https://github.com/Dylan-haiji/javayh-distribution