Параллельное программирование над общей памятью. POSIX Threads. Учебное пособие

2.Blaise Barney. POSIX Threads Programming [Electronic resource] // Lawrence Livermore National Laboratory. – URL: https://computing.llnl.gov/tutorials/pthreads/ (accessed: 28.07.2017).

3.Многопоточное программирование с использованием POSIX Threads [Электронный ресурс] // Национальный открытый университет «ИНТУИТ». – URL: http://www.intuit.ru/studies/professional_skill_improvements/16994/info (дата обращения: 04.08.2017).

4.Pthreads: Потоки в русле POSIX [Электронный ресурс] // Хабрахабр. – URL: https://habrahabr.ru/post/326138/ (дата обращения: 08.08.2017).

21

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

Тип объекта синхронизации:

pthread_mutex_t

Прототипы функций:

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

Параметры функций:

mutex – указатель на переменную типа «мьютекс»;

attr – указатель на атрибуты, которые получит мьютекс при инициализации (см. ниже); если указано NULL, то мьютекс получит атрибуты по умолчанию.

Сообщения об ошибках:

ноль – ошибки отсутствуют; pthread_mutex_init():

EAGAIN – недостаточно ресурсов (кроме памяти) для инициализации мьютекса;

ENOMEM – недостаточно памяти для инициализации мьютекса;

EPERM – недостаточно прав для выполнения операции;

pthread_mutex_lock() и pthread_mutex_trylock():

EAGAIN – мьютекс не может быть захвачен из-за превышения максимального количества рекурсивных захватов;

23

ENOTRECOVERABLE – невозможно восстановить целостное состояние данных, защищенных мьютексом;

EOWNERDEAD – поток, владевший мьютексом, завершился, не освободив его;

pthread_mutex_lock():

EDEADLK – текущий поток уже захватил мьютекс; pthread_mutex_trylock():

EBUSY – мьютекс не может быть захвачен, потому что его захватил другой поток;

pthread_mutex_unlock():

EPERM – поток не владеет мьютексом.

Важно отметить, что ответственность за корректное использование мьютексов (инициализация, захват, освобождение) полностью лежит на программисте.

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

Для обработки ошибок создан специальный макрос err_exit, который позволяет сократить объем кода, осуществляющего проверки на ошибки.

Пример 4. Использование мьютексов

#include <cstdlib> #include <iostream> #include <cstring> #include <pthread.h>

using namespace std;

#define err_exit(code, str) { cerr << str << ": " << strerror(code) \ << endl; exit(EXIT_FAILURE); }

const int TASKS_COUNT = 10;

int task_list[TASKS_COUNT]; // Массив заданий

24

void do_task(int task_no)

{

/* Сюда необходимо поместить код, выполняющий задание */

}

void *thread_job(void *arg)

{

int task_no; int err;

// Перебираем в цикле доступные задания while(true) {

//Захватываем мьютекс для исключительного доступа

//к указателю текущего задания (переменная

//current_task)

err = pthread_mutex_lock(&mutex); if(err != 0)

err_exit(err, "Cannot lock mutex");

//Запоминаем номер текущего задания, которое будем исполнять task_no = current_task;

//Сдвигаем указатель текущего задания на следующее current_task++;

//Освобождаем мьютекс

err = pthread_mutex_unlock(&mutex); if(err != 0)

err_exit(err, "Cannot unlock mutex");

//Если запомненный номер задания не превышает

//количества заданий, вызываем функцию, которая

//выполнит задание.

//В противном случае завершаем работу потока if(task_no < TASKS_COUNT)

do_task(task_no);

else

return NULL;

}

}

25

Прототипы функций:

int pthread_mutexattr_init(pthread_mutexattr_t *attr); int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);

int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr, int *restrict type);

int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);

int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr, int *restrict pshared);

Параметры функций:

attr – атрибуты мьютекса;

type – тип мьютекса (табл. 3);

pshared – видимость мьютекса (табл. 4);

Сообщения об ошибках:

ноль – ошибки отсутствуют; pthread_mutexattr_init():

ENOMEM – недостаточно памяти для инициализации объекта с атрибутами мьютекса;

pthread_mutexattr_settype():

EINVAL – значение атрибута «тип мьютекса» некорректно;

pthread_mutexattr_setpshared():

EINVAL – значение атрибута «видимость мьютекса» выходит за границы допустимых значений.

Атрибут мьютекса type влияет на поведение функций, захватывающих и освобождающих мьютекс. Всего стандарт определяет четыре типа мьютекса:

PTHREAD_MUTEX_NORMAL не допускает повторного захвата мьютекса; при попытке повторного захвата мьютекса потоком, который является его владельцем, происходит дедлок;

27

PTHREAD_MUTEX_ERRORCHECK не допускает повторного захвата мьютекса; предотвращает возникновение дедлоков, возвращая ошибку при попытке повторного захвата неосвобожденного мьютекса его владельцем;

PTHREAD_MUTEX_RECURSIVE допускает рекурсивный захват мьютекса одним и тем же потоком, однако затем поток должен столько же раз освободить мьютекс;

PTHREAD_MUTEX_DEFAULT является значением по умолчанию. Реа-

лизация Pthreads может отображать это значение на один из других трех типов.

Сводные характеристики различных типов мьютексов приведены в табл. 3.

Атрибут мьютекса pshared определяет возможность использова-

ния мьютекса потоками, принадлежащими разным процессам. Возможные значения атрибута приведены в табл. 4.

Таблица 4

Возможные значения атрибута pshared

28

СПИНЛОКИ

Спинлок (англ. spinlock – циклическая блокировка) – объект синхронизации, обеспечивающий взаимно исключающий доступ к ресурсу. Внешне спинлок очень похож на мьютекс, имеет аналогичный набор функций и принципы работы с ним. Разница заключается в технической реализации.

Вслучае мьютекса, если потоку не удается захватить блокировку, происходит переключение в режим ядра ОС3, где поток переводится в состояние «спящий» (см. раздел «Планирование потоков») и перестает расходовать ресурсы системы до момента освобождения мьютекса.

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

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

Тип объекта синхронизации:

pthread_spinlock_t

Прототипы функций:

int pthread_spin_init(pthread_spinlock_t *lock, int pshared); int pthread_spin_destroy(pthread_spinlock_t *lock);

int pthread_spin_lock(pthread_spinlock_t *lock); int pthread_spin_trylock(pthread_spinlock_t *lock); int pthread_spin_unlock(pthread_spinlock_t *lock);

3 В зависимости от операционной системы и конкретной реализации стандарта POSIX Threads технические детали могут существенно различаться.

29

Параметры функций:

lock – указатель на переменную типа «спинлок»;

pshared – видимость спинлока; возможные значения приведены в табл. 3.

Сообщения об ошибках:

ноль – ошибки отсутствуют; pthread_spin_init():

EAGAIN – недостаточно ресурсов (кроме памяти) для инициализации спинлока;

ENOMEM – недостаточно памяти для инициализации спинлока;

pthread_spin_trylock():

EBUSY – спинлок не может быть захвачен, потому что его захватил другой поток.

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

...

void *thread_job(void *arg)

{

...

// Захватываем спинлок

err = pthread_spin_lock(&lock); if(err != 0)

err_exit(err, "Cannot lock spinlock");

// Запоминаем номер текущего задания, которое будем исполнять task_no = current_task;

30