java如何监听队列

Java 监听队列的方法有：使用阻塞队列、使用观察者模式、使用监听器接口。其中，使用阻塞队列 是一种常见且高效的方法。

一、使用阻塞队列

Java 提供了多种阻塞队列（如 ArrayBlockingQueue、LinkedBlockingQueue 等），这些阻塞队列可以自动阻塞在读取和写入操作上，直到有数据可用或空间可用。这种方式非常适合用于生产者-消费者模型。

1.1、阻塞队列的基本概念

阻塞队列（BlockingQueue）是一个线程安全的队列，它支持两个附加的操作：在队列为空时，线程尝试从队列中获取元素会被阻塞；在队列满时，线程尝试向队列中添加元素会被阻塞。阻塞队列被广泛用于生产者-消费者问题中，生产者线程向队列中添加元素，消费者线程从队列中获取元素。

1.2、使用 ArrayBlockingQueue

ArrayBlockingQueue 是一个基于数组的有界阻塞队列，通常用于需要有界的情况。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueExample {
    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) {
                Thread.currentThread().interrupt();
            }
        });
        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        producer.start();
        consumer.start();
    }
}

在上述代码中，生产者线程不断向队列中添加元素，而消费者线程不断从队列中获取元素。由于 BlockingQueue 自动处理了线程间的同步问题，因此代码中不需要显式地使用锁或其他同步机制。

1.3、使用 LinkedBlockingQueue

LinkedBlockingQueue 是基于链表的阻塞队列，通常用于需要无界的情况。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class LinkedBlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        producer.start();
        consumer.start();
    }
}

二、使用观察者模式

观察者模式是一种设计模式，其中一个对象（称为观察者）监听另一个对象（称为被观察者）的状态变化。这种模式也可以用于实现队列监听。

2.1、基本概念

观察者模式中，观察者注册到被观察者上，当被观察者的状态发生变化时，通知所有注册的观察者。Java 提供了 java.util.Observable 类和 java.util.Observer 接口来支持观察者模式。

2.2、实现观察者模式

import java.util.Observable;
import java.util.Observer;
class Queue extends Observable {
    private final java.util.Queue<Integer> queue = new java.util.LinkedList<>();
    public void add(int item) {
        queue.add(item);
        setChanged();
        notifyObservers(item);
    }
    public Integer remove() {
        return queue.poll();
    }
}
class QueueObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Queue changed: " + arg);
    }
}
public class ObserverPatternExample {
    public static void main(String[] args) {
        Queue queue = new Queue();
        QueueObserver observer = new QueueObserver();
        queue.addObserver(observer);
        queue.add(1);
        queue.add(2);
        queue.add(3);
    }
}

在上述代码中，Queue 类继承了 Observable 类，并在添加元素时通知所有注册的观察者。QueueObserver 类实现了 Observer 接口，并在 update 方法中处理队列的变化。

三、使用监听器接口

使用监听器接口也是一种常见的实现队列监听的方法。我们可以定义一个自定义的监听器接口，并在队列操作时调用监听器的方法。

3.1、定义监听器接口

首先，我们定义一个监听器接口，包含队列变化时的回调方法。

interface QueueListener {
    void onItemAdded(int item);
}

3.2、实现监听器接口

接下来，我们实现监听器接口，并在队列操作时调用监听器的方法。

import java.util.LinkedList;
class QueueWithListener {
    private final java.util.Queue<Integer> queue = new LinkedList<>();
    private QueueListener listener;
    public void setQueueListener(QueueListener listener) {
        this.listener = listener;
    }
    public void add(int item) {
        queue.add(item);
        if (listener != null) {
            listener.onItemAdded(item);
        }
    }
    public Integer remove() {
        return queue.poll();
    }
}
class QueueListenerImpl implements QueueListener {
    @Override
    public void onItemAdded(int item) {
        System.out.println("Item added to queue: " + item);
    }
}
public class ListenerPatternExample {
    public static void main(String[] args) {
        QueueWithListener queue = new QueueWithListener();
        QueueListenerImpl listener = new QueueListenerImpl();
        queue.setQueueListener(listener);
        queue.add(1);
        queue.add(2);
        queue.add(3);
    }
}

在上述代码中，QueueWithListener 类包含一个 QueueListener 接口的实例，当添加元素时，如果监听器不为空，则调用监听器的 onItemAdded 方法。QueueListenerImpl 类实现了 QueueListener 接口，并在 onItemAdded 方法中处理队列的变化。

四、总结

在 Java 中，可以使用多种方式来监听队列的变化。使用阻塞队列 是一种高效且简洁的方法，适用于生产者-消费者模型。使用观察者模式 可以实现更灵活的队列监听，但需要额外的代码来管理观察者。使用监听器接口 是一种自定义的监听方法，适用于需要更高定制化的场景。

无论选择哪种方法，关键在于理解每种方法的优缺点，并根据具体的应用场景选择最合适的方法。希望这篇文章能够帮助你更好地理解 Java 中监听队列的方法，并在实际开发中应用这些知识。