C++实现一个消息循环，可以进行两个消息循环间的通信。

实现一个消息循环可以使用事件循环的方式，即不断地从消息队列中取出消息并处理。下面是一个简单的C++消息循环实现示例，其中包含两个消息循环并支持两个消息循环间的通信：

#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>

template<typename T>
class MessageQueue {
public:
    void Send(T&& msg) {
        std::lock_guard<std::mutex> lock(mutex_);
        queue_.emplace(std::move(msg));
        cv_.notify_one();
    }
    
    T Receive() {
        std::unique_lock<std::mutex> lock(mutex_);
        cv_.wait(lock, [this]{ return !queue_.empty(); });
        T msg = std::move(queue_.front());
        queue_.pop();
        return msg;
    }
    
private:
    std::queue<T> queue_;
    std::mutex mutex_;
    std::condition_variable cv_;
};

class MessageLoop {
public:
    MessageLoop() : stop_(false) {}
    
    void Run() {
        while (!stop_) {
            auto msg = message_queue_.Receive();
            if (msg == "Exit") {
                stop_ = true;
            } else if (msg == "Ping") {
                std::cout << "Pong" << std::endl;
                ping_pong_queue_.Send("Pong");
            } else {
                std::cout << "Unknown message: " << msg << std::endl;
            }
        }
    }
    
    void Stop() {
        message_queue_.Send("Exit");
    }
    
    void Ping() {
        message_queue_.Send("Ping");
    }
    
    void SetPongQueue(MessageQueue<std::string>& queue) {
        ping_pong_queue_ = queue;
    }
    
private:
    MessageQueue<std::string> message_queue_;
    MessageQueue<std::string> ping_pong_queue_;
    bool stop_;
};

int main() {
    MessageQueue<std::string> ping_pong_queue;
    
    MessageLoop ping_loop;
    ping_loop.SetPongQueue(ping_pong_queue);
    
    MessageLoop pong_loop;
    pong_loop.SetPongQueue(ping_pong_queue);
    
    std::thread ping_thread([&ping_loop](){
        ping_loop.Run();
    });
    
    std::thread pong_thread([&pong_loop](){
        pong_loop.Run();
    });
    
    ping_loop.Ping();
    std::cout << ping_pong_queue.Receive() << std::endl;
    
    ping_loop.Stop();
    pong_loop.Stop();
    
    ping_thread.join();
    pong_thread.join();
    
    return 0;
}

在上述代码中，我们使用了 `MessageQueue` 类来实现消息队列，同时定义了 `MessageLoop` 类来实现消息循环。每个 `MessageLoop` 对象都有一个消息队列和一个标志位 `stop_`，用于控制循环是否停止。在 `Run` 方法中，我们不断地从消息队列中取出消息并进行处理，如果收到了 "Exit" 消息，则将 `stop_` 设置为 true，从而停止循环；如果收到了 "Ping" 消息，则将 "Pong" 发送到另一个消息循环的队列中，以实现两个消息循环间的通信。在主函数中，我们创建了两个 `MessageLoop` 对象，并将它们的消息队列互相绑定，然后创建两个线程分别运行它们的消息循环。在主线程中，我们向 ping 循环发送 "Ping" 消息，并从 ping-pong 队列中接收 "Pong" 消息，以测试两个消息循环间的通信。最后，我们向两个循环发送 "Exit" 消息，以停止它们的消息循环，并等待线程退出。