해설 — 이벤트 버스 디스패치 중 구독 해제 경합

난이도: 최상

요약

EventBus::Publish 는 listeners_[eventName] 이 가리키는 std::vector<IEventListener*> 를 범위 기반 for 로 순회하며 각 리스너의 OnEvent 를 호출한다. 이 리스너들은 raw 포인터로만 등록되어 있어(A) EventBus 는 리스너의 생존 여부를 전혀 알지 못한다. 리스너 콜백 안에서 자기 자신을 구독 해제하거나, 다른 스레드가 Unsubscribe(B)로 벡터를 변형하면 순회 중인 반복자가 무효화되어 정의되지 않은 동작(잘못된 메모리 접근, 다음 리스너를 건너뜀 또는 중복 호출)이 발생한다. 더 심각한 것은, 어떤 모듈이 소멸자에서 자신을 Unsubscribe 하도록 되어 있다는 전제에서, 그 Unsubscribe 호출 자체가 아직 일어나지 않은 상태로 객체가 먼저 파괴되면 listeners_ 에는 이미 죽은 객체를 가리키는 댕글링 포인터가 남고, 다음 Publish 가 그 포인터로 가상 함수(OnEvent)를 호출해 use-after-free 로 이어진다.

문제점

• 분류: 반복자 무효화(iterator invalidation) + 메모리 안전성(use-after-free / dangling pointer)
• 증상:
  1. 리스너 콜백 안에서 bus->Unsubscribe(eventName, this) 를 호출하는 일회성 리스너 패턴을 쓰면, Publish 의 for (IEventListener* listener : it->second) 순회 도중 벡터의 원소가 제거되어 범위 기반 for 의 내부 반복자가 무효화된다 — 이후 반복에서 정의되지 않은 동작이 발생한다(스킵, 재방문, 크래시 등 컴파일러/구현에 따라 다양하게 나타난다).
  2. 어떤 모듈 객체가 소멸될 때 Unsubscribe 를 호출하는 것을 잊었거나, 소멸과 Unsubscribe 사이에 다른 스레드가 끼어들어 Publish 가 먼저 그 포인터로 접근하면, 이미 해제된 메모리에 대해 가상 함수를 호출하는 use-after-free 가 발생한다 — 크래시로 바로 드러날 수도 있고, 운이 나쁘면 해제된 메모리가 재사용되어 엉뚱한 객체의 메서드가 호출되는 조용한 오동작으로 나타날 수도 있다.
• 재현 조건: (1) 단일 스레드 — 리스너 A 의 OnEvent 안에서 bus.Unsubscribe(eventName, this) 호출 후 Publish 실행. (2) 멀티스레드/수명 — 스레드 T1 이 Publish 를 순회하는 동안 스레드 T2 가 리스너 객체를 delete 하거나, 리스너가 소멸되면서 Unsubscribe 를 호출하려는 순간과 겹침.
• 근본 원인:
  • (A) Subscribe 가 리스너의 수명을 전혀 추적하지 않는 raw 포인터를 그대로 저장한다. EventBus 입장에서 그 포인터가 여전히 유효한 객체를 가리키는지 알 방법이 없다.
  • (B) Unsubscribe 가 동기화 없이 벡터를 즉시 변형하며, 이 변형과 Publish 의 순회 사이에 어떤 순서 보장도 없다. 벡터 순회 중 벡터 자체가 변경되는 것과, 순회 중인 포인터가 가리키는 객체가 파괴되는 것, 두 가지 서로 다른 위험이 겹쳐 있다.

수정안

(1) 순회는 스냅샷(복사본)으로 하고 락으로 벡터 변경과의 경합을 없애 반복자 무효화를 방지한다. (2) 리스너 수명 문제는 raw 포인터 대신 std::weak_ptr 로 추적해, 이미 파괴된 리스너는 lock() 실패로 자연스럽게 걸러지도록 해 use-after-free 를 원천 차단한다.

#include <algorithm>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>

class IEventListener
{
public:
    virtual void OnEvent(const std::string& eventName, void* payload) = 0;
    virtual ~IEventListener() = default;
};

class EventBus
{
public:
    // 리스너는 shared_ptr 로 소유권이 관리되어야 하고, EventBus 는 그 수명에
    // 관여하지 않는 weak_ptr 만 보관한다 — 리스너가 파괴되면 weak_ptr 은
    // 자동으로 무효화되어 댕글링 포인터로 남지 않는다.
    void Subscribe(const std::string& eventName, const std::shared_ptr<IEventListener>& listener)
    {
        std::lock_guard<std::mutex> lock(mutex_);
        listeners_[eventName].push_back(listener);
    }

    void Unsubscribe(const std::string& eventName, const std::shared_ptr<IEventListener>& listener)
    {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = listeners_.find(eventName);
        if (it == listeners_.end())
            return;

        auto& list = it->second;
        list.erase(
            std::remove_if(list.begin(), list.end(),
                [&listener](const std::weak_ptr<IEventListener>& w) {
                    return w.lock() == listener;
                }),
            list.end());
    }

    void Publish(const std::string& eventName, void* payload)
    {
        std::vector<std::weak_ptr<IEventListener>> snapshot;
        {
            std::lock_guard<std::mutex> lock(mutex_);
            auto it = listeners_.find(eventName);
            if (it == listeners_.end() || it->second.empty())
                return;

            // 락 안에서 스냅샷을 뜬다 — 이후 콜백은 락 밖에서 이 복사본만
            // 순회하므로, 콜백 도중 원본 벡터가 바뀌어도 반복자 무효화가
            // 일어나지 않는다.
            snapshot = it->second;
        }

        for (const auto& weakListener : snapshot)
        {
            // 이미 파괴된 리스너는 lock() 이 nullptr 을 반환해 자연스럽게
            // 건너뛴다 — use-after-free 가 원천적으로 발생하지 않는다.
            if (auto listener = weakListener.lock())
            {
                listener->OnEvent(eventName, payload);
            }
        }
    }

private:
    std::mutex mutex_;
    std::unordered_map<std::string, std::vector<std::weak_ptr<IEventListener>>> listeners_;
};

더 나은 설계

• weak_ptr + 락 + 스냅샷(채택안): 리스너 수명 문제(use-after-free)와 순회 중 변경 문제(반복자 무효화)를 동시에 해결한다. 리스너를 shared_ptr 로 관리해야 하므로 리스너 소유권 모델을 EventBus 도입 시점에 함께 정리해야 하는 비용이 있다.
• RAII 구독 핸들(scoped subscription): Subscribe 가 "구독 취소 토큰" 객체(소멸자에서 자동으로 Unsubscribe 를 호출)를 반환하도록 하면, 리스너가 명시적으로 Unsubscribe 를 호출하는 것을 잊는 실수 자체를 방지할 수 있다. weak_ptr 방식과 함께 쓰면 이중 방어가 된다.
• Copy-on-Write 벡터: Subscribe/Unsubscribe 가 항상 새 벡터를 만들어 std::atomic<std::shared_ptr<const std::vector<...>>> 로 원자적으로 교체하고, Publish 는 락 없이 그 시점의 스냅샷 포인터만 로드해 순회한다. 발행이 압도적으로 잦은 이벤트 버스에서 락 경합 자체를 없앨 수 있지만, shared_ptr 원자 연산의 플랫폼별 성능 특성을 이해해야 하고 구현 난이도가 가장 높다.
• 트레이드오프: weak_ptr 방식은 리스너를 반드시 shared_ptr 로 관리해야 한다는 제약이 생기지만(기존에 raw 포인터/스택 객체로 리스너를 만들던 코드는 리팩터링이 필요), 수명 안전성을 컴파일러가 아니라 런타임에서라도 명확하게 보장받을 수 있어 이벤트 버스처럼 콜백 타이밍이 불확실한 구조에는 가장 안전한 선택이다.

면접 포인트

• C++ 에서 콜백/리스너 패턴을 raw 포인터로 구현하면, "그 포인터가 가리키는 객체가 아직 살아있는가"를 호출하는 쪽(EventBus)이 알 방법이 없다는 근본적 한계가 있다 — weak_ptr 은 "약한 참조"를 통해 이 질문에 안전하게 답할 수 있게 해주는 표준 도구임을 설명할 수 있어야 한다.
• 반복자 무효화(컨테이너 구조 변경)와 use-after-free(가리키는 객체 자체의 파괴)는 서로 다른 문제이지만 이벤트 버스처럼 "콜백이 임의의 코드를 실행할 수 있는" 구조에서는 흔히 함께 나타난다 — 두 문제를 구분해서 각각의 해법(스냅샷 vs weak_ptr)을 짝지어 설명할 수 있어야 한다.
• 스냅샷을 뜨는 비용(벡터 복사, shared_ptr 참조 카운트 증가)과 락 경합 감소 사이의 트레이드오프, 그리고 이를 Copy-on-Write 로 더 밀어붙일 때의 복잡도 상승을 실제 발행 빈도에 맞춰 논할 수 있어야 한다.