JDK中有直接可以使用的阻塞佇列

gongchengship發表於2024-07-04
JDK佇列

是的，Java標準庫（JDK）中提供了多個阻塞佇列，可以直接使用。這些阻塞佇列位於java.util.concurrent包中。阻塞佇列是一種支援在某些操作無法立即完成時等待的佇列，例如在佇列為空時執行的take操作，或者在佇列已滿時執行的put操作。

以下是JDK中幾種常見的阻塞佇列及其特點：

1. ArrayBlockingQueue

ArrayBlockingQueue是一個基於陣列的有界阻塞佇列。其特點如下：

  • 固定大小（在建立時指定）。
  • FIFO（先進先出）順序。
  • 可以指定公平性策略，以確保等待的執行緒按FIFO順序訪問佇列。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ArrayBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        // Producer
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // Consumer
        new Thread(() -> {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

2. LinkedBlockingQueue

LinkedBlockingQueue是一個基於連結串列的可選有界阻塞佇列。其特點如下：

  • 可以指定大小，也可以預設大小（預設是Integer.MAX_VALUE）。
  • FIFO順序。
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class LinkedBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

        // Producer
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // Consumer
        new Thread(() -> {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

3. PriorityBlockingQueue

PriorityBlockingQueue是一個支援優先順序的無界阻塞佇列。其特點如下：

  • 元素按照其自然順序或者透過提供的比較器排序。
  • 沒有容量限制（無界）。
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class PriorityBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

        // Producer
        new Thread(() -> {
            try {
                for (int i = 10; i > 0; i--) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // Consumer
        new Thread(() -> {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

4. SynchronousQueue

SynchronousQueue是一個不儲存元素的阻塞佇列。每個插入操作必須等待相應的移除操作，反之亦然。其特點如下：

  • 不儲存元素。
  • 每個put操作必須等待一個take操作，反之亦然。
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.BlockingQueue;

public class SynchronousQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new SynchronousQueue<>();

        // Producer
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // Consumer
        new Thread(() -> {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

總結

Java的java.util.concurrent包中提供了多種阻塞佇列，包括ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue和SynchronousQueue，可以根據不同的使用場景選擇合適的阻塞佇列。這些佇列實現了流式處理，支援多執行緒環境下的高效資料傳輸和同步。

相關文章