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

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)...);

}

Эта версия делает кристально ясным то, что reallyAsyncне делает ничего, кроме вызова std::asyncсо стратегией запуска std::launch::async.

• Стратегия запуска по умолчанию для std::asyncдопускает как асинхронное, так и синхронное выполнение задачи.

• Эта гибкость ведет к неопределенности при обращении к переменным thread_local, к тому, что задача может никогда не быть выполнена, и влияет на логику программы для вызовов waitна основе тайм-аутов.

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

Каждый объект std::threadможет находиться в двух состояниях: подключаемом (joinable) и неподключаемом (unjoinable) [23] Часто их переводят как объединяемое и необъединяемое , но, на наш взгляд, термин подключение лучше отражает смысл происходящего с потоком, связанным с объектом std::thread , при вызове функции join , как и отключение для происходящего при вызове функции detach . — Примеч. пер . . Подключаемый std::threadсоответствует асинхронному потоку выполнения, который выполняется или может выполняться. Например, таковым является std::thread, соответствующий потоку, который заблокирован или ожидает запуска планировщиком. Объекты std::thread, соответствующие потокам, которые выполняются до полного завершения, также рассматриваются как подключаемые.

Неподключаемые объекты std::threadявляются именно тем, что вы и ожидаете, а именно — объектами std::thread, которые не являются подключаемыми. Неподключаемые объекты std::threadвключают следующие.

• Объекты std::thread , созданные конструкторами по умолчанию. Такие std::threadне имеют выполняемой функции, а значит, не соответствуют никакому потоку выполнения.