Непоточная альтернатива ожиданию по условию. (Edit: шаблон Proactor с boost.asio?)

Я реализую алгоритм передачи сообщений. Сообщения передаются между соседними узлами, когда в узле имеется достаточно информации для составления сообщения - информации, которая передается узлу от соседних узлов. Реализация тривиальна, если я сделаю каждое из сообщений потоком и использую boost :: condition, чтобы перевести поток в спящий режим, пока необходимая информация не станет доступной.

К сожалению, у меня 100 тыс. Узлов в графе, что означает 300 тыс. Потоков. Когда я спросил , как создать такое количество потоков, я ответил, что не следует - и вместо этого переделываю дизайн.

Мой вопрос: существует ли стандартный шаблон проектирования для ожидания условия? Может быть, какой-нибудь асинхронный шаблон управления?

РЕДАКТИРОВАТЬ: Думаю, я могу сделать это с помощью шаблона проакатора. Я отредактировал теги, чтобы включить boost :: asio - чтобы узнать, есть ли у кого-нибудь предложения по этому поводу.

Итак, обсуждение может быть конкретным, вот как сообщения определены до сих пор:

class
Message
{
public:      
  Message(const Node* from, Node* to)
    : m_from(from), m_to(to)
  {}
  void
  operator()()
  {
    m_to->ReceiveMessage( m_from->ComposeMessage() );
  }
private:
  Node *m_from, *m_to;
};

Эти функторы сообщений в настоящее время запущены с boost :: thread. Тогда у нас есть

class Node
{
    Node(Node* Neighbour1, Node* Neighbour2, Node* Neighbour3); 
   // The messages (currently threads) are created on construction, 
   // The condition locks then sort out when they actually get passed 
   // without me having to think too hard.

    void ReceiveMessage(const Message&); 
    //set m_message from received messages;
    //EDIT This looks like an async write - use boost asio here?

    Message 
    ComposeMessage()
    {
      // If possible I want to implement this function without threads
      // It works great but it if every message is a thread 
      // then I have 300k threads.
      // EDIT: this looks like an async read (use boost asio here?)

      boost::mutex::scoped_lock lock(m_mutex);
       while (!m_message) //lock the thread until parameter is set.
        m_cond.wait(lock);
      return *m_message;
   }
  private:
    boost::optional m_message;
    boost::mutex m_mutex;
    boost::condition m_cond;
}

Мне нравится прозрачность кода, и, если возможно, я хотел бы сохранить те же интерфейсы, имея альтернативу условной блокировке?