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

Последнее перемещение (6)передает владение потоком, исполняющим some_function, обратно объекту t1, в котором исполнение этой функции началось. Однако теперь с t1уже связан поток (который исполнял функцию some_other_function), поэтому вызывается std::terminate(), и программа завершается. Так делается ради совместимости с поведением деструктора std::thread. В разделе 2.1.1 мы видели, что нужно либо явно ждать завершения потока, либо отсоединить его до момента уничтожения; то же самое относится и к присваиванию: нельзя просто «прихлопнуть» поток, присвоив новое значение объекту std::thread, который им управляет.

Поддержка операции перемещения в классе std::threadозначает, что владение можно легко передать при возврате из функции, как показано в листинге 2.5.

Листинг 2.5.Возврат объекта std::threadиз функции

std::thread f() {

void some_function();

return std::thread(some_function);

}

std::thread g() {

void some_other_function(int);

std::thread t(some_other_function, 42);

return t;

}

Аналогично, если требуется передать владение внутрь функции, то достаточно, чтобы она принимала экземпляр std::threadпо значению в качестве одного из параметров, например:

void f(std::thread t);

void g() {

void some_function();

f(std::thread(some_function));

std::thread t(some_function);

f(std::move(t));

}

Одно из преимуществ, которые даёт поддержка перемещения в классе std::thread, заключается в том, что мы можем модифицировать класс thread_guardиз листинга 2.3, так чтобы он принимал владение потоком. Это позволит избежать неприятностей в случае, когда время жизни объекта thread_guardоказывает больше, чем время жизни потока, на который он ссылается, а, кроме того, это означает, что никто другой не сможет присоединиться к потоку или отсоединить его, так как владение было передано объекту thread_guard. Поскольку основное назначение этого класса гарантировать завершение потока до выхода из области видимости, я назвал его scoped_thread. Реализация и простой пример использования приведены в листинге 2.6.

Листинг 2.6.Класс scoped_threadи пример его использования

class scoped_thread {

std::thread t;

public:

explicit scoped_thread(std::thread t_) : ← (1)

t(std::move(t_)) {

if (!t.joinable()) ← (2)

throw std::logic_error("No thread");

}

~scoped_thread() {

t.join(); ← (3)

}

scoped_thread(scoped_thread const&)=delete;

scoped_thread& operator=(scoped_thread const&)=delete;

};

struct func; ← см. листинг 2.1

void f() {

int some_local_state;

scoped_thread t(std::thread(func(some_local_state))); ← (4)

do_something_in_current_thread();

} ← (5)

Этот пример очень похож на приведенный в листинге 2.3, только новый поток теперь передается непосредственно конструктору scoped_thread (4), вместо того чтобы создавать для него отдельную именованную переменную. Когда новый поток достигает конца f (5), объект scoped_threadуничтожается, а затем поток соединяется (3)с потоком, переданным конструктору (1). Если в классе thread_guardиз листинга 2.3 деструктор должен был проверить, верно ли, что поток все еще допускает соединение, то теперь мы можем сделать это в конструкторе (2)и возбудить исключение, если это не так.

Поддержка перемещения в классе std::threadпозволяет также хранить объекты этого класса в контейнере при условии, что класс контейнера поддерживает перемещение (как, например, модифицированный класс std::vector<>). Это означает, что можно написать код, показанный в листинге 2.7, который запускает несколько потоков, а потом ждет их завершения.

Листинг 2.7.Запуск нескольких потоков и ожидание их завершения

void do_work(unsigned id);

void f() {

std::vector threads;

for (unsigned i = 0; i < 20; ++i) { │ Запуск

threads.push_back(std::thread(do_work(i))); ←┘ потоков

} │ Поочередный

std::for_each(threads.begin(), threads.end(),│ вызов join()

std::mem_fn(&std::thread::join)); ←┘ для каждого потока

}

Если потоки применяются для разбиения алгоритма на части, то зачастую такой подход именно то, что требуется: перед возвратом управления вызывающей программе все потоки должны завершиться. Разумеется, столь простая структура, как в листинге 2.7, предполагает, что каждый поток выполняет независимую работу, а единственным результатом является побочный эффект, заключающийся в изменении разделяемых данных. Если бы функция f()должна была вернуть вызывающей программе значение, зависящее от результатов операций, выполненных в потоках, то при такой организации получить это значение можно было бы только путем анализа разделяемых данных по завершении всех потоков. В главе 4 обсуждаются альтернативные схемы передачи результатов работы из одного потока в другой.

Хранение объектов std::threadв векторе std::vector— шаг к автоматизации управления потоками: вместо тот чтобы создавать отдельные переменные для потоков и выполнять соединение напрямую, мы можем рассматривать группу потоков. Можно пойти еще дальше и создавать не фиксированное число потоков, как в листинге 2.7, а определять нужное количество динамически, во время выполнения.

В стандартной библиотеке С++ есть функция std::thread::hardware_concurrency(), которая поможет нам решить эту задачу. Она возвращает число потоков, которые могут работать по-настоящему параллельно. В многоядерной системе это может быть, например, количество процессорных ядер. Возвращаемое значение всего лишь оценка; более того, функция может возвращать 0, если получить требуемую информацию невозможно. Однако эту оценку можно с пользой применить для разбиения задачи на несколько потоков.

В листинге 2.8 приведена простая реализация параллельной версии std::accumulate. Она распределяет работу между несколькими потоками и, чтобы не создавать слишком много потоков, задает ограничение снизу на количество элементов, обрабатываемых одним потоком. Отмстим, что в этой реализации предполагается, что ни одна операция не возбуждает исключений, хотя в принципе исключения возможны; например, конструктор std::threadвозбуждает исключение, если не может создать новый поток. Но если добавить в этот алгоритм обработку исключений, он перестанет быть таким простым; эту тему мы рассмотрим в главе 8.

Листинг 2.8.Наивная реализация параллельной версии алгоритма std::accumulate

template

struct accumulate_block {

void operator()(Iterator first, Iterator last, T& result) {