Журнал LinuxFormat - перейти на главную

LXF86:Unix API

Материал из Linuxformat
(Различия между версиями)
Перейти к: навигация, поиск
(Новая: {{Цикл/Unix API}} == Потоки: создание и уничтожение == ''ЧАСТЬ 7: Сегодня '''Андрей Боровский''' намерен рассказа...)
 
м (викификация)
 
Строка 1: Строка 1:
 
{{Цикл/Unix API}}
 
{{Цикл/Unix API}}
 
== Потоки: создание и уничтожение ==
 
== Потоки: создание и уничтожение ==
−
''ЧАСТЬ 7: Сегодня '''Андрей Боровский''' намерен рассказать о жизненном цикле потоков – от создания до принудительного завершения.''
+
''ЧАСТЬ 7: Сегодня '''Андрей Боровский''' намерен рассказать о жизненном цикле потоков — от создания до принудительного завершения.''
  
 
{| align="right"
 
{| align="right"
−
|“Processes are like human beings...<br />A small difference is that sex is not really common among<br />processes as each process has just one parent.”
+
|«Processes are like human beings…<br />A small difference is that sex is not really common among<br />processes as each process has just one parent.»
 
|-
 
|-
 
| <div align="right">Understanding the Linux Kernel, 3rd Edition<br />By Daniel P. Bovet, Marco Cesati</div>
 
| <div align="right">Understanding the Linux Kernel, 3rd Edition<br />By Daniel P. Bovet, Marco Cesati</div>
Строка 11: Строка 11:
 
многозадачности, точно так же как виртуальные машины,
 
многозадачности, точно так же как виртуальные машины,
 
позволяющие запускать несколько ОС на одном компьютере, представляют собой логическое развитие концепции разделения
 
позволяющие запускать несколько ОС на одном компьютере, представляют собой логическое развитие концепции разделения
−
ресурсов. В рамках неформального, но простого, определения, поток –
+
ресурсов. В рамках неформального, но простого, определения, поток -
 
это последовательность выполнения машинных инструкций. В многопоточном приложении одновременно работает несколько потоков.
 
это последовательность выполнения машинных инструкций. В многопоточном приложении одновременно работает несколько потоков.
 
Некоторые авторы избегают термина «поток» и используют вместо
 
Некоторые авторы избегают термина «поток» и используют вместо
Строка 26: Строка 26:
 
Потоки часто становятся источниками программных ошибок особого
 
Потоки часто становятся источниками программных ошибок особого
 
рода. Эти ошибки возникают при использовании потоками разделяемых ресурсов системы (например, общего адресного пространства) и
 
рода. Эти ошибки возникают при использовании потоками разделяемых ресурсов системы (например, общего адресного пространства) и
−
являются частным случаем более широкого класса ошибок – ошибок
+
являются частным случаем более широкого класса ошибок — ошибок
 
синхронизации. Если задача разделена между независимыми процессами, то доступом к их общим ресурсам управляет операционная
 
синхронизации. Если задача разделена между независимыми процессами, то доступом к их общим ресурсам управляет операционная
 
система, и вероятность ошибок из-за конфликтов доступа снижается. Впрочем, разделение задачи между несколькими независимыми
 
система, и вероятность ошибок из-за конфликтов доступа снижается. Впрочем, разделение задачи между несколькими независимыми
Строка 38: Строка 38:
  
 
Первая подсистема потоков в Linux появилась около 1996 года и
 
Первая подсистема потоков в Linux появилась около 1996 года и
−
называлась без лишних затей – LinuxThreads. Рудимент этой подсистемы, который вы найдете в любой современной системе Linux, – файл
+
называлась без лишних затей — LinuxThreads. Рудимент этой подсистемы, который вы найдете в любой современной системе Linux, — файл
−
/usr/include/pthread.h, указывает год выпуска – 1996 и имя разработчика – Ксавье Лерой (Xavier Leroy). Библиотека LinuxThreads была
+
/usr/include/pthread.h, указывает год выпуска — 1996 и имя разработчика — Ксавье Лерой (Xavier Leroy). Библиотека LinuxThreads была
 
попыткой организовать поддержку потоков в Linux в то время, когда
 
попыткой организовать поддержку потоков в Linux в то время, когда
 
ядро системы еще не предоставляло никаких специальных механизмов
 
ядро системы еще не предоставляло никаких специальных механизмов
 
для работы с ними. Позднее разработку потоков для Linux вели сразу
 
для работы с ними. Позднее разработку потоков для Linux вели сразу
−
две конкурирующие группы – NGPT и NPTL. В 2002 году группа NGPT
+
две конкурирующие группы — NGPT и NPTL. В 2002 году группа NGPT
 
фактически присоединилась к NPTL, и теперь реализация потоков
 
фактически присоединилась к NPTL, и теперь реализация потоков
 
NPTL является стандартом Linux. Подсистема потоков Linux стремится
 
NPTL является стандартом Linux. Подсистема потоков Linux стремится
Строка 50: Строка 50:
  
 
=== Потоки и процессы ===
 
=== Потоки и процессы ===
−
Тем, кто впервые познакомился с концепцией потоков, изучая программирование для Windows, модель потоков Linux покажется непривычной. В среде Microsoft Windows процесс – это контейнер для потоков
+
Тем, кто впервые познакомился с концепцией потоков, изучая программирование для Windows, модель потоков Linux покажется непривычной. В среде Microsoft Windows процесс — это контейнер для потоков
 
(именно этими словами о процессах говорит Джеффри Рихтер в своей
 
(именно этими словами о процессах говорит Джеффри Рихтер в своей
 
классической книге «Программирование приложений для Microsoft
 
классической книге «Программирование приложений для Microsoft
Строка 59: Строка 59:
 
В многопоточных приложениях Linux для создания дополнительных
 
В многопоточных приложениях Linux для создания дополнительных
 
потоков используются процессы особого типа. Эти процессы представляют собой обычные дочерние процессы главного процесса, но
 
потоков используются процессы особого типа. Эти процессы представляют собой обычные дочерние процессы главного процесса, но
−
они разделяют с главным процессом адресное пространство, файловые дескрипторы и обработчики сигналов. Для обозначения процессов этого типа, применяется специальный термин – легкие процессы
+
они разделяют с главным процессом адресное пространство, файловые дескрипторы и обработчики сигналов. Для обозначения процессов этого типа, применяется специальный термин — легкие процессы
 
(lightweight processes). Прилагательное «легкий» в названии процессов-потоков вполне оправдано. Поскольку этим процессам не нужно создавать собственную копию адресного пространства (и других ресурсов)
 
(lightweight processes). Прилагательное «легкий» в названии процессов-потоков вполне оправдано. Поскольку этим процессам не нужно создавать собственную копию адресного пространства (и других ресурсов)
 
своего процесса-родителя, создание нового легкого процесса требует
 
своего процесса-родителя, создание нового легкого процесса требует
Строка 82: Строка 82:
 
нужно еще определить с помощью макроса _syscall [это само по себе
 
нужно еще определить с помощью макроса _syscall [это само по себе
 
уже является явным намеком на то, что вам не следует усердствовать
 
уже является явным намеком на то, что вам не следует усердствовать
−
с ее использованием, – прим. ред.]. Работа с функцией gettid() выглядит примерно так:
+
с ее использованием, — прим. ред.]. Работа с функцией gettid() выглядит примерно так:
 
<source lang="C">#include <sys/types.h>
 
<source lang="C">#include <sys/types.h>
 
#include <linux/unistd.h>
 
#include <linux/unistd.h>
Строка 108: Строка 108:
 
Функция потока должна иметь заголовок вида:
 
Функция потока должна иметь заголовок вида:
 
<source lang="C">void * func_name(void * arg)</source>
 
<source lang="C">void * func_name(void * arg)</source>
−
Имя функции, естественно, может быть любым. Аргумент arg – это
+
Имя функции, естественно, может быть любым. Аргумент arg — это
 
тот самый указатель, который передается в последнем параметре
 
тот самый указатель, который передается в последнем параметре
 
функции pthread_create(). Функция потока может вернуть значение,
 
функции pthread_create(). Функция потока может вернуть значение,
Строка 117: Строка 117:
 
void *, становится возвращаемым значением функции потока. Как (и
 
void *, становится возвращаемым значением функции потока. Как (и
 
кому?) функция потока может вернуть значение, если она не вызывается из программы явным образом? Для того, чтобы получить значение, возвращенное функцией потока, нужно воспользоваться функцией {{man|pthread_join|3}}. У этой функции два параметра. Первый параметр,
 
кому?) функция потока может вернуть значение, если она не вызывается из программы явным образом? Для того, чтобы получить значение, возвращенное функцией потока, нужно воспользоваться функцией {{man|pthread_join|3}}. У этой функции два параметра. Первый параметр,
−
pthread_join(), – это идентификатор потока, второй параметр имеет
+
pthread_join(), — это идентификатор потока, второй параметр имеет
 
тип «указатель на нетипизированный указатель». В этом параметре
 
тип «указатель на нетипизированный указатель». В этом параметре
 
функция pthread_join() возвращает значение, возвращенное функцией
 
функция pthread_join() возвращает значение, возвращенное функцией
Строка 184: Строка 184:
 
Функция, вызываемая из нескольких потоков одновременно, должна
 
Функция, вызываемая из нескольких потоков одновременно, должна
 
обладать свойством реентерабельности (этим же свойством должны
 
обладать свойством реентерабельности (этим же свойством должны
−
обладать функции, допускающие рекурсию). Реентерабельная функция – это функция, которая может быть вызвана повторно, в то время, когда она уже выполняется (отсюда и происходит ее название).
+
обладать функции, допускающие рекурсию). Реентерабельная функция — это функция, которая может быть вызвана повторно, в то время, когда она уже выполняется (отсюда и происходит ее название).
 
Реентерабельные функции используют локальные переменные (и
 
Реентерабельные функции используют локальные переменные (и
 
локально выделенную память) в тех случаях, когда их не-реентерабельные аналоги могут воспользоваться глобальными переменными.
 
локально выделенную память) в тех случаях, когда их не-реентерабельные аналоги могут воспользоваться глобальными переменными.
Строка 219: Строка 219:
 
может случиться так, что первый поток будет запущен уже после того,
 
может случиться так, что первый поток будет запущен уже после того,
 
как переменной id будет присвоено значение 2. Тогда оба потока получат одно и то же значение id. Впрочем, мы можем использовать одну
 
как переменной id будет присвоено значение 2. Тогда оба потока получат одно и то же значение id. Впрочем, мы можем использовать одну
−
и ту же переменную для передачи данных функциям потока, если воспользуемся средствами синхронизации – им будет посвящена следующая статья.
+
и ту же переменную для передачи данных функциям потока, если воспользуемся средствами синхронизации — им будет посвящена следующая статья.
  
 
=== Досрочное завершение потока ===
 
=== Досрочное завершение потока ===
Строка 241: Строка 241:
 
... //Здесь поток завершать нельзя
 
... //Здесь поток завершать нельзя
 
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);</source>
 
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);</source>
−
Первый вызов pthread_setcancelstate() запрещает досрочное завершение потока, второй – разрешает. Если запрос на досрочное завершение потока поступит в тот момент, когда поток игнорирует эти
+
Первый вызов pthread_setcancelstate() запрещает досрочное завершение потока, второй — разрешает. Если запрос на досрочное завершение потока поступит в тот момент, когда поток игнорирует эти
 
запросы, выполнение запроса будет отложено до тех пор, пока функция pthread_setcancelstate() не будет вызвана с аргументом PTHREAD_CANCEL_ENABLE. Что именно произойдет дальше, зависит от более
 
запросы, выполнение запроса будет отложено до тех пор, пока функция pthread_setcancelstate() не будет вызвана с аргументом PTHREAD_CANCEL_ENABLE. Что именно произойдет дальше, зависит от более
 
тонких настроек потока. Рассмотрим пример программы (вы найдете
 
тонких настроек потока. Рассмотрим пример программы (вы найдете
Строка 290: Строка 290:
 
досрочного завершения (именно этот режим установлен по умолчанию), он выполнит запрос на досрочное завершение, только достигнув одной из точек отмены. В соответствии со стандартом POSIX, точками отмены являются вызовы многих «обычных» функций, например open(), pause() и write(). Про функцию printf() в документации
 
досрочного завершения (именно этот режим установлен по умолчанию), он выполнит запрос на досрочное завершение, только достигнув одной из точек отмены. В соответствии со стандартом POSIX, точками отмены являются вызовы многих «обычных» функций, например open(), pause() и write(). Про функцию printf() в документации
 
сказано, что она может быть точкой отмены, но в Linux при попытке
 
сказано, что она может быть точкой отмены, но в Linux при попытке
−
остановиться на printf() происходит нечто странное – поток завершается, но pthread_join() не возвращает управления. Поэтому мы
+
остановиться на printf() происходит нечто странное — поток завершается, но pthread_join() не возвращает управления. Поэтому мы
 
создаем явную точку отмены с помощью вызова pthread_testcancel().
 
создаем явную точку отмены с помощью вызова pthread_testcancel().
 
Впрочем, мы можем выполнить досрочное завершение потока, не
 
Впрочем, мы можем выполнить досрочное завершение потока, не

Текущая версия на 15:47, 14 декабря 2008

Подписка на печатную версию
Весь 2015 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Подписка на электронную версию
Весь 2015 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Подшивки старых номеров журнала (печатные версии)
Весь 2014 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)

[править] Потоки: создание и уничтожение

ЧАСТЬ 7: Сегодня Андрей Боровский намерен рассказать о жизненном цикле потоков — от создания до принудительного завершения.

«Processes are like human beings…
A small difference is that sex is not really common among
processes as each process has just one parent.»
Understanding the Linux Kernel, 3rd Edition
By Daniel P. Bovet, Marco Cesati

Многопоточность является естественным продолжением многозадачности, точно так же как виртуальные машины, позволяющие запускать несколько ОС на одном компьютере, представляют собой логическое развитие концепции разделения ресурсов. В рамках неформального, но простого, определения, поток - это последовательность выполнения машинных инструкций. В многопоточном приложении одновременно работает несколько потоков. Некоторые авторы избегают термина «поток» и используют вместо него термин «нить» (от англ. «thread»), вероятно для того, чтобы потоки программ не путались с потоками ввода-вывода. Для обозначения последовательного выполнения цепочки инструкций мне лично больше нравится термин «поток», которым я и буду пользоваться. Надеюсь, читатели Linux Format не запутаются в контекстах и, встретив слово поток, всегда поймут, идет ли речь о потоках программы, потоках ввода вывода, или о бурных паводковых потоках.

Прежде чем приступать к программированию потоков, следует ответить на вопрос: а нужны ли они вам. Мы уже знаем, насколько хорошо развиты в Linux средства межпроцессного взаимодействия. С помощью управления процессами в Linux можно решить многие задачи, которые в других ОС решаются только с помощью потоков. Потоки часто становятся источниками программных ошибок особого рода. Эти ошибки возникают при использовании потоками разделяемых ресурсов системы (например, общего адресного пространства) и являются частным случаем более широкого класса ошибок — ошибок синхронизации. Если задача разделена между независимыми процессами, то доступом к их общим ресурсам управляет операционная система, и вероятность ошибок из-за конфликтов доступа снижается. Впрочем, разделение задачи между несколькими независимыми процессами само по себе не защитит вас от других разновидностей ошибок синхронизации. В пользу потоков можно указать то, что накладные расходы на создание нового потока в многопоточном приложении обычно ниже, чем накладные расходы на создание нового самостоятельного процесса. Уровень контроля над потоками в многопоточном приложении выше, чем уровень контроля приложения над дочерними процессами. Кроме того, многопоточные программы не склонны оставлять за собой вереницы зомби или «осиротевших» независимых процессов.

Первая подсистема потоков в Linux появилась около 1996 года и называлась без лишних затей — LinuxThreads. Рудимент этой подсистемы, который вы найдете в любой современной системе Linux, — файл /usr/include/pthread.h, указывает год выпуска — 1996 и имя разработчика — Ксавье Лерой (Xavier Leroy). Библиотека LinuxThreads была попыткой организовать поддержку потоков в Linux в то время, когда ядро системы еще не предоставляло никаких специальных механизмов для работы с ними. Позднее разработку потоков для Linux вели сразу две конкурирующие группы — NGPT и NPTL. В 2002 году группа NGPT фактически присоединилась к NPTL, и теперь реализация потоков NPTL является стандартом Linux. Подсистема потоков Linux стремится соответствовать требованиям стандартов POSIX, так что новые многопоточные приложения Linux должны без проблем компилироваться на других POSIX-совместимых системах.

[править] Потоки и процессы

Тем, кто впервые познакомился с концепцией потоков, изучая программирование для Windows, модель потоков Linux покажется непривычной. В среде Microsoft Windows процесс — это контейнер для потоков (именно этими словами о процессах говорит Джеффри Рихтер в своей классической книге «Программирование приложений для Microsoft Windows»). Процесс-контейнер содержит как минимум один поток. Если потоков в процессе несколько, приложение (процесс) становится многопоточным. В мире Linux все выглядит иначе. В Linux каждый поток является процессом, и для того, чтобы создать новый поток, нужно создать новый процесс. В чем же, в таком случае, заключается преимущество многопоточности Linux перед многопроцессностью? В многопоточных приложениях Linux для создания дополнительных потоков используются процессы особого типа. Эти процессы представляют собой обычные дочерние процессы главного процесса, но они разделяют с главным процессом адресное пространство, файловые дескрипторы и обработчики сигналов. Для обозначения процессов этого типа, применяется специальный термин — легкие процессы (lightweight processes). Прилагательное «легкий» в названии процессов-потоков вполне оправдано. Поскольку этим процессам не нужно создавать собственную копию адресного пространства (и других ресурсов) своего процесса-родителя, создание нового легкого процесса требует значительно меньших затрат, чем создание полновесного дочернего процесса. Поскольку потоки Linux на самом деле представляют собой процессы, в мире Linux нельзя говорить, что один процесс содержит несколько потоков. Если вы скажете это, в вас тут же заподозрят вражеского лазутчика!

Интересно рассмотреть механизм, с помощью которого Linux решает проблему идентификаторов процессов-потоков. В Linux у каждого процесса есть идентификатор. Есть он, естественно, и у процессов-потоков. С другой стороны, спецификация POSIX 1003.1c требует, чтобы все потоки многопоточного приложения имели один идентификатор. Вызвано это требование тем, что для многих функций системы многопоточное приложение должно представляться как один процесс с одним идентификатором. Проблема единого идентификатора решается в Linux весьма элегантно. Процессы многопоточного приложения группируются в группы потоков (thread groups). Группе присваивается идентификатор, соответствующий идентификатору первого процесса многопоточного приложения. Именно этот идентификатор группы потоков используется при «общении» с многопоточным приложением. Функция

потока, независимо от того, из какого потока она вызвана. Функции kill(), waitpid() и им подобные по умолчанию также используют идентификаторы групп потоков, а не отдельных процессов. Вам вряд ли понадобится узнавать собственный идентификатор процесса-потока, но если вы захотите это сделать, вам придется воспользоваться довольно экзотичной конструкцией. Получить идентификатор потока (thread ID) можно с помощью функции gettid(2), однако саму функцию нужно еще определить с помощью макроса _syscall [это само по себе уже является явным намеком на то, что вам не следует усердствовать с ее использованием, — прим. ред.]. Работа с функцией gettid() выглядит примерно так: 

#include <sys/types.h>
#include <linux/unistd.h>
...
_syscall0(pid_t,gettid)
...
pid_t my_tid;
my_tid = gettid();

Более подробную информацию вы можете получить на страницах man, посвященных gettid() и _syscall.

Потоки создаются функцией

заголовочном файле pthread.h. Первый параметр этой функции представляет собой указатель на переменную типа pthread_t, которая служит идентификатором создаваемого потока. Второй параметр, указатель на переменную типа pthread_attr_t, используется для передачи атрибутов потока. Третьим параметром функции pthread_create() должен быть адрес функции потока. Эта функция играет для потока ту же роль, что функция main() для главной программы. Четвертый параметр функции pthread_create() имеет тип void *. Этот параметр может использоваться для передачи функции потока произвольного аргумента. Вскоре после вызова pthread_create() функция потока будет запущена на выполнение параллельно с другими потоками программы. Таким образом, собственно, и создается новый поток. Я говорю, что новый поток запускается «вскоре» после вызова pthread_create() потому, что перед тем как запустить новую функцию потока, нужно выполнить некоторые подготовительные действия, а поток-родитель, между тем, продолжает выполняться. Непонимание этого факта может привести вас к ошибкам, которые будет трудно обнаружить. Если в ходе создания потока возникла ошибка, функция pthread_create() возвращает ненулевое значение, соответствующее номеру ошибки.

Функция потока должна иметь заголовок вида: 

void * func_name(void * arg)

Имя функции, естественно, может быть любым. Аргумент arg — это тот самый указатель, который передается в последнем параметре функции pthread_create(). Функция потока может вернуть значение, которое затем будет проанализировано заинтересованным потоком, но это не обязательно. Завершение функции потока происходит, если (а) функция потока вызвала функцию

потоком. Функция pthread_exit() представляет собой потоковый аналог функции _exit(). Аргумент функции pthread_exit(), значение типа void *, становится возвращаемым значением функции потока. Как (и кому?) функция потока может вернуть значение, если она не вызывается из программы явным образом? Для того, чтобы получить значение, возвращенное функцией потока, нужно воспользоваться функцией

pthread_join(), — это идентификатор потока, второй параметр имеет тип «указатель на нетипизированный указатель». В этом параметре функция pthread_join() возвращает значение, возвращенное функцией потока. Конечно, в многопоточном приложении есть и более простые способы организовать передачу данных между потоками. Основная задача функции pthread_join() заключается, однако, в синхронизации потоков. Вызов функции pthread_join() приостанавливает выполнение вызвавшего ее потока до тех пор, пока поток, чей идентификатор передан функции в качестве аргумента, не завершит свою работу. Если в момент вызова pthread_join() ожидаемый поток уже завершился, функция вернет управление немедленно. Функцию pthread_join() можно рассматривать как эквивалент

выполнить более одного вызова pthread_join() (из разных потоков) для одного и того же потока приведет к ошибке.

Посмотрим, как все это работает на практике. Ниже приводится фрагмент листинга программы threads, полный текст которой вы найдете на прилагаемом диске в файле threads.c: 

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <pthread.h>
void * thread_func(void *arg)
{
int i;
int loc_id = * (int *) arg;
for (i = 0; i < 4; i++) {
printf("Thread %i is running\n", loc_id);
sleep(1);
}
}
int main(int argc, char * argv[])
{
int id1, id2, result;
pthread_t thread1, thread2;
id1 = 1;
result = pthread_create(&thread1, NULL, thread_func, &id1);
if (result != 0) {
perror("Creating the first thread");
return EXIT_FAILURE;
}
id2 = 2;
result = pthread_create(&thread2, NULL, thread_func, &id2);
if (result != 0) {
perror("Creating the first thread");
return EXIT_FAILURE;
}
result = pthread_join(thread1, NULL);
if (result != 0) {
perror("Joining the first thread");
return EXIT_FAILURE;
}
result = pthread_join(thread2, NULL);
if (result != 0) {
perror("Joining the first thread");
return EXIT_FAILURE;
}
printf("Done\n");
return EXIT_SUCCESS;
}

Рассмотрим сначала функцию thread_func(). Как вы, конечно, догадались, это и есть функция потока. Наша функция потока очень проста. В качестве аргумента ей передается указатель на переменную типа int, в которой содержится номер потока. Функция потока распечатывает этот номер несколько раз с интервалом в одну секунду и завершает свою работу. В функции main() вы видите две переменных типа pthread_t. Мы собираемся создать два потока, и у каждого из них должен быть свой идентификатор. Вы также видите две переменные типа int, id1 и id2, которые используются для передачи функциям потоков их номеров. Сами потоки создаются с помощью функции pthread_create().В этом примере мы не модифицируем атрибуты потоков, поэтому во втором параметре в обоих случаях передаем NULL. Вызывая pthread_create() дважды, мы оба раза передаем в качестве третьего параметра адрес функции thread_func, в результате чего два созданных потока будут выполнять одну и ту же функцию. Функция, вызываемая из нескольких потоков одновременно, должна обладать свойством реентерабельности (этим же свойством должны обладать функции, допускающие рекурсию). Реентерабельная функция — это функция, которая может быть вызвана повторно, в то время, когда она уже выполняется (отсюда и происходит ее название). Реентерабельные функции используют локальные переменные (и локально выделенную память) в тех случаях, когда их не-реентерабельные аналоги могут воспользоваться глобальными переменными.

Мы вызываем последовательно две функции pthread_join() для того, чтобы дождаться завершения обоих потоков. Если мы хотим дождаться завершения всех потоков, порядок вызова функций pthread_join() для разных потоков, очевидно, не имеет значения. Для того, чтобы скомпилировать программу threads.c, необходимо дать следующую команду: 

gcc threads.c -D_REENTERANT -I/usr/include/nptl -L/usr/lib/nptl --lpthread -o threads

Команда компиляции включает макрос _REENTERANT. Этот макрос указывает, что вместо обычных функций стандартной библиотеки к программе должны быть подключены их реентерабельные аналоги. Реентерабельный вариант библиотеки glibc написан таким образом, что вы, скорее всего, вообще не обнаружите никаких различий в работе с реентерабельными функциями по сравнению с их обычными аналогами. Мы указываем компилятору путь для поиска заголовочных файлов и путь для поиска библиотек /usr/include/nptl и /usr/lib/nptl соответственно. Наконец, мы указываем компоновщику, что программа должна быть связана с библиотекой libpthread, которая содержит все специальные функции, необходимые для работы с потоками.

У вас, возможно, возникает вопрос, зачем мы использовали две разные переменные, id1 и id2, для передачи значений двум потокам? Почему нельзя использовать одну переменную, скажем id, для обоих потоков? Рассмотрим такой фрагмент кода: 

id = 1;
pthread_create(&thread1, NULL, thread_func, &id);
id = 2;
pthread_create(&thread2, NULL, thread_func, &id);

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

[править] Досрочное завершение потока

Функции потоков можно рассматривать как вспомогательные программы, находящиеся под управлением функции main(). Точно так же, как при управлении процессами, иногда у программы возникает необходимость досрочно завершить один из потоков. Для этого можно воспользоваться функцией

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

будет ли поток реагировать на обращение к нему с помощью pthread_cancel(), или не будет. У функции pthread_setcancelstate() два параметра, параметр state типа int и параметр oldstate типа «указатель на int». В первом параметре передается новое значение, указывающее, как поток должен реагировать на запрос pthread_cancel(), а в переменную, чей адрес был передан во втором параметре, функция записывает прежнее значение. Если прежнее значение вас не интересует, во втором параметре можно передать NULL. Чаще всего функция pthread_setcancelstate() используется для временного запрета завершения потока. Допустим, мы программируем поток, и знаем, что при определенных условиях программа может потребовать его досрочного завершения. Но в нашем потоке есть участок кода, во время выполнения которого завершать поток крайне нежелательно. Мы можем оградить этот участок кода от досрочного завершения с помощью пары вызовов pthread_setcancelstate(): 

pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
... //Здесь поток завершать нельзя
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

Первый вызов pthread_setcancelstate() запрещает досрочное завершение потока, второй — разрешает. Если запрос на досрочное завершение потока поступит в тот момент, когда поток игнорирует эти запросы, выполнение запроса будет отложено до тех пор, пока функция pthread_setcancelstate() не будет вызвана с аргументом PTHREAD_CANCEL_ENABLE. Что именно произойдет дальше, зависит от более тонких настроек потока. Рассмотрим пример программы (вы найдете ее на диске в файле canceltest.c) 

#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
int i = 0;
void * thread_func(void *arg)
{
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
for (i=0; i < 4; i++) {
sleep(1);
printf("I’m still running!\n");
}
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_testcancel();
printf("YOU WILL NOT STOP ME!!!\n");
}
int main(int argc, char * argv[])
{
pthread_t thread;
pthread_create(&thread, NULL, thread_func, NULL);
while (i < 1) sleep(1);
pthread_cancel(thread);
printf("Requested to cancel the thread\n");
pthread_join(thread, NULL);
printf("The thread is stopped.\n");
return EXIT_SUCCESS;
}

В самом начале функции потока thread_func() мы запрещаем досрочное завершение потока, затем выводим четыре тестовых сообщения с интервалом в одну секунду, после чего разрешаем досрочное завершение. Далее, с помощью функции pthread_testcancel(), мы создаем точку отмены (cancellation point) нашего потока. Если досрочное завершение потока было затребовано, в этот момент поток должен завершиться. Затем мы выводим еще одно диагностическое сообщение, которое пользователь не должен видеть, если программа работает правильно.

В главной функции программы мы создаем поток, затем дожидаемся, пока значение глобальной переменной i станет больше нуля (это гарантирует нам, что поток уже запретил досрочное завершение) и вызываем функцию pthread_cancel(). После этого мы переходим к ожиданию завершения потока с помощью pthread_join(). Если вы скомпилируете и запустите программу, то увидите, что поток распечатает четыре тестовых сообщения I’m still running! (после первого сообщения главная функция программы выдаст запрос на завершение потока). Поскольку поток завершится досрочно, последнего тестового сообщения вы не увидите.

Интересна роль функции pthread_testcancel(). Как уже отмечалось, эта функция создает точку отмены потока. Зачем нужны особые точки отмены? Дело в том, что даже если досрочное завершение разрешено, поток, получивший запрос на досрочное завершение, может остановиться не сразу. Если поток находится в режиме отложенного досрочного завершения (именно этот режим установлен по умолчанию), он выполнит запрос на досрочное завершение, только достигнув одной из точек отмены. В соответствии со стандартом POSIX, точками отмены являются вызовы многих «обычных» функций, например open(), pause() и write(). Про функцию printf() в документации сказано, что она может быть точкой отмены, но в Linux при попытке остановиться на printf() происходит нечто странное — поток завершается, но pthread_join() не возвращает управления. Поэтому мы создаем явную точку отмены с помощью вызова pthread_testcancel(). Впрочем, мы можем выполнить досрочное завершение потока, не дожидаясь точек останова. Для этого необходимо перевести поток в режим немедленного завершения, что делается с помощью вызова 

pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

В этом случае беспокоиться о точках останова уже не нужно. Вызов 

pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);

снова переводит поток в режим отложенного досрочного завершения.

Тема потоков практически неисчерпаема (простите за каламбур), но мы посвятим потокам еще лишь только одну статью, в которой рассмотрим вопросы синхронизации и атрибуты потоков.

Источник — «http://wiki.linuxformat.ru/wiki/index.php?title=LXF86:Unix_API&oldid=5977»
Персональные инструменты
купить
подписаться
Яндекс.Метрика