Java Observer 如何实现延迟通知

在 Java 中，观察者模式（Observer Pattern）是一种行为设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象发生变化时，它会通知所有观察者对象。要实现延迟通知，可以使用以下方法：

1. 使用 ScheduledExecutorService：

ScheduledExecutorService 是一个用于执行延迟任务或定期任务的线程池。你可以使用它来实现延迟通知。首先，创建一个 ScheduledExecutorService 实例，然后使用 schedule 方法来安排一个延迟任务。在任务中，调用观察者的 update 方法来通知它们。

import java.util.concurrent.*;

public class DelayedNotificationObserverPattern {
    public static void main(String[] args) {
        // 创建一个观察者列表
        List<Observer> observers = new ArrayList<>();

        // 创建一个主题
        Subject subject = new Subject();

        // 将观察者添加到主题中
        observers.add(new ConcreteObserver("Observer 1"));
        observers.add(new ConcreteObserver("Observer 2"));

        // 注册观察者
        subject.registerObservers(observers);

        // 模拟主题发生变化
        subject.notifyObservers();

        // 创建一个 ScheduledExecutorService 实例
        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();

        // 安排一个延迟任务，2秒后通知观察者
        executorService.schedule(() -> {
            System.out.println("Delayed notification");
            subject.notifyObservers();
        }, 2, TimeUnit.SECONDS);

        // 关闭 ScheduledExecutorService
        executorService.shutdown();
    }
}

class Subject {
    private List<Observer> observers;

    public void registerObservers(List<Observer> observers) {
        this.observers = observers;
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

interface Observer {
    void update();
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update() {
        System.out.println(name + " received the delayed notification.");
    }
}

2. 使用 CompletableFuture：

CompletableFuture 是 Java 8 引入的一个功能强大的异步编程工具。你可以使用它来实现延迟通知。首先，创建一个 CompletableFuture 实例，然后使用 thenAccept 方法来安排一个延迟任务。在任务中，调用观察者的 update 方法来通知它们。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class DelayedNotificationObserverPattern {
    public static void main(String[] args) {
        // 创建一个观察者列表
        List<Observer> observers = new ArrayList<>();

        // 创建一个主题
        Subject subject = new Subject();

        // 将观察者添加到主题中
        observers.add(new ConcreteObserver("Observer 1"));
        observers.add(new ConcreteObserver("Observer 2"));

        // 注册观察者
        subject.registerObservers(observers);

        // 模拟主题发生变化
        subject.notifyObservers();

        // 创建一个 CompletableFuture 实例
        CompletableFuture.completedFuture(null)
                .thenAccept(() -> {
                    System.out.println("Delayed notification");
                    subject.notifyObservers();
                })
                .orTimeout(2, TimeUnit.SECONDS)
                .exceptionally(ex -> {
                    System.out.println("Delayed notification task failed");
                    return null;
                });
    }
}

class Subject {
    private List<Observer> observers;

    public void registerObservers(List<Observer> observers) {
        this.observers = observers;
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

interface Observer {
    void update();
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update() {
        System.out.println(name + " received the delayed notification.");
    }
}

这两种方法都可以实现延迟通知。你可以根据自己的需求和场景选择合适的方法。