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

• Может быть невозможно предсказать, будет ли f выполнена вообще, поскольку может оказаться невозможно гарантировать, что функции-члены getили waitобъекта futбудут вызваны на всех путях выполнения программы.

Гибкость планирования стратегии запуска по умолчанию часто плохо комбинируется с использованием переменных thread_local, поскольку она означает, что если fчитает или записывает такую локальную память потока (thread-local storage — TLS), то невозможно предсказать, к переменным какого потока будет обращение:

auto fut = std::async(f); // TLS для f может принадлежать

// независимому потоку, но может

// принадлежать и потоку, вызывающему

// get или wait объекта fut

Это также влияет на циклы на основе waitс использованием тайм-аутов, поскольку вызов wait_forили wait_untilдля откладываемой задачи (см. раздел 7.1) дает значение std::future_status::deferred. Это означает, что приведенный далее цикл, который выглядит как в конечном итоге завершающийся, может оказаться бесконечным:

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: