Энтони Уильямс - Параллельное программирование на С++ в действии. Практика разработки многопоточных программ

Листинг 4.9.Выполнение кода в потоке пользовательского интерфейса с применением std::packaged_task

#include

#include

#include

#include

#include

std::mutex m;

std::deque> tasks;

bool gui_shutdown_message_received();

void get_and_process_gui_message();

void gui_thread() { ← (1)

while (!gui_shutdown_message_received()) { ← (2)

get_and_process_gui_message(); ← (3)

std::packaged_task task; {

std::lock_guard lk(m);

if (tasks empty()) ← (4)

continue;

task = std::move(tasks.front()); ← (5)

tasks.pop_front();

}

task(); ← (6)

}

}

std::thread gui_bg_thread(gui_thread);

template

std::future post_task_for_gui_thread(Func f) {

std::packaged_task task(f); ← (7)

std::future res = task.get_future();← (8)

std::lock_guard lk(m);

tasks.push_back(std::move(task)); ← (9)

return res; ← (10)

}

Код очень простой: поток пользовательского интерфейса (1)повторяет цикл, пока не будет получено сообщение о необходимости завершить работу (2). На каждой итерации проверяется, есть ли готовые для обработки сообщения GUI (3), например события мыши, или новые задачи в очереди. Если задач нет (4), программа переходит на начало цикла; в противном случае извлекает задачу из очереди (5), освобождает защищающий очередь мьютекс и исполняет задачу (6). По завершении задачи будет готов ассоциированный с ней будущий результат.

Помещение задачи в очередь ничуть не сложнее: по предоставленной функции создается новая упакованная задача (7), для получения ее будущего результата вызывается функция-член get_future() (8), после чего задача помещается в очередь (9)еще до того, как станет доступен будущий результат (10). Затем часть программы, которая отправляла сообщение потоку пользовательского интерфейса, может дождаться будущего результата, если хочет знать, как завершилась задача, или отбросить его, если это несущественно.

В этом примере мы использовали класс std::packaged_taskдля задач, обертывающих функцию или иной допускающий вызов объект, который не принимает параметров и возвращает void(если он вернет что-то другое, то возвращенное значение будет отброшено). Это простейшая из всех возможных задач, но, как мы видели ранее, шаблон std::packaged_taskприменим и в более сложных ситуациях — задав другую сигнатуру функции в качестве параметра шаблона, вы сможете изменить тип возвращаемого значения (и, стало быть, тип данных, которые хранятся в состоянии, ассоциированном с будущим объектом), а также типы аргументов оператора вызова. Наш пример легко обобщается на задачи, которые должны выполняться в потоке GUI и при этом принимают аргументы и возвращают в std::futureкакие-то данные, а не только индикатор успешности завершения.

А как быть с задачами, которые нельзя выразить в виде простого вызова функции, или такими, где результат может поступать из нескольких мест? Эти проблемы решаются с помощью еще одного способа создания будущего результата: явного задания значения с помощью шаблона класса std::promise [8] promise — обещание. Прим. перев. .

При написании сетевых серверных программ часто возникает искушение обрабатывать каждый запрос на соединение в отдельном потоке, поскольку при такой структуре порядок коммуникации становится нагляднее и проще для программирования. Этот подход срабатывает, пока количество соединений (и, следовательно, потоков) не слишком велико. Но с ростом числа потоков увеличивается и объем потребляемых ресурсов операционной системы, а равно частота контекстных переключений (если число потоков превышает уровень аппаратного параллелизма), что негативно сказывается на производительности. В предельном случае у операционной системы могут закончиться ресурсы для запуска новых потоков, хотя пропускная способность сети еще не исчерпана. Поэтому в приложениях, обслуживающих очень большое число соединений, обычно создают совсем немного потоков (быть может, всего один), каждый из которых одновременно обрабатывает несколько запросов.

Рассмотрим один из таких потоков. Пакеты данных приходят по разным соединениям в случайном порядке, а потому и порядок помещения исходящих пакетов в очередь отправки тоже непредсказуем. Часто будет складываться ситуация, когда другие части приложения ждут либо успешной отправки данных, либо поступления нового пакета по конкретному сетевому соединению.

Шаблон std::promiseдает возможность задать значение (типа T), которое впоследствии можно будет прочитать с помощью ассоциированного объекта std::future. Пара std::promise/ std::futureреализует один из возможных механизмов такого рода; ожидающий поток приостанавливается в ожидании будущего результата, тогда как поток, поставляющий данные, может с помощью promiseустановить ассоциированное значение и сделать будущий результат готовым .

Чтобы получить объект std::future, ассоциированный с данным обещанием std::promise, мы должны вызвать функцию-член get_future()— так же, как в случае std::packaged_task. После установки значения обещания (с помощью функции-члена set_value()) будущий результат становится готовым , и его можно использовать для получения установленного значения. Если уничтожить объект std::promise, не установив значение, то в будущем результате будет сохранено исключение. О передаче исключений между потоками см. раздел 4.2.4.

В листинге 4.10 приведен код потока обработки соединений, написанный по только что изложенной схеме. В данном случае для уведомления об успешной передаче блока исходящих данных применяется пара std::promise/ std::future; ассоциированное с будущим результатом значение — это просто булевский флаг успех/неудача. Для входящих пакетов в качестве ассоциированных данных могла бы выступать полезная нагрузка пакета.

Листинг 4.10.Обработка нескольких соединений в одном потоке с помощью объектов-обещаний

#include

void process_connections(connection_set& connections) {

while(!done(connections)) { ← (1)

for (connection_iterator ← (2)

connection = connections.begin(), end = connections.end();

connection != end;

++connection) {

if (connection->has_incoming_data()) {← (3)

data_packet data = connection->incoming();

std::promise& p =

connection->get_promise(data.id); ← (4)

p.set_value(data.payload);

}

if (connection->has_outgoing_data()) {← (5)

outgoing_packet data =

connection->top_of_outgoing_queue();

connection->send(data.payload);