Книга: Основы программирования в Linux

Первая программа с применением потоков

Первая программа с применением потоков

Существует целый ряд библиотечных вызовов, связанных с потоками, большинство имен которых начинается с префикса pthread. Для применения этих библиотечных вызовов вы должны определить макрос _REENTRANT, включить файл pthread.h и скомпоновать программу с библиотекой потоков, используя опцию -lpthread.

Когда разрабатывались первые версии библиотечных подпрограмм UNIX и POSIX, предполагалось, что в каждом процессе будет только один поток исполнения. Яркий пример — переменная errno, применяемая для хранения сведений об ошибке после аварийного завершения вызова. В многопоточной программе по умолчанию будет одна переменная errno, совместно используемая всеми потоками. Переменная может легко быть изменена вызовом в одном потоке до того, как другой поток успеет извлечь код предыдущей ошибки. Аналогичные проблемы есть и у функций, таких как fputs, которые, как правило, используют одну глобальную область для буферизации вывода.

Вам нужны реентерабельные подпрограммы. Реентерабельный программный код может вызываться несколько раз либо разными потоками, либо каким-то образом вложенными вызовами и при этом работать корректно. Следовательно, реентерабельная часть программного кода обычно должна применять локальные переменные таким образом, чтобы любой и каждый вызов кода получал собственную уникальную копию данных.

В многопоточных программах вы сообщаете компилятору, что вам нужно это средство, определяя в вашей программе макрос _REENTRANT до любых директив #include. При этом делаются три вещи и столь искусно, что обычно вам даже не нужно знать, какая работа проделана.

? Некоторые функции получают безопасный реентерабельный вариант прототипа или объявления. При этом имя функции остается обычно прежним, но в конце добавляется суффикс _r, например функция gethostbyname заменяется функцией gethostbyname_r.

? Некоторые функции из файла stdio.h, которые обычно реализованы как макросы, становятся соответствующими реентерабельными безопасными функциями.

? Переменная errno из файла errno.h заменяется вызовом функции, которая может определить действительное значение errno безопасным образом с точки зрения многопоточности.

Включение файла pthread.h предоставляет другие прототипы и определения, которые нужны в вашем программном коде, во многом так же, как делает stdio.h для подпрограмм стандартного ввода и вывода. В заключение следует убедиться в том, что вы включили в программу соответствующий заголовочный файл потоков и скомпоновали программу с подходящей библиотекой потоков, в которой реализованы функции семейства pthread. Позже в упражнении данного раздела приведены подробности, касающиеся компиляции вашей программы, но сначала рассмотрим новые функции, необходимые для управления потоками. Функция pthread_create создает новый поток во многом так же, как функция fork создает новый процесс.

#include <pthread.h>
int pthread_create(pthread_t * thread, pthread_attr_t *attr,
 void *(*start_routine)(void *), void *arg);

Прототип выглядит внушительно, но функцию очень легко применять. Первый аргумент — указатель на переменную типа pthread_t. Когда поток создан, в область памяти, на которую указывает эта переменная, записывается идентификатор. Этот идентификатор позволяет ссылаться на поток. Следующий аргумент задает атрибуты потока. Обычно нет нужды в особых атрибутах, и вы можете просто передать в этом аргументе NULL. Позже в этой главе вы увидите, как применять атрибуты потока. В последних двух аргументах потоку передается функция, которую он должен начать выполнять, и аргументы, которые нужно передать этой функции.

void *(*start_routine)(void *)

Предыдущая строка просто говорит о том, что вы должны передать адрес функции, принимающей бестиповой указатель void как параметр, и функция вернет указатель на void. Следовательно, вы можете передать единственный аргумент любого типа и вернуть указатель на любой тип. Применение функции fork заставит продолжить выполнение в том же месте, но с другим кодом возврата, в то время как использование нового потока непосредственно предоставит указатель на функцию, которую новый поток должен начать выполнять.

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

Когда поток завершается, он вызывает функцию pthread_exit, во многом так же, как процесс во время завершения вызывает exit. Функция завершает вызванный поток, возвращая указатель на объект. Никогда не применяйте ее для возврата указателя на локальную переменную, потому что переменная перестает существовать, когда поток завершается, вызывая серьезную ошибку. Функция pthread_exit объявляется следующим образом:

#include <рthread.h>
void pthread_exit(void *retval);

Функция pthread_join — эквивалент функции wait, которую процессы применяют для ожидания дочерних процессов. Она объявляется так:

#include <рthread.h>
int pthread_join(pthread_t th, void** thread_return);

Первый параметр — это поток, который следует ждать, идентификатор, который для вас добывает функция pthread_create. Второй аргумент — указатель на указатель, который указывает на возвращаемое из потока значение. Как и pthread_create, эта функция возвращает ноль в случае успешного завершения и код ошибки при сбое.

Выполните упражнение 12.1.

Данная программа создает один дополнительный поток, показывает, что он совместно с исходным потоком использует переменные и заставляет новый поток вернуть результат исходному потоку. Далее приведена программа thread1.с.

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
void *thread_function(void *arg);
char message[] = "Hello World";
int main() {
 int res;
 pthread_t a_thread;
 void *thread_result;
 res = pthread_create(&a_thread, NULL, thread_function, (void *)message);
 if (res ! = 0) {
  perror("Thread creation failed");
  exit(EXIT_FAILURE);
 }
 printf("Waiting for thread to finish...n");
 res = pthread_join(a_thread, &thread_result);
 if (res != 0) {
  perror("Thread join-failed");
  exit(EXIT_FAILURE);
 }
 printf("Thread-joined, it returned %sn", (char *)thread_result);
 printf("Message is now %sn", message);
 exit(EXIT_SUCCESS);
}
void *thread_function(void *arg) {
 printf("thread_function is running. Argument was %sn", (char *)arg);
 sleep(3);
 strcpy(message, "Bye!");
 pthread_exit("Thank you for the CPU time");
}

Итак:

1. Перед компиляцией программы вы должны убедиться в том, что определен макрос _REENTRANT. В некоторых системах вы также должны определить _POSIX_C_SOURCE, но обычно в этом нет необходимости.

2. Далее вы должны убедиться в том, что программа скомпонована с подходящей библиотекой потоков. В случае маловероятной ситуации применения старой версии дистрибутива Linux, в которой NPTL не является библиотекой потоков по умолчанию, возможно, у вас возникнет желание обновить ее, хотя большая часть программного кода, приведенного в этой главе, совместима со старой реализацией потоков в Linux. Легкий способ проверить — заглянуть в файл /usr/include/pthread.h. Если в этом файле приведен в качестве даты авторского права (copyright date) 2003 г. или более поздний, почти наверняка у вас реализация NPTL. Если указана более ранняя дата, может быть, самое время получить современную версию дистрибутива Linux.

3. Определив и установив нужные файлы, вы можете откомпилировать и скомпоновать вашу программу следующим образом:

$ cc -D_REENTRANT -I/usr/include/nptl threadl.с -о thread1 -L/usr/lib/nptl -lpthread

4. Когда вы выполните эту программу, то увидите следующие строки:

$ ./thread1
Waiting for thread to finish...
thread_function is running. Argument was Hello World
Thread joined, it returned Thank you for the CPU time
Message is now Bye!

Стоит потратить немного времени на анализ данной программы, поскольку мы будем использовать ее как основу в большинстве примеров этой главы.

Как это работает

Вы объявляете прототип функции, которую вызовет поток, когда вы его создадите:

void *thread_function(void *arg);

Как требует функция pthread_create, данная функция принимает в качестве своего единственного параметра указатель на void и возвращает указатель на void. (Мы перейдем к реализации thread_function через минуту.)

В функции main объявлено несколько переменных и затем осуществляется вызов функции pthread_create, чтобы начать выполнение нового потока.

pthread_t a_thread;
void *thread_result;
res = pthread_create(&a_thread, NULL, thread_function, (void *)message);

Вы передаете адрес объекта типа pthread_t, который можете применять в дальнейшем для ссылки на поток. Вы не хотите менять атрибуты потока, заданные по умолчанию, поэтому во втором параметре передаете NULL. Последние два параметра — вызываемая функция и передаваемый ей параметр.

Если вызов завершился нормально, теперь выполняются два потока. Исходный поток (main) продолжается и выполняет код, расположенный следом за функцией pthread_create, а новый поток начинает выполнение в функции, образно названной thread_function.

Исходный поток проверяет, запустился ли новый поток, и затем вызывает функцию pthread_join:

res = pthread_join(a_thread, &thread_result);

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

Новый поток начинает выполнение, запуская функцию thread_function, которая выводит свои аргументы, засыпает на короткий период, обновляет глобальные переменные и затем завершается, возвращая строку в поток main. Новый поток пишет в тот же массив message, к которому у исходного потока есть доступ. Если бы вы вызвали функцию fork вместо pthread_create, массив представлял бы собой копию массива message, а не сам массив.

Оглавление книги