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


文章目录

  • 一.ArrayBlockingQueue 介绍
  • 二、创建ArrayBlockingQueue
  • 2.1 默认非公平阻塞队列
  • 2.2 公平阻塞队列
  • 2.3 给定集合的元素,按集合迭代器的遍历顺序添加
  • 三、使用ArrayBlockingQueue
  • 3.1 添加
  • 3.1.1 offer()方法
  • 3.1.2 add()方法
  • 3.1.3 put()方法
  • 3.1.4 总结
  • 3.2 删除
  • 3.2.1 remove()
  • 3.2.2 poll()
  • 3.2.3 take()
  • 3.3 检查方法
  • 3.3.1 element()
  • 3.3.2 peek()
  • 扩展
  • 关注 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();
        }
    }


技术博客:

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