如何实现类似WM_POSTMESSAGE的跨类无等待自定义事件/方法调用？

Great question! Implementing non-blocking cross-class calls—mirroring how WM_POSTMESSAGE queues messages in Windows and lets the sender keep running immediately— is a super common scenario. Let’s walk through actionable approaches you can use in Class A’s method to pull this off.

Core Concept #

Just like WM_POSTMESSAGE adds a message to the OS’s message queue and doesn’t wait for a reply, we need a way to queue a task or message for the target class (let’s call it Class B) to handle later, without blocking Class A’s execution flow.

Practical Implementation Methods #

1. Custom Thread-Safe Message Queue (Closest to WM_POSTMESSAGE) #

This approach directly mimics the Windows message queue pattern. We’ll create a queue that Class B monitors on a dedicated worker thread, and Class A adds messages/tasks to it—no waiting required.

Example Code (C++):

// Define a structure to hold your message details
struct CustomMessage {
    enum Type { InvokeMethodX, TriggerCustomEvent };
    Type messageType;
    // Add any parameters your methods need
    int intParam;
    std::string stringParam;
};

// Class B (the receiver that processes messages)
class ClassB {
private:
    std::queue<CustomMessage> messageQueue;
    std::mutex queueMutex;
    std::condition_variable queueCV;
    bool isRunning = true;

    // Worker thread to process queued messages
    void messageProcessor() {
        while (isRunning) {
            std::unique_lock<std::mutex> lock(queueMutex);
            // Wait until there's a message or we need to shut down
            queueCV.wait(lock, [this]() { return !messageQueue.empty() || !isRunning; });

            if (!isRunning) break;

            // Grab the next message and release the lock early
            auto msg = messageQueue.front();
            messageQueue.pop();
            lock.unlock();

            // Process the message based on its type
            switch(msg.messageType) {
                case CustomMessage::InvokeMethodX:
                    this->methodX(msg.intParam, msg.stringParam);
                    break;
                case CustomMessage::TriggerCustomEvent:
                    this->fireCustomEvent();
                    break;
            }
        }
    }

public:
    ClassB() {
        // Start the worker thread when Class B is initialized
        std::thread(&ClassB::messageProcessor, this).detach();
    }

    ~ClassB() {
        // Clean up the worker thread safely
        std::lock_guard<std::mutex> lock(queueMutex);
        isRunning = false;
        queueCV.notify_one();
    }

    // Method for Class A to send non-blocking messages
    void postMessage(CustomMessage msg) {
        std::lock_guard<std::mutex> lock(queueMutex);
        messageQueue.push(msg);
        queueCV.notify_one(); // Wake up the worker thread
    }

    // The actual methods Class A wants to trigger
    void methodX(int p1, std::string p2) {
        std::cout << "Class B's methodX called with: " << p1 << ", " << p2 << std::endl;
    }

    void fireCustomEvent() {
        std::cout << "Class B triggered its custom event!" << std::endl;
    }
};

// Class A (the sender)
class ClassA {
private:
    ClassB* targetClassB;

public:
    ClassA(ClassB* bInstance) : targetClassB(bInstance) {}

    void someMethod() {
        // Do your initial work in Class A...

        // Send a non-blocking message to Class B
        CustomMessage msg;
        msg.messageType = CustomMessage::InvokeMethodX;
        msg.intParam = 42;
        msg.stringParam = "Hello from Class A!";
        targetClassB->postMessage(msg);

        // Class A continues executing immediately—no waiting!
        std::cout << "Class A is already moving on to the next task." << std::endl;
    }
};

2. Asynchronous Task Dispatch (Modern Languages) #

If you don’t need a full message queue, most modern languages have built-in async utilities to offload the call to a background thread. This is simpler for one-off fire-and-forget calls.

C++ Example with std::async:

class ClassA {
private:
    ClassB* targetClassB;

public:
    ClassA(ClassB* bInstance) : targetClassB(bInstance) {}

    void someMethod() {
        // Do work in Class A...

        // Fire-and-forget async call to Class B's method
        std::async(std::launch::async, &ClassB::methodX, targetClassB, 100, "Async call!");

        // Class A keeps running right away
        std::cout << "Class A doesn't wait for the async call to finish." << std::endl;
    }
};

Heads up: Make sure Class B’s lifetime outlasts the async task—if Class B gets destroyed while the task runs, you’ll hit undefined behavior.

3. Observer Pattern + Async Event Dispatch #

If you’re working with custom events (instead of direct method calls), combine the observer pattern with async execution to dispatch events without blocking.

Example:

// Define the event handler type
using CustomEventHandler = std::function<void(int)>;

class EventEmitter {
private:
    std::vector<CustomEventHandler> eventHandlers;

public:
    // Let classes like Class B subscribe to the event
    void subscribe(CustomEventHandler handler) {
        eventHandlers.push_back(handler);
    }

    // Dispatch the event asynchronously (non-blocking)
    void fireEvent(int eventData) {
        for (auto& handler : eventHandlers) {
            std::async(std::launch::async, handler, eventData);
        }
    }
};

// Class B subscribes to the event
class ClassB {
public:
    void onEventReceived(int data) {
        std::cout << "Class B received event data: " << data << std::endl;
    }
};

// Class A triggers the event
class ClassA {
private:
    EventEmitter* eventSource;

public:
    ClassA(EventEmitter* emitter) : eventSource(emitter) {}

    void someMethod() {
        // Do work in Class A...

        // Fire the event without waiting for handlers to finish
        eventSource->fireEvent(789);

        // Class A continues execution immediately
        std::cout << "Class A moves on after firing the event." << std::endl;
    }
};

Key Things to Keep in Mind #

• Thread Safety: If Class B’s methods are accessed from multiple threads (like the worker thread or async task), ensure they’re thread-safe with mutexes, atomic variables, or other synchronization tools.
• Lifetime Management: Always make sure the target object (Class B) doesn’t get deleted before the queued task or async call completes—use smart pointers or lifetime checks if needed.
• Error Handling: Since this is fire-and-forget, the caller (Class A) won’t get error feedback directly. Add logging or a separate error reporting mechanism in Class B to catch issues.

内容的提问来源于stack exchange，提问作者Daniel Kaplan