for (auto &t : v) { t.join(); }
cout << '\n';
}
6. Компиляция и запуск дадут следующий результат. Сначала мы увидим восклицательный знак благодаря функции
once_print
. Затем увидим все идентификаторы потоков. Функция call_once
не только помогла убедиться в том, что функция once_print
была вызвана всего раз. Помимо этого, она синхронизировала все потоки и ни один идентификатор не был выведен на экран до выполнения once_print
.
$ ./call_once
!1239406758
Как это работает
Функция
std:call_once
работает как барьер. Она поддерживает доступ к функции (или вызываемому объекту). Первый поток, достигший ее, выполняет эту функцию. Пока ее выполнение не завершится, любой другой поток, который достигнет call_once
, заблокируется. После того как первый поток вернется из этой функции, все другие потоки также будут освобождены.Чтобы организовать этот небольшой «танцевальный номер», требуется переменная, на основе которой другие потоки могут определить, следует ли им ждать, а также время их освобождения. Именно для этого и предназначена переменная
once_flag callflag;
. Каждая строка call_once
нуждается и в экземпляре типа once_flag
. Он будет передан как аргумент перед функцией, которая должна быть вызвана всего раз.Еще одна приятная деталь: если поток, который был выбран для выполнения функции
call_once
, даст сбой из-за какого-то исключения, то следующий поток сможет попытаться выполнить функцию снова. Это делается вследствие вероятности того, что в следующий раз исключение не будет сгенерировано. Отправляем выполнение задач в фоновый режим с применением std::async
При необходимости выполнить некий код в фоновом режиме можно просто запустить новый поток, который выполнит данный код. В подобных ситуациях можно сделать что-то еще, а затем подождать результата. Это просто:
std::thread t {my_function, arg1, arg2, ...};
// сделать что-то еще
t.join(); // подождать завершения потока
Но здесь начинаются неудобства:
t.join()
не дает возвращаемое значение функции my_function
. Чтобы получить его, следует написать функцию, которая вызывает функцию my_function
и сохраняет ее возвращаемое значение в какой-то переменной. Последняя также доступна первому потоку, в котором и был запущен новый поток. Если такие ситуации происходят постоянно, то нужно написать очень много стереотипного кода снова и снова.В C++11 появилась функция
std::async
, способная решить эту задачу для нас, и не только. В этом примере мы напишем простую программу, которая делает несколько дел одновременно с помощью асинхронных вызовов функций. Поскольку std::async
эффективна не только в данной области, рассмотрим все ее аспекты.
Как это делается
В этом примере мы реализуем программу, которая делает несколько дел конкурентно, но вместо того, чтобы явно запускать потоки, мы используем
std::async
и std::future
.
1. Сначала включим все необходимые заголовочные файлы и объявим об использовании пространства имен
std
:
#include
#include
#include
#include
#include
#include
#include
using namespace std;
2. Реализуем три функции, которые не связаны с параллелизмом, а просто выполняют интересные задачи. Первая функция принимает строку и создает гистограмму включения всех символов внутри этой строки:
static map histogram(const string &s)
{
map m;
for (char c : s) { m[c] += 1; }
return m;
}
3. Вторая функция также принимает строку и возвращает ее отсортированную копию:
static string sorted(string s)
{
sort(begin(s), end(s));
return s;
}
4. Третья функция подсчитывает, как много гласных находится внутри принимаемой строки:
static bool is_vowel(char c)
{
char vowels[] {"aeiou"};
return end(vowels) !=
find(begin(vowels), end(vowels), c);
}
static size_t vowels(const string &s)
{
return count_if(begin(s), end(s), is_vowel);
}
5. В функции
main
считываем весь стандартный поток ввода в одну строку. Чтобы не разбивать входные данные на слова, деактивируем ios::skipws
. Подобным образом получаем одну большую строку независимо от того, сколько пробелов содержится во входных данных. Используем pop_back
для полученной строки, поскольку так мы получаем слишком много символов-терминаторов '\0'
:
int main()
{
cin.unsetf(ios::skipws);
string input {istream_iterator{cin}, {}};
input.pop_back();
6. Теперь вернем значения из всех функций, которые реализовали ранее. Чтобы ускорить выполнение программы в случае получения очень больших входных данных, запустим их асинхронно. Функция
std::async
принимает политику, функцию и аргументы этой функции. Вызываем функции histogram
, sorted
и vowels
, передавая в качестве политики launch::async
(далее узнаем, что это значит). Все функции получают в качестве аргументов одинаковые входные строки:
auto hist (async(launch::async,
histogram, input));
auto sorted_str (async(launch::async,
sorted, input));
auto vowel_count(async(launch::async,
vowels, input));
7. Вызовы
async
возвращают значения мгновенно, поскольку не выполняют сами функции. Вместо этого они подготавливают структуры для синхронизации, которые в дальнейшем станут получать результаты вызова функций. Результаты теперь будут определяться конкурентно с помощью дополнительных потоков. В это же время мы можем делать все, что захотим, поскольку получим данные значения позже. Возвращаемые значения hist
, sorted_str
и vowel_count
имеют типы, указанные для функций histogram
, sorted
и vowels
, но они обернуты в тип future
функцией std::async
. Объекты этого типа выражают тот факт, что в какой-то момент времени будут содержать значения. Вызов .get()
позволяет получить их все, а до их появления можем заблокировать функцию main
. После получения этих значений выводим их на экран:
for (const auto &[c, count] : hist.get()) {
cout << c << ": " << count << '\n';
}
cout << "Sorted string: "
<< quoted(sorted_str.get()) << '\n'
<< "Total vowels: "
<< vowel_count.get()<< '\n';
}
8. Компиляция и запуск кода выглядят так. Мы использовали короткую строку, которую не стоит распараллеливать, но для примера выполнили ее конкурентно. Вдобавок общая структура программы не изменилась по сравнению с наивной последовательной реализацией: