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

using namespace std::literals; // Суффиксы длительности С++14;
                               // см. Раздел 6.4

void f()                       // f ждет 1 с, затем выполняется
{                              // возврат из функции
 std::this_thread::sleep_for(1s);
}

auto fut = std::async(f);     // (Концептуально) асинхронное
                              // выполнение функции f
while (fut.wait_for(100ms) != // Цикл до завершения f...
       std::future_status::ready)
{                             // ... которого никогда не будет!
 …
}

Если функция f выполняется параллельно с потоком, вызывающим std::async (т.e. если выбранная для f стратегия запуска — std::launch::async), нет никаких проблем (в предположении, что f в конечном итоге завершится), но если выполнение f откладывается, fut.wait_for всегда будет возвращать std::future_status::deferred. Это возвращаемое значение никогда не станет равным std::future_status::ready, так что цикл никогда не завершится.

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

Исправить ошибку просто: следует проверить фьючерс, соответствующий вызову std::async, и выяснить, не отложена ли данная задача. Если отложена, то надо избегать входа в цикл на основе тайм-аутов. К сожалению, нет непосредственного способа выяснить у фьючерса, отложена ли задача. Вместо этого вы должны вызывать функцию на основе тайм-аута, такую как wait_for. В этом случае вы в действительности не хотите ничего ожидать, а хотите просто проверить, не возвращает ли она значение std::future_status::deferred, так что можно вызывать эту функцию с нулевым временем ожидания:

auto fut = std::async(f); // Как и ранее
if (fut.wait_for(0s) =    // Если задача отложена...
 std::future_status::deferred) {
                          // ...используем wait или get
  …                       // для синхронного вызова f
} else {                  // Если задача не отложена -
 while(fut.wait_for(100ms) !=       // бесконечный цикл
       std::future_status::ready) { // невозможен (если f в
                                    // конце концов завершается)
   … // Задача не отложена и не готова,
     // так что она выполняется параллельно
 }
     // fut выполнен
}

Из всего изложенного получается, что применение std::async со стратегией запуска по умолчанию отлично работает, пока выполняются следующие условия.

• Задача не обязана работать параллельно с потоком, вызывающим get или wait.

• Не имеет значения, переменные thread_local какого потока читаются или записываются.

• Либо гарантируется вызов get или wait для фьючерса, возвращаемого std::async, либо ситуация, когда задача не выполняется совсем, является приемлемой.

• Код с использованием wait_for или wait_until учитывает возможность отложенного состояния задачи.

Если не выполняется любое из этих условий, то вы, вероятно, захотите гарантировать, что std::async обеспечит асинхронное выполнение задачи. Для этого в качестве первого аргумента в нее надо передать значение std::launch::async:

auto fut = std::async(std::launch::async, f); // Асинхронный
                                              // запуск f

На практике удобно иметь функцию, работающую как std::async, но автоматически использующую стратегию запуска std::launch::async. Такую функцию несложно написать. Вот как выглядит версия этой функции для С++11:

template
inline
std::future::type>
reallyAsync(F&& f, Ts&&... params)     // Возврат фьючерса
{                                      // для асинхронного
 return std::async(std::launch::async, // вызова f(params ...)
                   std::forward(f),
                   std::forward(params)...);
}

Эта функция получает вызываемый объект f и нуль или более параметров params и выполняет их прямую передачу (см. раздел 5.3) в std::async, передавая также значение std::launch::async в качестве стратегии вызова. Подобно std::async, она возвращает std::future для результата выполнения f с параметрами params. Определить тип этого результата просто, так как его нам дает свойство типа std::result_of. (Информацию о свойствах типов вы найдете в разделе 3.3.)

Функция reallyAsync используется так же, как и std::async:

auto fut = reallyAsync(f); // Асинхронный запуск f; генерирует
                           // исключение, если это делает
                           // std::async

В С++ 14 возможность вывода возвращаемого типа reallyAsync сокращает объявление функции:

template
inline
auto // С++14
reallyAsync(F&& f, Ts&&... params) {
 return std::async(std::launch::async,
                   std::forward(f),
                   std::forward(params)...);