在Java中，可以使用java.util.concurrent包中的BlockingQueue實現多線程共享隊列。

BlockingQueue是一個線程安全的隊列，它提供了多種方法來處理并發訪問的問題。常用的方法有：

• put(E e): 將元素添加到隊列的尾部，如果隊列已滿則阻塞等待。
• take(): 移除并返回隊列頭部的元素，如果隊列為空則阻塞等待。
• offer(E e): 將元素添加到隊列的尾部，如果隊列已滿則返回false。
• poll(): 移除并返回隊列頭部的元素，如果隊列為空則返回null。

以下是一個簡單的示例代碼：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class SharedQueueExample {
    public static void main(String[] args) {
        // 創建一個容量為10的阻塞隊列
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

        // 創建并啟動多個生產者線程
        for (int i = 0; i < 5; i++) {
            new Producer(queue).start();
        }

        // 創建并啟動一個消費者線程
        new Consumer(queue).start();
    }

    static class Producer extends Thread {
        private final BlockingQueue<Integer> queue;

        public Producer(BlockingQueue<Integer> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i); // 阻塞等待直到隊列有空閑位置
                    System.out.println("Produced: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class Consumer extends Thread {
        private final BlockingQueue<Integer> queue;

        public Consumer(BlockingQueue<Integer> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    int value = queue.take(); // 阻塞等待直到隊列有可用元素
                    System.out.println("Consumed: " + value);
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在上面的示例中，我們創建了一個容量為10的阻塞隊列queue，并創建了5個生產者線程和1個消費者線程。每個生產者線程會不斷向隊列中添加元素，而消費者線程會不斷從隊列中取出元素進行處理。

通過使用BlockingQueue，我們可以避免手動實現線程同步和等待/通知機制，簡化了多線程編程的復雜性。