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

Исключение из этого нормального поведения осуществляется только для фьючерса, для которого выполняются все перечисленные далее условия.

• Он ссылается на общее состояние, созданное вызовом 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_futurefut;

};

Конечно, если у вас есть способ узнать, что данный фьючерс не удовлетворяет условиям, приводящим к специальному поведению деструктора (например, в силу логики программы), вы можете быть уверены, что этот фьючерс не приведет к блокировке деструктора. Например, претендовать на особое поведение могут только общие состояния, получающиеся в результате вызовов 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до того, как планировщик начинает выполнение задачи.)