java并发包-ArrayBlockingQueue

ArrayBlockingQueue应用场景 线程池

在Java中，ArrayBlockingQueue是一种有界阻塞队列，它在特定的应用场景下非常有用，特别是在与线程池一起使用时。由于您提供的信息中包含关于Java编程的兴趣，我将为您解释ArrayBlockingQueue的应用场景以及它与线程池的关系。

ArrayBlockingQueue的应用场景：

1. 任务调度： 当您使用线程池来管理多个任务时，可以使用ArrayBlockingQueue来存储待执行的任务。这有助于实现任务的调度和执行顺序控制。

2. 生产者-消费者模型： 如果您有一个生产者线程生成数据并将其放入队列，而一个或多个消费者线程从队列中获取并处理这些数据，ArrayBlockingQueue可以很好地实现这种模型。它确保了线程之间的同步和数据安全。

3. 限流： ArrayBlockingQueue的容量是有限的，因此它可以用于限制任务的并发执行数量。这在需要控制系统资源消耗的情况下非常有用。

4. 缓冲： 当生产者产生数据速度快于消费者处理数据的速度时，ArrayBlockingQueue可以用作缓冲区，确保生产者不会过度生产导致内存溢出，而消费者可以按照自己的速度进行处理。

与线程池的关系： ArrayBlockingQueue通常与线程池一起使用，特别是在实现ExecutorService接口的线程池中。线程池中的任务队列可以选择使用ArrayBlockingQueue来管理待执行的任务。这种组合的好处包括：

1. 任务排队： 线程池中的任务队列可以确保待执行的任务按照一定的顺序进行排队。ArrayBlockingQueue可以帮助您控制任务的执行顺序。

2. 线程池大小控制： 由于ArrayBlockingQueue是有界的，它可以帮助限制线程池中同时执行的任务数量，从而控制系统资源的使用。

3. 同步和协调： 使用ArrayBlockingQueue可以在生产者和消费者之间提供同步和协调机制，确保任务的安全执行。

请注意，虽然ArrayBlockingQueue在上述场景中非常有用，但在不同的情况下，您可能会选择使用其他类型的队列，如LinkedBlockingQueue或PriorityBlockingQueue，以更好地满足您的需求。

源码分析

入队

入口

/**
 * Inserts the specified element at the tail of this queue if it is
 * possible to do so immediately without exceeding the queue's capacity,
 * returning {@code true} upon success and throwing an
 * {@code IllegalStateException} if this queue is full.
 *
 * @param e the element to add
 * @return {@code true} (as specified by {@link Collection#add})
 * @throws IllegalStateException if this queue is full
 * @throws NullPointerException if the specified element is null
 */
public boolean add(E e) {
    return super.add(e);
}

入队

/**
 * Inserts the specified element at the tail of this queue if it is
 * possible to do so immediately without exceeding the queue's capacity,
 * returning {@code true} upon success and {@code false} if this queue
 * is full.  This method is generally preferable to method {@link #add},
 * which can fail to insert an element only by throwing an exception.
 *
 * @throws NullPointerException if the specified element is null
 */
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();
    }
}

直接写入数组，因为队列是基于数组实现

/**
 * Inserts element at current put position, advances, and signals.
 * Call only when holding lock.
 */
private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    //将元素放入数组
    items[putIndex] = x; //基于数组实现队列
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    notEmpty.signal();
}

数组如何实现队列？本质是基于双指针，即一个下标指向头，一个下标指向尾。

/** The queued items */
final Object[] items; //基于数字实现队列

/** items index for next take, poll, peek or remove */
int takeIndex; //取出元素的索引

/** items index for next put, offer, or add */
int putIndex; //添加元素的索引

出队

入口

/**
 * 出队(阻塞)：线程池默认使用阻塞
 *
 * @return E
 * @author javaself
 */
public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0)
            notEmpty.await(); //阻塞
        
        //出队
        return dequeue();
    } finally {
        lock.unlock();
    }
}

出队

/**
 * Extracts element at current take position, advances, and signals.
 * Call only when holding lock.
 */
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;
}

poll和take区别

在Java中，poll和take都是用于从阻塞队列（如ArrayBlockingQueue、LinkedBlockingQueue等）中获取元素的方法，但它们之间有一些关键的区别。

1. poll方法：

   • poll是一个非阻塞方法。如果队列为空，它会立即返回null，不会等待元素被添加到队列中。
   • 如果队列非空，poll会从队列中取出并返回队首的元素。
   • poll方法可以接受一个超时参数，允许您指定等待的最大时间，如果在指定时间内队列仍然为空，它会返回null。

2. take方法：

   • take是一个阻塞方法。如果队列为空，它会阻塞当前线程，直到队列中有元素可用为止。
   • 当队列非空时，take会从队列中取出并返回队首的元素。
   • take方法不接受超时参数，因为它会一直等待，直到队列中有元素。

要点总结：

• 如果您希望立即获取队列中的元素（如果有的话），可以使用poll方法，而且它可以设置超时时间。
• 如果您希望在队列为空时阻塞线程，直到队列中有元素可用，应该使用take方法。

需要注意的是，使用这些方法时要根据具体的应用场景来选择。如果您想要避免线程阻塞，并且能够处理队列为空的情况，可以使用poll方法。如果您需要等待队列中有元素可用，然后立即获取它，应该使用take方法。

---

java.util.concurrent.ArrayBlockingQueue#poll()

/**
 * 出队(非阻塞)
 *
 * @return E
 * @author javaself
 */
public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //出队
        return (count == 0) ? null : dequeue();
    } finally {
        lock.unlock();
    }
}

ThreadPoolExecutor是使用poll还是take？

在ThreadPoolExecutor中，默认情况下使用的是take方法来从任务队列中获取任务。ThreadPoolExecutor是Java提供的一个灵活的线程池实现，它使用阻塞队列来管理待执行的任务。这意味着当线程池中没有可用的任务时，线程会被阻塞，直到有任务可供执行。

ThreadPoolExecutor使用的是阻塞队列的take方法，以确保在没有可用任务时，线程池中的工作线程会等待，直到有新的任务进入队列。这种方式可以避免不必要的忙等，节省系统资源，同时也能够在任务到达时立即执行。

但需要注意的是，ThreadPoolExecutor的行为可以通过构造函数中传递的不同参数进行配置。您可以选择不同的队列实现，如ArrayBlockingQueue、LinkedBlockingQueue等，以及设置核心线程数、最大线程数、拒绝策略等参数来适应不同的应用场景。如果您需要更具体的控制，您可以自定义队列实现，或者通过配置适当的参数来满足您的需求。

总之，ThreadPoolExecutor默认使用take方法从任务队列中获取任务，以便在没有可用任务时等待并阻塞线程。这种默认行为通常是适合大多数情况的，但在特定的需求下，您可以根据实际情况进行配置和调整。