Скотт Мейерс - Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14

// (часть 2)

А вот задача реакции:

… // Подготовка к реакции

{ // Как и ранее

std: :unique_lock lk(m); // Как и ранее

cv.wait(lk, []{ return flag; }); // Применение лямбда-

// выражения во избежание

// ложных пробуждений

… // Реакция на событие

// (m заблокирован)

}

… // Продолжение реакции

// (m разблокирован)

Этот подход позволяет избежать проблем, которые мы обсуждали. Он работает независимо от того, вызывает ли задача реакции waitдо уведомления задачей обнаружения, он работает при наличии ложных пробуждений и не требует опроса флага. Тем не менее душок остается, потому что задача обнаружения взаимодействует с задачей реакции очень любопытным способом. Уведомляемая переменная условия говорит задаче реакции о том, что, вероятно, произошло ожидаемое событие, но задаче реакции необходимо проверить флаг, чтобы быть в этом уверенной. Установка флага говорит задаче реакции, что событие, определенно, произошло, но задача обнаружения по-прежнему обязана уведомить переменную условия о том, чтобы задача реакции активизировалась и проверила флаг. Этот подход работает, но не кажется очень чистым.

Альтернативный вариант заключается в том, чтобы избежать переменных условия, мьютексов и флагов с помощью вызова waitзадачей реакции для фьючерса, установленного задачей обнаружения. Это может показаться странной идеей. В конце концов, в разделе 7.4 поясняется, что фьючерс представляет принимающий конец канала связи от вызываемой функции к (обычно асинхронной) вызывающей функции, а между задачами обнаружения и реакции нет отношений “вызываемая-вызывающая”. Однако в разделе 7.4 также отмечается, что канал связи, передающий конец которого представляет собой std::promise, а принимающий — фьючерс, может использоваться для большего, чем простой обмен информацией между вызываемой и вызывающей функциями. Такой канал связи может быть использован в любой ситуации, в которой необходима передача информации из одного места вашей программы в другое. В нашем случае мы воспользуемся им для передачи информации от задачи обнаружения задаче реакции, и информация, которую мы будем передавать, — о том, что произошло интересующее нас событие.

Проект прост. Задача обнаружения имеет объект std::promise(т.e. передающий конец канала связи), а задача реакции имеет соответствующий фьючерс. Когда задача обнаружения видит, что произошло ожидаемое событие, она устанавливает объект std::promise(т.e. выполняет запись в канал связи). Тем временем задача реакции выполняет вызов waitсвоего фьючерса. Этот вызов waitблокирует задачу реакции до тех пор, пока не будет установлен объект std::promise.

И std::promise, и фьючерсы (т.e. std::futureи std::shared_ future) являются шаблонами, требующими параметр типа. Этот параметр указывает тип данных, передаваемый по каналу связи. Однако в нашем случае никакие данные не передаются. Единственное, что представляет интерес для задачи реакции, — что ее фьючерс установлен. Нам нужно указать для шаблонов std::promiseи фьючерса тип, показывающий, что по каналу связи не будут передаваться никакие данные. Таким типом является void. Задача обнаружения, таким образом, будет использовать std::promise, а задача реакции — std::futureили std::shared_future. Задача обнаружения устанавливает свой объект std::promise, когда происходит интересующее нас событие, а задача реакции ожидает с помощью вызова waitсвоего фьючерса. Даже несмотря на то, что задача реакции не получает никаких данных от задачи обнаружения, канал связи позволит задаче реакции узнать, что задача обнаружения “записала” void-данные с помощью вызова set_valueсвоего объекта std::promise. Так что для данного

std::promise p; // Коммуникационный канал

код задачи обнаружения тривиален:

… // Обнаружение события

p.set_value(); // Сообщение задаче реакции

Код задачи реакции не менее прост:

… // Подготовка к реакции

p.get_future().wait();// Ожидание фьючерса,

// соответствующего p

… // Реакция на событие

Этот подход, как и использование флага, не требует мьютексов, работает независимо от того, устанавливает ли задача обнаружения свой объект std::promiseдо того, как задача реакции вызывает wait, и невосприимчива к ложным пробуждениям. (Этой проблеме подвержены только переменные условия.) Подобно подходу на основе переменных условия задача реакции оказывается истинно заблокированной после вызова wait, так что во время ожидания не потребляет системные ресурсы. Идеально, нет?