C++观察者模式实战：从原理到现代实现优化

1. 观察者模式概述

观察者模式是《Head First设计模式》中最经典的模式之一，也是我在实际C++项目中应用最频繁的设计模式。它定义了对象之间的一对多依赖关系，当一个对象（被观察者）状态发生改变时，所有依赖它的对象（观察者）都会自动收到通知并更新。

我在一个实时数据监控系统中首次应用这个模式时，发现它完美解决了数据源与多个显示模块之间的动态耦合问题。比如当温度传感器数据变化时，需要同时更新曲线图、数字面板和报警器三个UI组件，而观察者模式让这种需求变得异常简单。

2. 模式结构与C++实现

2.1 经典UML结构解析

观察者模式包含两个核心角色：

• Subject（被观察者）：维护观察者列表，提供注册/注销接口，通知观察者
• Observer（观察者）：定义更新接口，供Subject调用

在C++中，我通常这样实现基础框架：

cpp复制// 观察者基类
class Observer {
public:
    virtual ~Observer() = default;
    virtual void update(float temp, float humidity) = 0;
};

// 被观察者基类
class Subject {
public:
    virtual ~Subject() = default;
    virtual void registerObserver(Observer* o) = 0;
    virtual void removeObserver(Observer* o) = 0;
    virtual void notifyObservers() = 0;
};

2.2 具体实现示例

以气象站为例，这是我在项目中实际使用的WeatherData实现：

cpp复制class WeatherData : public Subject {
private:
    std::vector<Observer*> observers;
    float temperature;
    float humidity;

public:
    void registerObserver(Observer* o) override {
        observers.push_back(o);
    }

    void removeObserver(Observer* o) override {
        observers.erase(std::remove(observers.begin(), 
                                  observers.end(), o), 
                      observers.end());
    }

    void notifyObservers() override {
        for (auto* o : observers) {
            o->update(temperature, humidity);
        }
    }

    void measurementsChanged() {
        notifyObservers();
    }

    void setMeasurements(float temp, float humidity) {
        this->temperature = temp;
        this->humidity = humidity;
        measurementsChanged();
    }
};

3. 现代C++的改进实现

3.1 使用智能指针管理生命周期

原始实现中观察者的生命周期管理是个隐患。在我的实践中，改用shared_ptr/weak_ptr组合：

cpp复制class ModernSubject {
private:
    std::vector<std::weak_ptr<Observer>> observers;

public:
    void registerObserver(std::shared_ptr<Observer> o) {
        observers.emplace_back(o);
    }

    void notifyObservers() {
        auto it = observers.begin();
        while (it != observers.end()) {
            if (auto o = it->lock()) {
                o->update(data);
                ++it;
            } else {
                it = observers.erase(it);
            }
        }
    }
};

3.2 使用std::function实现通用观察者

C++11之后，我更喜欢用std::function替代接口继承：

cpp复制class EventSubject {
    using Callback = std::function<void(float, float)>;
    std::vector<Callback> callbacks;

public:
    void registerObserver(Callback cb) {
        callbacks.push_back(cb);
    }

    void notifyObservers(float temp, float humidity) {
        for (auto& cb : callbacks) {
            cb(temp, humidity);
        }
    }
};

4. 实际应用中的经验技巧

4.1 避免通知风暴的三种策略

在实时系统中，不加控制的观察者通知会导致性能问题。我的解决方案：

1. 节流通知：积累变化，定时批量通知

cpp复制void onSensorUpdate() {
    dirty = true;
    // 每100ms检查一次
    if (!timerRunning) {
        startTimer(100ms);
    }
}

void onTimer() {
    if (dirty) {
        notifyObservers();
        dirty = false;
    }
}

2. 差分通知：仅当数据变化超过阈值时通知

cpp复制void setMeasurements(float temp, float humidity) {
    if (abs(temp - temperature) > 0.5 || 
        abs(humidity - this->humidity) > 1.0) {
        this->temperature = temp;
        this->humidity = humidity;
        notifyObservers();
    }
}

3. 优先级队列：按观察者优先级顺序通知

4.2 线程安全实现方案

在多线程环境中，我通常采用以下模式：

cpp复制class ThreadSafeSubject {
    std::vector<std::weak_ptr<Observer>> observers;
    mutable std::mutex mtx;

public:
    void registerObserver(std::shared_ptr<Observer> o) {
        std::lock_guard<std::mutex> lock(mtx);
        observers.emplace_back(o);
    }

    void notifyObservers() {
        std::vector<std::shared_ptr<Observer>> validObservers;
        {
            std::lock_guard<std::mutex> lock(mtx);
            for (auto it = observers.begin(); it != observers.end(); ) {
                if (auto o = it->lock()) {
                    validObservers.push_back(o);
                    ++it;
                } else {
                    it = observers.erase(it);
                }
            }
        }
        
        for (auto& o : validObservers) {
            o->update(data);
        }
    }
};

5. 典型问题与解决方案

5.1 循环引用问题

当观察者同时持有Subject引用时，会导致内存泄漏。我的解决方法：

cpp复制// 错误示例：相互持有shared_ptr
class BadObserver : public Observer {
    std::shared_ptr<Subject> subject;  // 循环引用！
};

// 正确做法：使用weak_ptr打破循环
class SafeObserver : public Observer {
    std::weak_ptr<Subject> subject;
};

5.2 更新顺序依赖

某些观察者可能有执行顺序要求。我的排序方案：

cpp复制void WeatherData::registerObserver(Observer* o, int priority) {
    observers.insert(std::upper_bound(
        observers.begin(), observers.end(), priority,
        [](int val, auto&& item) { 
            return val < item.priority; 
        }),
        {o, priority}
    );
}

5.3 死锁预防

在复杂回调场景中，我遵循以下原则：

1. 不要在观察者回调中执行可能阻塞的操作
2. 保持锁的粒度尽可能小
3. 使用std::recursive_mutex处理嵌套调用

6. 模式变体与扩展应用

6.1 推模型 vs 拉模型

经典实现是推模型（Subject主动推送数据），但有时拉模型更合适：

cpp复制class PullObserver {
public:
    virtual void update(Subject* subject) = 0;
};

void WeatherData::notifyObservers() {
    for (auto o : observers) {
        o->update(this);  // 观察者自己拉取需要的数据
    }
}

6.2 事件总线实现

基于观察者模式，我构建过简单的事件总线系统：

cpp复制class EventBus {
    std::unordered_map<EventType, 
                      std::vector<EventHandler>> handlers;

public:
    void subscribe(EventType type, EventHandler handler) {
        handlers[type].push_back(handler);
    }

    void publish(const Event& event) {
        for (auto& handler : handlers[event.type]) {
            handler(event.data);
        }
    }
};

6.3 与反应式编程结合

现代C++中，观察者模式可以很自然地与RxCpp等库结合：

cpp复制auto subject = rxcpp::subjects::subject<float>();
auto observable = subject.get_observable();

// 订阅
auto subscription = observable.subscribe(
    [](float temp) { /* 处理数据 */ },
    []() { /* 完成处理 */ }
);

// 发布
subject.get_subscriber().on_next(23.5f);

7. 性能优化实践

7.1 内存分配优化

频繁的观察者注册/注销会导致内存分配。我的优化方案：

1. 使用对象池预分配观察者
2. 采用tbb::concurrent_vector替代std::vector
3. 实现无锁队列用于高频更新场景

cpp复制class HighPerformanceSubject {
    moodycamel::ConcurrentQueue<Observer*> observers;
    
public:
    void notifyObservers() {
        Observer* observer;
        while (observers.try_dequeue(observer)) {
            observer->update(data);
            // 处理完后回收观察者
            observerPool.release(observer);
        }
    }
};

7.2 批量通知机制

对于大量观察者，我采用分批通知策略：

cpp复制void batchNotify() {
    const size_t batchSize = 10;
    auto it = observers.begin();
    
    while (it != observers.end()) {
        std::vector<Observer*> batch;
        for (size_t i = 0; i < batchSize && it != observers.end(); ++i, ++it) {
            if (auto o = it->lock()) {
                batch.push_back(o.get());
            }
        }
        
        // 并行处理批次
        std::for_each(std::execution::par, batch.begin(), batch.end(),
            [](auto o) { o->update(data); });
    }
}

8. 测试与调试技巧

8.1 单元测试模式

我为观察者模式设计了专门的测试夹具：

cpp复制TEST(ObserverPattern, NotificationTest) {
    WeatherData weather;
    MockObserver obs1, obs2;
    
    weather.registerObserver(&obs1);
    weather.registerObserver(&obs2);
    
    EXPECT_CALL(obs1, update(23.0f, 65.0f)).Times(1);
    EXPECT_CALL(obs2, update(23.0f, 65.0f)).Times(1);
    
    weather.setMeasurements(23.0f, 65.0f);
}

8.2 调试观察者泄漏

使用自定义删除器追踪观察者生命周期：

cpp复制template<typename T>
struct DebugDeleter {
    void operator()(T* p) {
        std::cout << "Deleting observer @" << p << "\n";
        delete p;
    }
};

using DebugObserverPtr = std::unique_ptr<Observer, DebugDeleter<Observer>>;

8.3 性能剖析要点

关键指标检查清单：

1. 单次通知延迟（P99值）
2. 内存占用与观察者数量关系
3. 多线程竞争情况下的吞吐量
4. 注册/注销操作的耗时