Java concurrency集合之ArrayBlockingQueue_动力节点Java学院整理

Java Concurrency集合之ArrayBlockingQueue

什么是ArrayBlockingQueue

ArrayBlockingQueue是Java提供的一个有界队列，它是按照FIFO（先进先出）的顺序对元素进行存储和访问的。它支持多线程，即多个线程可同时访问该队列，因此被称为Java Concurrency集合之一。

ArrayBlockingQueue的实现原理

ArrayBlockingQueue内部基于数组实现，它封装了一个固定长度的数组，该数组用于存储添加到队列中的元素。当队列的容量被占满时，ArrayBlockingQueue将阻止更多的元素被添加到队列中，直到队列中的其他元素被访问并删除，才能继续添加新的元素。

ArrayBlockingQueue的使用

创建ArrayBlockingQueue

使用ArrayBlockingQueue需要在导入Java.util.concurrent包后通过构造函数创建实例，构造函数接受两个参数：

• int capacity：队列的容量
• boolean fair：是否按公平原则创建队列

ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10, true);

添加元素到ArrayBlockingQueue

当队列未满时，使用add或put方法将一个元素添加到队列中。

try {
    queue.add(1); //添加元素到队列尾部
    queue.put(2); //添加元素到队列尾部，阻塞当前线程直至队列有空位
} catch (InterruptedException e) {
    e.printStackTrace();
}

从ArrayBlockingQueue中取出元素

当队列非空时，使用remove或take方法从队列中取出并移除一个元素。

try {
    Integer num1 = queue.remove(); //从队列头部获取元素并移除
    Integer num2 = queue.take();   //从队列头部获取元素并移除，阻塞当前线程直至队列非空
} catch (InterruptedException e) {
    e.printStackTrace();
}

获取ArrayBlockingQueue的大小或剩余空间

使用size或remainingCapacity方法获取队列的大小或未被填满的剩余空间。

System.out.println("队列大小：" + queue.size()); 
System.out.println("队列中剩余空间：" + queue.remainingCapacity());

示例说明

示例1：生产者和消费者模式

import java.util.concurrent.ArrayBlockingQueue;

public class ProducerConsumerDemo {
    public static void main(String[] args) {
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10, true);
        new Thread(new Producer(queue)).start(); //启动生产者线程
        new Thread(new Consumer(queue)).start(); //启动消费者线程
    }
}

//生产者线程
class Producer implements Runnable {
    private ArrayBlockingQueue<Integer> queue;
    public Producer(ArrayBlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            try {
                queue.put(i);  //将元素放入队列
                System.out.println("生产者生产了：" + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者线程
class Consumer implements Runnable {
    private ArrayBlockingQueue<Integer> queue;
    public Consumer(ArrayBlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            try {
                int num = queue.take(); //从队列中取出元素
                System.out.println("消费者消费了：" + num);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在该示例中，生产者将1~10的数字添加到了队列中，而消费者从队列中取出这些元素，并进行消费。因为在队列满时生产者线程将会被阻塞，而在队列空时消费者线程也同样会被阻塞，因此在这个示例中演示了多线程间的同步。

示例2：队列大小和剩余空间的获取

import java.util.concurrent.ArrayBlockingQueue;

public class QueueSizeDemo {
    public static void main(String[] args) {
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10, true);
        for (int i = 1; i <= 5; i++) {
            queue.add(i); //添加元素
        }
        System.out.println("队列大小：" + queue.size()); //输出队列大小
        System.out.println("队列中剩余空间：" + queue.remainingCapacity()); //输出队列中未被填满的剩余空间
    }
}

在该示例中，先向队列中添加了5个元素，然后通过size和remainingCapacity分别获取了队列的大小和剩余空间。因为队列的容量是10，而已经添加了5个元素，因此队列中剩余的空间还有5个。