Java queue如何设置大小

Java Queue 设置大小的方法包括：使用带有容量限制的队列实现、设置阻塞队列、使用包装类。

其中，使用带有容量限制的队列实现 是最常用和最有效的方法之一。Java 提供了几种内置的队列实现，如 ArrayBlockingQueue 和 LinkedBlockingQueue，这些类允许我们在构造函数中指定队列的最大容量。这种方式不仅简单直观，而且能够有效防止队列无限制地增长，从而避免内存溢出的问题。下面我们将详细探讨这些方法，并提供相关的示例代码。

一、使用带有容量限制的队列实现

Java 提供了一些内置的队列类，这些类在构造时可以指定容量限制。常见的有 ArrayBlockingQueue 和 LinkedBlockingQueue。

1、ArrayBlockingQueue

ArrayBlockingQueue 是一个基于数组实现的有界阻塞队列。在创建该队列时，我们必须指定其容量。这意味着队列不能存储超过其容量的元素。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10); // 队列容量为10
        for (int i = 0; i < 10; i++) {
            try {
                queue.put(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Queue is full, size: " + queue.size());
    }
}

在这个例子中，我们创建了一个 ArrayBlockingQueue，其容量为10。当我们尝试添加第11个元素时，put 方法将阻塞，直到队列中有空间。

2、LinkedBlockingQueue

LinkedBlockingQueue 是一个基于链表实现的有界阻塞队列。与 ArrayBlockingQueue 类似，我们可以在创建时指定其容量。

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10); // 队列容量为10
        for (int i = 0; i < 10; i++) {
            try {
                queue.put(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Queue is full, size: " + queue.size());
    }
}

与 ArrayBlockingQueue 不同，LinkedBlockingQueue 的内部实现是基于链表的，这使得它在某些情况下性能更好。

二、设置阻塞队列

阻塞队列是 Java 中非常有用的一种队列实现，它们允许我们在队列满时阻塞 put 操作，在队列空时阻塞 take 操作。这些队列通过实现 BlockingQueue 接口来提供这些功能。

1、使用 `BlockingQueue` 接口

BlockingQueue 接口包含了一些方法，如 put 和 take，它们会在必要时阻塞。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        producer.start();
        consumer.start();
    }
}

在这个例子中，我们创建了一个生产者线程和一个消费者线程。生产者线程尝试向队列中添加20个元素，而消费者线程尝试从队列中取出20个元素。由于队列的容量限制，生产者线程在队列满时会阻塞，直到消费者线程从队列中取出元素。

2、使用 `SynchronousQueue`

SynchronousQueue 是一种特殊类型的阻塞队列，它没有容量。每个 put 操作必须等待一个 take 操作，反之亦然。

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.BlockingQueue;
public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new SynchronousQueue<>();
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        producer.start();
        consumer.start();
    }
}

在这个例子中，每个生产者的 put 操作必须等待消费者的 take 操作。这种队列通常用于传递单个元素，在高并发环境中性能很高。

三、使用包装类

在某些情况下，我们可能需要对现有的队列进行包装，以添加容量限制。我们可以使用自定义的包装类来实现这一功能。

1、自定义包装类

我们可以创建一个自定义的包装类，该类包含一个队列实例，并在添加元素时检查队列的大小。

import java.util.Queue;
import java.util.LinkedList;
public class BoundedQueue<T> {
    private final Queue<T> queue;
    private final int maxSize;
    public BoundedQueue(int maxSize) {
        this.queue = new LinkedList<>();
        this.maxSize = maxSize;
    }
    public synchronized boolean add(T element) {
        if (queue.size() >= maxSize) {
            return false;
        }
        return queue.add(element);
    }
    public synchronized T poll() {
        return queue.poll();
    }
    public synchronized int size() {
        return queue.size();
    }
}

在这个例子中，我们创建了一个 BoundedQueue 类，该类在添加元素时检查队列的大小。如果队列已满，add 方法将返回 false，否则将添加元素。

public class Main {
    public static void main(String[] args) {
        BoundedQueue<Integer> queue = new BoundedQueue<>(10);
        for (int i = 0; i < 12; i++) {
            if (queue.add(i)) {
                System.out.println("Added: " + i);
            } else {
                System.out.println("Queue is full, cannot add: " + i);
            }
        }
        System.out.println("Final queue size: " + queue.size());
    }
}

在这个例子中，我们创建了一个 BoundedQueue 实例，其容量为10。当我们尝试添加第11个和第12个元素时，add 方法将返回 false，并输出相应的消息。

2、使用 `Collections.synchronizedList`

我们还可以使用 Collections.synchronizedList 方法来创建一个线程安全的列表，并手动检查列表的大小来实现容量限制。

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
public class Main {
    public static void main(String[] args) {
        List<Integer> list = Collections.synchronizedList(new ArrayList<>());
        int maxSize = 10;
        for (int i = 0; i < 12; i++) {
            synchronized (list) {
                if (list.size() < maxSize) {
                    list.add(i);
                    System.out.println("Added: " + i);
                } else {
                    System.out.println("List is full, cannot add: " + i);
                }
            }
        }
        System.out.println("Final list size: " + list.size());
    }
}

在这个例子中，我们创建了一个线程安全的列表，并在添加元素时手动检查列表的大小。如果列表已满，我们将输出相应的消息。

四、总结

在本文中，我们探讨了在 Java 中设置队列大小的几种方法。使用带有容量限制的队列实现 是最常用的方法，因为它简单直观，并且内置了所有必要的功能。设置阻塞队列 提供了更高级的功能，如在队列满时阻塞 put 操作，这对于并发编程非常有用。使用包装类 和 Collections.synchronizedList 是一些更灵活的方法，适用于需要对现有队列进行包装的情况。

无论选择哪种方法，关键在于理解每种方法的优缺点，并根据具体需求选择最合适的方案。希望这篇文章能够帮助你更好地理解如何在 Java 中设置队列的大小，并为你的项目选择合适的解决方案。