Windows 上，消息队列怎么实现？

消息队列是实现异步通信的一种常见方式，它允许在不同的线程之间传递信息或任务。在 C++ 中，消息队列通常用于处理线程间的异步任务或事件，特别是在需要解耦和异步操作的场景中。可以通过多种方法来实现消息队列，如使用操作系统提供的机制（Windows 消息队列、事件、信号量等）或者通过自定义的消息队列类来实现。

1. 使用 Windows 消息队列

Windows 操作系统本身提供了强大的消息机制。可以利用 Windows 消息循环 或 消息队列 来实现线程间的通信。特别是在 GUI 应用程序中，消息队列被广泛用于线程间的异步通信。

示例：使用 Windows 消息队列

在 Windows 环境下，可以使用 PostMessage 或 SendMessage 将消息放入队列，并由窗口的消息循环进行处理。

步骤：

1. 使用 PostMessage 将消息发送到窗口的消息队列。
2. 在窗口的消息循环中接收并处理这些消息。

示例代码：

#include <windows.h>
#include <iostream>

// 消息处理函数
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    if (uMsg == WM_USER_MESSAGE) {
        // wParam 现在是 LPCWSTR 类型，所以它可以直接处理
        std::wcout << L"Received message: " << (LPCWSTR)wParam << std::endl;
        return 0;
    }
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

void SendMessageToQueue(HWND hwnd, LPCWSTR message) {
    PostMessage(hwnd, WM_USER_MESSAGE, (WPARAM)message, 0);
}

int main() {
    WNDCLASS wc = {0};
    wc.lpfnWndProc = WindowProc;
    wc.lpszClassName = L"MessageQueueWindowClass";  // 使用宽字符字符串
    RegisterClass(&wc);

    HWND hwnd = CreateWindow(wc.lpszClassName, L"Message Queue Window", WS_OVERLAPPEDWINDOW,
                             CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
                             NULL, NULL, NULL, NULL);

    ShowWindow(hwnd, SW_SHOWNORMAL);

    // 使用宽字符字符串
    SendMessageToQueue(hwnd, L"Hello from another thread!");
    
    MSG msg;
    while (GetMessage(&msg, hwnd, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return 0;
}
 

在上面的代码中：

• StartMessageLoop 函数创建了一个简单的窗口，并启动了消息循环。
• SendMessageToQueue 函数使用 PostMessage 向窗口的消息队列发送一个自定义消息 (WM_USER_MESSAGE)。
• 当消息到达窗口的消息队列时，WindowProc 会处理消息，并打印出接收到的消息内容。

2. 自定义消息队列实现

如果不想依赖操作系统的消息机制，可以自定义一个消息队列。这种方法适用于更灵活的需求，尤其是需要跨线程传递消息或任务的场景。常见的做法是使用互斥锁（mutex）和条件变量（condition_variable）来同步线程之间的消息传递。

自定义消息队列实现

下面是一个使用 C++ STL 的 std::queue、std::mutex 和 std::condition_variable 实现的简单消息队列。

增加退出机制

当前代码的消费者线程没有退出条件，会一直运行直到程序结束。如果需要优雅退出，可以加入一个标志位。例如：

 

代码解释：

• MessageQueue 类封装了一个 std::queue，它使用了 std::mutex 来保证线程安全，同时使用 std::condition_variable 来同步消费者线程等待消息的到来。
• push 函数将消息添加到队列中，并通过 notify_one() 通知消费者线程有新消息。
• pop 函数从队列中取出消息，如果队列为空，消费者线程将被阻塞，直到队列中有新消息。
• 在 main 函数中，创建了两个线程，一个作为生产者向队列中添加消息，另一个作为消费者从队列中取消息并处理。

3. 高级异步通信：使用线程池和消息队列

在更复杂的系统中，可以结合 线程池 和 消息队列 来处理并发任务。线程池允许管理多个线程处理多个异步任务，而消息队列则负责调度这些任务。

示例：

template<typename T>
class MessageQueue {
public:
    void push(const T& message) {
        std::lock_guard<std::mutex> lock(mtx);
        queue.push(message);
        cv.notify_one();
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this] { return stop || !queue.empty(); });
        if (queue.empty() && stop) {
            throw std::runtime_error("Queue stopped");
        }
        T message = queue.front();
        queue.pop();
        return message;
    }

    void stopQueue() {
        std::lock_guard<std::mutex> lock(mtx);
        stop = true;
        cv.notify_all();
    }

private:
    std::queue<T> queue;
    std::mutex mtx;
    std::condition_variable cv;
    bool stop = false;
};

// 消费者线程
void consumer(MessageQueue<std::string>& queue) {
    try {
        while (true) {
            std::string msg = queue.pop();
            std::cout << "Consumed message: " << msg << std::endl;
        }
    } catch (const std::exception& e) {
        std::cout << "Consumer stopped: " << e.what() << std::endl;
    }
}

// 生产者线程
void producer(MessageQueue<std::string>& queue) {
    queue.push("Message 1");
    std::this_thread::sleep_for(std::chrono::seconds(1));
    queue.push("Message 2");
    std::this_thread::sleep_for(std::chrono::seconds(1));
    queue.push("Message 3");
    std::this_thread::sleep_for(std::chrono::seconds(1));

    queue.stopQueue();  // 停止队列
}

int main() {
    MessageQueue<std::string> queue;

    std::thread consumerThread(consumer, std::ref(queue));
    std::thread producerThread(producer, std::ref(queue));

    producerThread.join();
    consumerThread.join();

    return 0;
}
 

结合 std::thread、std::queue、std::mutex 和 std::condition_variable 来实现一个简易的线程池，处理异步消息。