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

• Вам нужен доступ к API, лежащей в основе реализации потоков. В С++ API параллельных вычислений обычно реализуется с помощью низкоуровневого платформо-зависимого API, обычно pthreadsили Windows Threads. Эти API в настоящее время предлагают больше возможностей, чем С++. (Например, С++ не имеет понятий приоритетов или родственности потоков.) Для предоставления доступа к API реализации потоков std::threadобычно предлагает функцию-член native_handle. Такая функциональность отсутствует в std::future (т.e. в том, что возвращает std::async).

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

• Вам требуется реализовать поточную технологию, выходящую за рамки API параллельных вычислений в С++, например пулы потоков на платформах, на которых ваши реализации С++ их не предоставляют.

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

• API std::thrеаdне предлагает способа непосредственного получения возвращаемых значений из асинхронно выполняемых функций, и, если такие функции генерируют исключения, программа завершается.

• Программирование на основе потоков требует управления вручную исчерпанием потоков, превышением подписки, балансом загрузки и адаптацией к новым платформам.

• Программирование на основе задач с помощью std::asyncсо стратегией запуска по умолчанию решает большинство перечисленных проблем вместо вас.

Вызывая std::asyncдля выполнения функции (или иного выполнимого объекта), вы в общем случае планируете выполнять ее асинхронно. Но вы не обязательно требуете это от std::async. В действительности вы запрашиваете выполнение функции в соответствии со стратегией запуска std::async. Имеются две стандартные стратегии, представленные перечислителями в перечислении с областью видимости std::launch. (Читайте информацию о перечислениях с областью видимости в разделе 3.4.) В предположении, что для выполнения в std::asyncпередается функция f:

• стратегия std::launch::async означает, что fдолжна выполняться асинхронно, т.e. в другом потоке;

• стратегия std::launch::deferred означает, что fможет выполняться только тогда, когда для фьючерса, возвращенного std::async, вызывается функция-член getили wait [22] Это упрощение. Значение имеет не фьючерс, для которого вызывается get или wait , а совместно используемое состояние, на которое ссылается фьючерс. (В разделе 7.4 обсуждается взаимосвязь фьючерсов и совместно используемых состояний.) Поскольку std: future поддерживают перемещение, а также могут использоваться для построения std::shared_future и поскольку std::shared_future могут копироваться, объект фьючерса, ссылающийся на совместно используемое состояние, возникающее из вызова std::async , в который была передана f , вероятно, будет отличаться от фьючерса, возвращенного std::async . Однако обычно просто говорят о вызове функций-членов get или wait фьючерса, возвращенного из std::async . , т.e. выполнение f откладывается до тех пор, пока не будет выполнен такой вызов. Когда вызываются функции-члены getили wait, функция fвыполняется синхронно, т.e. вызывающая функция блокируется до тех пор, пока fне завершит работу. Если не вызывается ни get, ни wait, fне выполняется.

Возможно, это окажется удивительным, но стратегия запуска std::asyncпо умолчанию — используемая в случае, если вы не указали таковую — не является ни одной из перечисленных. На самом деле это стратегия, которая представляет собой сочетание описанных с помощью оператора “или”. Два приведенных далее вызова имеют один и тот же смысл:

auto fut1 = std::async(f); // Выполнение f со стратегией

// запуска по умолчанию

auto fut2 = std::async( // Выполнение f

std::launch::async | // асинхронное

std::launch:: deferred, // или отложенное

f);

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

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

auto fut = std::async(f); // Выполнение f со стратегией

// запуска по умолчанию

• Невозможно предсказать, будет ли f выполняться параллельно с t , поскольку выполнение fможет быть отложено планировщиком.

• Невозможно предсказать, будет ли f выполняться потоком, отличным от того, в котором вызываются функции-члены get или wait объекта fut . Если этот поток — t, отсюда вытекает невозможность предсказать, будет ли fвыполняться потоком, отличным от t.

• Может быть невозможно предсказать, будет ли 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. Это означает, что приведенный далее цикл, который выглядит как в конечном итоге завершающийся, может оказаться бесконечным: