1.使用异步通知：观察者接收到通知后，不立即更新自己的状态，而是将更新操作放到消息队列中，等待异步执行。这样就可以避免观察者之间的阻塞，提高了系统的性能。 2.改变通知策略：可以通过改变通知策路来减少通知顷率。例如，可以采用延迟通知，即等待一段时间后再通知观察者：或者采用累积通知，即等待多个状态变化后再通知观察者。给出示例

1. 使用异步通知的示例：

假设我们有一个网站，需要实时更新用户的购物车信息。当用户添加商品到购物车时，我们可以采用观察者模式来通知所有相关的观察者。但是，如果我们同步执行所有的观察者，会导致系统的性能下降。因此，我们可以采用异步通知的方式，将更新操作放入消息队列中，等待异步执行。

具体实现可以参考以下代码：

class ShoppingCart {
    private List<Product> products = new ArrayList<>();
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void addProduct(Product product) {
        products.add(product);
        notifyObservers();
    }

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

    public List<Product> getProducts() {
        return products;
    }
}

class ShoppingCartObserver implements Observer {
    private ShoppingCart shoppingCart;

    public ShoppingCartObserver(ShoppingCart shoppingCart) {
        this.shoppingCart = shoppingCart;
        shoppingCart.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        // 将更新操作放入消息队列中，等待异步执行
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(() -> {
            List<Product> products = shoppingCart.getProducts();
            // 更新购物车信息
            // ...
        });
    }
}

在上述代码中，当用户添加商品到购物车时，我们会调用 `notifyObservers()` 方法来通知所有相关的观察者。在 `ShoppingCartObserver` 中，我们将更新操作放入了一个线程池中，等待异步执行。

2. 改变通知策略的示例：

假设我们有一个系统，需要实时展示股票的价格变化。我们可以采用观察者模式来实现，每当股票价格发生变化时，通知所有相关的观察者。但是，如果股票价格变化频繁，会导致观察者接收到大量的通知，影响系统性能。因此，我们可以采用改变通知策略的方式，减少通知频率。

具体实现可以参考以下代码：

class Stock {
    private String name;
    private double price;
    private List<Observer> observers = new ArrayList<>();

    public Stock(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void setPrice(double price) {
        // 如果价格变化超过 1%，才通知观察者
        if (Math.abs(price - this.price) / this.price > 0.01) {
            this.price = price;
            notifyObservers();
        }
    }

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

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

class StockObserver implements Observer {
    private Stock stock;

    public StockObserver(Stock stock) {
        this.stock = stock;
        stock.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        // 更新股票价格
        // ...
    }
}

在上述代码中，我们在 `Stock` 类中设置了一个阈值，当股票价格变化超过 1% 时，才通知观察者。这样可以避免观察者接收到过多的通知，提高系统性能。