Это руководство демонстрирует использование повышения::asio:::strand класса для синхронизации обработчиков обратного вызова в многопоточной программе.

Предыдущие четыре учебника избежали проблемы синхронизации обработчика, позвонив вio_service::run()Функция только из одной нити. Как вы уже знаете, библиотека азио предоставляет гарантию того, что обработчики обратного вызова будут вызываться только из потоков, которые в настоящее время вызываютio_service::run().Следовательно, вызовio_service::run()из одного потока гарантирует, что обработчики обратного вызова не могут работать одновременно.

Однопотоковый подход, как правило, является лучшим местом для начала разработки приложений с использованием Asio. Недостатком являются ограничения, которые он накладывает на программы, особенно на серверы, в том числе:

Если вы столкнулись с этими ограничениями, альтернативный подход заключается в том, чтобы иметь пул потоков, вызывающихio_service::run(). Тем не менее, поскольку это позволяет обработчикам выполнять одновременно, нам нужен метод синхронизации, когда обработчики могут получать доступ к общему ресурсу.

#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

Мы начинаем с определения класса под названием<printer>, аналогичного классу в предыдущем учебнике. Этот класс расширит предыдущий учебник, запустив два таймера параллельно.

class printer
{
public:

В дополнение к инициализации пары участников boost::asio::deadline_timer конструктор инициализирует элемент<strand_>, объект типа boost::asio::strand.

Повышение::asio::strand гарантирует, что для тех обработчиков, которые отправляются через него, исполняющему обработчику будет разрешено завершить до начала следующего. Это гарантируется независимо от количества потоков, вызывающихio_service::run(). Конечно, обработчики могут по-прежнему выполнять одновременно с другими обработчиками, которые не были отправлены через усилитель::asio:::strand, или были отправлены через другой усилитель:::asio:::strand объект.

  printer(boost::asio::io_service& io)
    : strand_(io),
      timer1_(io, boost::posix_time::seconds(1)),
      timer2_(io, boost::posix_time::seconds(1)),
      count_(0)
  {

При инициировании асинхронных операций каждый обработчик обратного вызова «заворачивается» с помощью импульса::asio:::strand. Функцияstrand::wrap()возвращает новый обработчик, который автоматически отправляет свой содержащийся обработчик через усилитель::asio:::strand объект. Обертывая обработчиков, используя тот же импульс::asio:::strand, мы гарантируем, что они не могут выполнять одновременно.

    timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1, this)));
    timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2, this)));
  }
  ~printer()
  {
    std::cout << "Final count is " << count_ << std::endl;
  }

В многопоточной программе обработчики асинхронных операций должны быть синхронизированы, если они получают доступ к общим ресурсам. В этом руководстве общие ресурсы, используемые обработчиками<print1>и<print2>, являются<std::cout>и<count_>членом данных.

  void print1()
  {
    if (count_ < 10)
    {
      std::cout << "Timer 1: " << count_ << std::endl;
      ++count_;
      timer1_.expires_at(timer1_.expires_at() + boost::posix_time::seconds(1));
      timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1, this)));
    }
  }
  void print2()
  {
    if (count_ < 10)
    {
      std::cout << "Timer 2: " << count_ << std::endl;
      ++count_;
      timer2_.expires_at(timer2_.expires_at() + boost::posix_time::seconds(1));
      timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2, this)));
    }
  }
private:
  boost::asio::io_service::strand strand_;
  boost::asio::deadline_timer timer1_;
  boost::asio::deadline_timer timer2_;
  int count_;
};

Функция<main>теперь вызываетio_service::run()должно быть вызвано из двух нитей: основной и одной дополнительной. Это достигается с помощью ускорения::thread объект.

Так же, как и при вызове из одной нити, параллельные вызовы вio_service::run()будет продолжать выполнять, пока есть «работа». Нить фона не выйдет до тех пор, пока не будут завершены все асинхронные операции.

int main()
{
  boost::asio::io_service io;
  printer p(io);
  boost::thread t(boost::bind(&boost::asio::io_service::run, &io));
  io.run();
  t.join();
  return 0;
}

См.полный список источников

Вернуться вучебный индекс

Таймер.4 - Использование функции члена в качестве обработчика