【多线程】线程池中的队列有哪些，应该如何选择

在多线程编程中，线程池是一种非常常用的模式，它能够有效管理线程的创建和销毁，以提高系统的性能和资源利用率。在线程池中，任务通常被放置在一个队列中，等待线程去执行。常见的线程池队列主要有三种：无界队列、有界队列和优先级队列。选择合适的队列能有效影响到线程池的性能与响应能力。

1. 无界队列

无界队列最典型的实现是LinkedBlockingQueue。它不对队列的大小设限，可以无限地接收任务。这种队列的优点是提高了系统的吞吐量，能够快速接受大量的任务。但同时，因为没有上限，可能会导致内存消耗过高，甚至出现内存溢出的问题。

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class UnboundedQueueExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                5, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>()
        );

        for (int i = 0; i < 100; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Executing task " + taskId);
                try {
                    Thread.sleep(1000); // 模拟任务的执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        executor.shutdown();
    }
}

2. 有界队列

有界队列的典型实现是ArrayBlockingQueue，它在创建时指定了队列的大小限制。如果提交的任务数超过了这个限制，新的任务将被拒绝，抛出异常或者被阻塞，具体行为取决于线程池的拒绝策略。

使用有界队列可以有效防止系统因为任务积压而耗尽资源，因此在高负载的情况下，具有更好的稳定性。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class BoundedQueueExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10)
        );

        for (int i = 0; i < 100; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Executing task " + taskId);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        executor.shutdown();
    }
}

3. 优先级队列

优先级队列PriorityBlockingQueue允许任务按优先级排序，确保优先级高的任务优先执行，这在某些场景下是非常有用的，比如实时任务处理。

使用优先级队列时，任务需要实现Comparable接口，以便系统能够根据优先级进行排序。

import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class Task implements Comparable<Task> {
    private final int priority;
    private final String name;

    public Task(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public int compareTo(Task other) {
        return Integer.compare(this.priority, other.priority);
    }
}

public class PriorityQueueExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                5, 10, 60, TimeUnit.SECONDS, new PriorityBlockingQueue<Task>()
        );

        executor.execute(new Task(5, "Low priority task"));
        executor.execute(new Task(1, "High priority task"));
        executor.execute(new Task(3, "Medium priority task"));

        executor.shutdown();
    }
}

选择队列时的考虑因素

1. 任务特性：如果任务执行时间不定，考虑使用无界队列；若任务数量可控且预计较多，使用有界队列。
2. 系统稳定性：有界队列能有效控制内存消耗，适合需要高可用性的系统。
3. 优先级需求：如果任务需要按优先级执行，那么优先级队列是最佳选择。

总的来说，选择哪种队列经常依赖于应用场景、任务特点及对系统性能的需求。在实际开发中，开发者应综合考虑各种因素，以选出最合适的线程池队列类型。