PostMessage кроссплатформенный аналог

#include <iostream>
#include <future>
 
// Function to be called asynchronously
void foo() {
    std::cout << "foo() called asynchronously\n";
}
 
int main() {
    // Launch foo asynchronously and get a future representing its result
    std::future<void> result = std::async(std::launch::async, foo);
 
    // Do other work while foo is executing asynchronously
 
    // Wait for foo to finish (optional)
    result.get();
 
    return 0;
}

#include <iostream>
#include <queue>
#include <thread>
#include <boost/asio.hpp>
#include <mutex>
#include <condition_variable>
 
template <typename T>
class MessageQueue {
public:
    MessageQueue(boost::asio::io_context& io_context)
        : io_context_(io_context), work_guard_(boost::asio::make_work_guard(io_context)) {}
 
    void push(const T& message) {
        std::lock_guard<std::mutex> lock(mutex_);
        queue_.push(message);
        condition_.notify_one();
    }
 
    T pop() {
        std::unique_lock<std::mutex> lock(mutex_);
        condition_.wait(lock, [this] { return !queue_.empty(); });
        T message = queue_.front();
        queue_.pop();
        return message;
    }
 
private:
    std::queue<T> queue_;
    std::mutex mutex_;
    std::condition_variable condition_;
    boost::asio::io_context& io_context_;
    boost::asio::executor_work_guard<boost::asio::io_context::executor_type> work_guard_;
};
 
void producer(MessageQueue<std::string>& queue) {
    for (int i = 0; i < 10; ++i) {
        std::string message = "Message " + std::to_string(i);
        std::cout << "Producing: " << message << std::endl;
        queue.push(message);
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}
 
void consumer(MessageQueue<std::string>& queue) {
    for (int i = 0; i < 10; ++i) {
        std::string message = queue.pop();
        std::cout << "Consuming: " << message << std::endl;
    }
}
 
int main() {
    boost::asio::io_context io_context;
 
    MessageQueue<std::string> queue(io_context);
 
    std::thread producer_thread(producer, std::ref(queue));
    std::thread consumer_thread(consumer, std::ref(queue));
 
    producer_thread.join();
    consumer_thread.join();
 
    return 0;
}