A idéia é poder substituir o código multithread com boost :: asio e um pool de threads, em um problema consumidor / produtor. Atualmente, cada segmento consumidor espera em umboost::condition_variable - quando um produtor adiciona algo à fila, ele chamanotify_one/notify_all notificar todos os consumidores. Agora, o que acontece quando você (potencialmente) tem 1k + consumidores? Tópicos não serão escalados!

Eu decidi usarboost::asio, mas depois me deparei com o fato de que não tem variáveis ​​de condição. E depoisasync_condition_variable nasceu:

class async_condition_variable
{
private:
    boost::asio::io_service& service_;
    typedef boost::function<void ()> async_handler;
    std::queue<async_handler> waiters_;

public:
    async_condition_variable(boost::asio::io_service& service) : service_(service)
    {
    }

    void async_wait(async_handler handler)
    {
        waiters_.push(handler);
    }

    void notify_one()
    {
        service_.post(waiters_.front());
        waiters_.pop();
    }

    void notify_all()
    {
        while (!waiters_.empty()) {
            notify_one();
        }
    }
};

Basicamente, cada consumidor ligariaasync_condition_variable::wait(...). Então, um produtor acabaria chamandoasync_condition_variable::notify_one() ouasync_condition_variable::notify_all(). A alça de cada consumidor seria chamada, e agiria sob a condição ou chamariaasync_condition_variable::wait(...) novamente. Isso é possível ou estou sendo louco aqui? Que tipo de bloqueio (mutexes) deve ser executado, dado o fato de que isso seria executado em um pool de threads?

P.S .: Sim, isso é mais um RFC (Request for Comments) do que uma pergunta :).