Вторая же выглядит практически так же, но вместо непосредственного применения cout создает экземпляр pcout. Этот экземпляр представляет собой временный объект, существующий только для одной строки кода. После выполнения всех вызовов operator<< внутренний строковый поток заполняется всеми данными, которые мы бы хотели вывести. Затем вызывается деструктор для экземпляра типа pcout. Мы уже видели, что он делает: блокирует конкретный мьютекс, разделяемый всеми экземплярами класса pcout, и выводит данные на экран:
static void print_cout(int id)
{
cout << "cout hello from " << id << 'n';
}
static void print_pcout(int id)
{
pcout{} << "pcout hello from " << id << 'n';
}
4. Опробуем его. Сначала воспользуемся print_cout, которая для вывода данных просто обращается к cout. Запускаем десять потоков, конкурентно выводящих свои строки и ожидающих завершения:
int main()
{
vector<thread> v;
for (size_t i {0}; i < 10; ++i) {
v.emplace_back(print_cout, i);
}
for (auto &t : v) { t.join(); }
5. Далее делаем то же самое для функции print_pcout:
cout << "=====================n";
v.clear();
for (size_t i {0}; i < 10; ++i) {
v.emplace_back(print_pcout, i);
}
for (auto &t : v) { t.join(); }
}
6. Компиляция и запуск программы дадут следующий результат (рис. 9.3). Как видите, первые десять строк полностью перепутались. Именно так может выглядеть результат, когда cout используется конкурентно и без блокировки. Последние десять строк выведены с помощью print_pcout, никакой путаницы нет. Можно увидеть, что они выводятся из разных потоков, поскольку их порядок различается при каждом запуске программы.
Как это работает
О’кей, мы создали эту «оболочку для cout», которая автоматически сериализует последовательные попытки вывода текста. Как она работает?
Выполним те же действия, что и pcout, вручную. Сначала создаем строковый поток и принимаем входные данные, которые будем передавать в него:
stringstream ss;
ss << "This is some printed line " << 123 << 'n';
Затем блокируем глобально доступный мьютекс:
{
lock_guard<mutex> l {cout_mutex};
В этой заблокированной области видимости мы получаем доступ к содержимому строкового потока ss, выводим его на экран и освобождаем мьютекс, покидая область видимости. Строка cout.flush() указывает объекту потока вывести данные на консоль немедленно. Без данной строки программа способна работать быстрее, поскольку несколько строк можно вывести за один раз. В наших примерах мы хотим видеть результат работы немедленно, так что используем метод flush:
cout << ss.rdbuf();
cout.flush();
}
О’кей, это достаточно просто, но утомительно писать, если нужно делать одно и то же раз за разом. Можно сократить создание объекта stringstream таким образом:
stringstream{} << "This is some printed line " << 123 << 'n';
Эта строка создает объект строкового потока, передает ему все, что нужно вывести на экран, а затем снова разрушает его. Жизненный цикл строкового потока сокращается до данной строки. После этого мы не можем выводить на экран данные, поскольку у нас нет доступа к указанному объекту. Какой фрагмент кода последним может получить содержимое потока? Это деструктор stringstream.
Мы не можем изменить методы-члены экземпляра stringstream, но способны расширить их, обернув наш собственный тип вокруг них с помощью наследования:
struct pcout : public stringstream {
~pcout() {
lock_guard<mutex> l {cout_mutex};
cout << rdbuf();
cout.flush();
}
};
Этот класс все еще является строковым потоком, и его можно использовать так же, как и любой другой строковый поток. Единственное отличие заключается в том, что он будет блокировать мьютекс и выводить собственный буфер с помощью cout.
Кроме того, мы поместили объект cout_mutex в структуру pcout как статический экземпляр, и теперь все элементы находятся в одном месте.
Безопасно откладываем инициализацию с помощью std::call_once
Иногда встречаются специфические разделы кода, которые можно запустить в параллельном контексте в нескольких потоках, при этом перед выполнением самих функций нужно выполнить программу настройки. Простым решением будет выполнить существующую функцию настройки до того, как программа войдет в состояние, из которого время от времени может работать параллельный код.
Однако данный подход имеет следующие недостатки.
□ Если параллельная функция находится в библиотеке, то пользователь не должен забывать вызывать функцию настройки. Это не упрощает применение библиотеки.
□ Предположим, функция настройки в какой-то степени дорогая, и ее, возможно, даже не требуется выполнять, если параллельные функции, которые ее используют, не запускаются. В таком случае необходим код, определяющий, запускать эту функцию или нет.
В данном примере мы рассмотрим вспомогательную функцию std::call_once, которая решает эту проблему простым, элегантным и неявным способом.
Как это делается
В этом примере мы напишем программу, которая запускает несколько потоков, выполняющих один и тот же код. Несмотря на полностью одинаковый выполняемый ими код, наша функция настройки будет вызвана всего раз.
1. Сначала включим все необходимые заголовочные файлы и объявим об использовании пространства имен std:
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
using namespace std;
2. Далее будем использовать функцию std::call_once. Чтобы ее применить, нужен экземпляр типа once_flag для синхронизации между всеми потоками, которые задействуют call_once для конкретной функции.
once_flag callflag;
3. Функция, которая должна быть выполнена всего раз, выглядит так. Она просто выводит один восклицательный знак:
static void once_print()
{
cout << '!';
}
4. Все потоки будут выполнять функцию print. Первое, что мы сделаем, — вызовем функцию once_print для функции std::call_once. Функции call_once требуется переменная callflag, которую мы определили ранее. Она послужит для управления потоками.
static void print(size_t x)
{
std::call_once(callflag, once_print);
cout << x;
}
5. О’кей, теперь запустим десять потоков, все они будут использовать функцию print:
int main()
{
vector<thread> v;
for (size_t i {0}; i < 10; ++i) {
