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

• Он ссылается на общее состояние, созданное вызовом std::async.

• Стратегия запуска задачи — std::launch::async (см. раздел 7.2), либо потому, что она выбрана системой времени выполнения, либо потому, что была явно указана в вызове std::async.

• Фьючерс является последним фьючерсом, ссылающимся на общее состояние. Это всегда справедливо для std::future. Для std::shared_future, если при уничтожении фьючерса на то же самое общее состояние ссылаются другие std::shared_future, поведение уничтожаемого фьючерса — нормальное (т.e. просто уничтожаются его члены-данные).

Только когда все эти условия выполнены, деструктор фьючерса демонстрирует особое поведение, и это поведение состоит в блокировке до тех пор, пока не будет завершена асинхронно выполняющаяся задача. С практической точки зрения это равносильно неявному вызову join для потока с запущенной задачей, созданной с помощью std::async.

Часто приходится слышать, что это исключение из нормального поведения деструктора фьючерса резюмируется как “Фьючерс из std::async блокируется в своем деструкторе”. В качестве первого приближения это так, но иногда нам надо что-то большее, чем первое приближение. Теперь вы знаете правду во всей ее красе и славе.

Ваше удивление может принять и иную форму. Например, “Не понимаю, почему имеется особое правило для общих состояний для неотложенных задач, запущенных с помощью std::async”. Это разумный вопрос. Я могу сказать, что Комитет по стандартизации хотел избежать проблем, связанных с неявным вызовом detach (см. раздел 7.3), но не хотел одобрять такую радикальную стратегию, как обязательное завершение программы (как сделано для подключаемых std::thread; см. тот же раздел 7.3), так что в качестве компромисса был принят неявный вызов join. Это решение не без противоречий, и были серьезные предложения отказаться от этого поведения в С++ 14. В конце концов никакие изменения сделаны не были, так что поведение деструкторов фьючерсов в С++11 согласуется с таковым в С++14.

API для фьючерсов не предлагает способа определения, ссылается ли фьючерс на общее состояние, возникающее из вызова std::async, так что невозможно узнать, будет ли заблокирован некоторый объект фьючерса в своем деструкторе для ожидания завершения асинхронно выполняющейся задачи. Это имеет некоторые интересные последствия.

// Этот контейнер может блокироваться в деструкторе, поскольку
// один или несколько содержащихся в нем фьючерсов могут
// ссылаться на общее состояние неотложенного задания,
// запущенного с помощью std::async
std::vector<std::future> futs; // См.std::future
                                     // в разделе 7.5
class Widget {                       // Объекты Widget могут
public:                              // блокироваться в их
 …                                   // деструкторах
private:
 std::shared_future fut;
};

Конечно, если у вас есть способ узнать, что данный фьючерс не удовлетворяет условиям, приводящим к специальному поведению деструктора (например, в силу логики программы), вы можете быть уверены, что этот фьючерс не приведет к блокировке деструктора. Например, претендовать на особое поведение могут только общие состояния, получающиеся в результате вызовов std::async, но есть и иные способы создания этих общих состояний. Один из них — использование std::packaged_task. Объект std::packaged_task подготавливает функцию (или иной вызываемый объект) к асинхронному выполнению, “заворачивая” ее таким образом, что ее результат помещается в общее состояние. Фьючерс, ссылающийся на это общее состояние, может быть получен с помощью функции get_future объекта std::packaged_task.

int calcValue();            // Выполняемая функция
std::packaged_task   // Заворачивание calcValue для
 pt(calcValue);             // асинхронного выполнения
auto fut = pt.get_future(); // Получение фьючерса для pt

В этой точке мы знаем, что фьючерс fut не ссылается на общее состояние, созданное вызовом std::async, так что его деструктор будет вести себя нормально.

Будучи созданным, объект pt типа std::packaged_task может быть запущен в потоке. (Он может быть запущен и с помощью вызова std::async, но если вы хотите выполнить задачу с использованием std::async, то нет смысла создавать std::packaged_task, поскольку std::async делает все, что делает std::packaged_task до того, как планировщик начинает выполнение задачи.)

Объекты std::packaged_task не копируются, так что когда pt передается в конструктор std::thread, он должен быть приведен к rvalue (с помощью std::move; см. раздел 5.1):

std::thread t(std::move(pt)); // Выполнение pt потоком t

Этот пример дает некоторое представление о нормальном поведении деструкторов фьючерсов, но его легче увидеть, если собрать весь код вместе в одном блоке:

{  // Начало блока
 std::packaged_task
  pt(calcValue);

 auto fut = pt.get_future();
 std::thread t(std::move(pt));

 … // См. Ниже

}  // Конец блока

Наиболее интересный код скрывается за троеточием “…” следующим за созданием объекта t типа std::thread и предшествующим концу блока. Имеются три основные возможности.