PTHREAD_PROCESS_PRIVATE (значение по умолчанию) - мьютекс может использоваться только потоками, порожденными в том же процессе, где был инициализирован мьютекс. В документации сказано: попытка захвата мьютекса с таким значением параметра доступа к потокам из "чужого" процесса приведет к неопределенному результату. На практике же функция захвата возвращает управление в любом случае, независимо от того, был ли уже захвачен мьютекс другим потоком или нет (как будто происходит нормальный захват). Состояние мьютекса при этом никак не меняется.
Разрешение рекурсивного захвата
int pthread_mutexattr_setrecursive(
pthread_mutexattr_t* attr, int recursive);
int pthread_mutexattr_getrecursive(
const pthread_mutexattr_t* attr, int* recursive);
Функции устанавливают/считывают в атрибутной записи мьютекса признак, определяющий, может ли поток, ранее захвативший мьютекс (его владелец), захватить его еще раз (естественно, что любой другой поток захватить такой мьютекс уже не может и он будет заблокирован). Режим реализован для возможности рекурсивного вызова процедур в потоке. Необходимо помнить, что при рекурсивном захвате мьютекс должен быть освобожден столько раз, сколько раз он был захвачен. Параметр recursive может принимать следующие значения:
PTHREAD_RECURSIVE_ENABLE - разрешает рекурсивный захват мьютекса;
PTHREAD_RECURSIVE_DISABLE (значение по умолчанию) - запрещает рекурсивный захват мьютекса. В результате при попытке захвата мьютекса потоком, который им уже владеет, вызов pthread_mutex_lock() не приведет к захвату мьютекса и вернет значение EDEADLK.
Определение типа мьютекса
int pthread_mutexattr_settype(
pthread_mutexattr_t* attr, int type);
int pthread_mutexattr_gettype(
const pthread_mutexattr_t* attr, int* type);
В версиях QNX 6.2.1 и 6.3 предусматривается создание мьютексов следующих типов:
• PTHREAD_MUTEX_NORMAL - для этого типа не проводится контроль "мертвой блокировки" (deadlock) в ситуации, когда поток, захвативший мьютекс, пытается захватить его повторно. Поэтому при попытке повторного захвата такого мьютекса тем же потоком этот поток будет безусловно блокирован (то есть он попадает в "мертвую блокировку", а это во всех случаях аварийная ситуация в выполнении приложения); такой мьютекс уже некому разблокировать (мьютекс может разблокироваться только своим владельцем). Попытка освободить (unlock) мьютекс такого типа, захваченный другим потоком, или освободить незахваченный мьютекс ни к чему не приводит, при этом не возвращается ошибка выполнения.
• PTHREAD_MUTEX_ERRORCHECK - включается контроль ошибок. В этом режиме регистрируются следующие ситуации:
• попытка повторного захвата мьютекса тем же потоком;
• попытка освобождения мьютекса, захваченного другим потоком;
• освобождение свободного мьютекса.
• PTHREAD_MUTEX_RECURSIVE - мьютекс, допускающий рекурсивный захват. Поток, пытающийся захватить мьютекс, уже захваченный в этом потоке, сможет это сделать, при этом количество захватов будет учитываться при освобождении мьютекса. Другой поток сможет захватить такой мьютекс только тогда, когда он будет освобожден столько же раз, сколько был захвачен. Если поток пытается освободить мьютекс, захваченный другим потоком, или свободный мьютекс, то будет возвращено сообщение об ошибке (регистрируются ошибки, предусмотренные предыдущим типом, за исключением повторного захвата, который является для рекурсивного мьютекса штатным действием).
Примечание
Обратите внимание, что разрешение рекурсивного захвата мьютекса необходимо проводить установкой двух параметров (type и recursive).
• PTHREAD_MUTEX_DEFAULT (значение по умолчанию) - попытка рекурсивного захвата мьютекса, освобождения мьютекса, захваченного другим потоком, или освобождения уже свободного мьютекса ни к чему не приводит и не возвращает ошибку выполнения.
Освобождение параметров
int pthread_mutexattr_destroy(pthread_mutexattr_t* attr);
Вызов разрушает ранее применявшийся объект - атрибутную запись мьютекса, после чего она уже не может более использоваться для инициализации мьютекса без предварительного выполнения вызова pthread_mutexattr_init().
На этом обсуждение атрибутов заканчивается, и мы переходим непосредственно к функциям работы с мьютексом.
Операции над мьютексом
Инициализация мьютекса
int pthread_mutex_init(pthread_mutex_t* mutex,
const pthread_mutexattr_t* attr);
Структура данных pthread_mutex_t определена в файле <pthread.h> (производный тип от типа sync_t, который в свою очередь определен в файле <target_nto.h>) и имеет следующий вид:
struct _sync_t {
/* Счетчик для рекурсивного мьютекса или семафора */
int count;
/* TID потока - имеет смысл и применяется только для мьютексов */
unsigned owner;
};
Функция pthread_mutex_init() инициализирует переданный объект мьютекс в соответствии со значением переданных атрибутов. Если вместо attr передать NULL, то мьютекс будет создан в соответствии со значениями атрибутов по умолчанию. В native QNX API эта функция реализуется вызовом SyncTypeCreate(). SyncTypeCreate() - единая функция для создания всех базовых объектов синхронизации QNX Neutrino.
Вместо прямого вызова функции pthread_mutex_init() для начальной инициализации статических мьютексов (глобальных на уровне файла кода или пространства имен namespace либо явно описанных с квалификатором static) можно воспользоваться двумя макросами PTHREAD_MUTEX_INITIALIZER и PTHREAD_RMUTEX_INITIALIZER:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_RMUTEX_INITIALIZER;
Первый из них создает мьютекс в соответствии со значениями атрибутов по умолчанию, а второй - мьютекс с разрешенным рекурсивным захватом.
Операции с граничным приоритетом
Большинство параметров мьютекса не могут быть изменены после его создания. Но не все. В процессе работы с мьютексом может быть изменено значение приоритета, которое система использует для реализации протокола граничного приоритета с целью предотвращения инверсии приоритетов:
int pthread_mutex_setprioceiling(pthread_mutex_t* mutex,
int prioceiling, int* old_ceiling);
int pthread_mutex_getprioceiling(const pthread_mutex_t* mutex,
int* prioceiling);
Функция pthread_mutex_setprioceiling() захватывает мьютекс (или блокируется, пока мьютекс не будет освобожден, и уже тогда захватывает его) и изменяет установленную для него величину граничного приоритета, после чего освобождает мьютекс для использования другими потоками. После изменения значения граничного приоритета предыдущее значение возвращается в old_ceiling.
Функция возвращает следующие значения:
EOK - успешное завершение;
EINVAL - указанный в вызове мьютекс не существует или указанный приоритет выходит за диапазон допустимых значений;
EPERM - поток, вызвавший функцию, не имеет прав на изменение граничного приоритета указанного мьютекса.
Захват мьютекса
Захват мьютекса может производиться тремя разными функциями, в основе которых лежит функция из native QNX API SyncMutexLock().
Простой захват
int pthread_mutex_lock(pthread_mutex_t* mutex);
Функция захватывает мьютекс, на который ссылается mutex. Если мьютекс уже захвачен другим потоком, то вызвавший поток блокируется до освобождения мьютекса и после этого захватывает его. Только после этого функция pthread_mutex_lock() возвращает управление. Если захватить мьютекс пытается поток, который им уже владеет, то поведение функции pthread_mutex_lock() будет зависеть от значений атрибутов мьютекса, указанных при его создании. QNX предоставляет возможность рекурсивного захвата мьютекса при соответствующих настройках атрибутов (см. выше раздел "Параметры мьютекса"). При создании мьютекса с параметрами по умолчанию попытка повторного захвата мьютекса ни к чему не приводит. Если включен режим контроля ошибок и отключен рекурсивный захват мьютекса, функция pthread_mutex_lock() возвращает EDEADLK при попытке повторного захвата мьютекса тем же потоком.
Функция pthread_mutex_lock() может возвращать следующие значения: EOK - успешное завершение;
EAGAIN - недостаточно системных ресурсов для захвата мьютекса;
EDEADLK - вызывающий поток уже владеет мьютексом и мьютекс не поддерживает рекурсивный захват (режим контроля ошибок);
EINVAL - некорректное значение параметра mutex.
Попытка захвата
int pthread_mutex_trylock(pthread_mutex_t* mutex);
Функция проверяет, свободен ли мьютекс mutex, и если да, то она захватывает его. В противном случае функция возвращает значение EBUSY.
Возвращаемые значения:
EOK - успешное завершение;
EAGAIN - недостаточно системных ресурсов для захвата мьютекса;
EBUSY - мьютекс mutex уже захвачен;
EINVAL - некорректное значение параметра mutex.
Захват с установкой времени ожидания
#include <pthread.h>
#include <time.h>
int pthread_mutex_timedlock(pthread_mutex_t* mutex,
const struct timespec* abs_timeout);
Функция проверяет, свободен ли мьютекс (mutex), и если да, то поток, в котором вызвана функция, захватывает этот мьютекс. Если мьютекс уже захвачен, вызвавший поток блокируется до освобождения мьютекса либо до наступления времени, указанного в аргументе abs_timeout. Если это время уже наступило, поток не блокируется вообще, но захват все-таки произойдет, если мьютекс свободен.
Наступление времени определяется по часам REALTIME_CLOCK, когда значение часов оказывается равным или большим значения, указанного в abs_timeout. Тип данных timespec определен в файле <time.h>.
Если мьютекс создан с атрибутом протокола PRIO_INHERIT, то после выхода потока из блокировки на мьютексе по тайм-ауту приоритет владельца мьютекса подвергается пересмотру в соответствии с приоритетами потоков, оставшихся в очереди на захват мьютекса.
Возвращаемые значения:
EOK - успешное завершение;
EAGAIN - недостаточно системных ресурсов для захвата мьютекса;
EDEADLK - вызывающий поток уже владеет мьютексом, который не поддерживает рекурсивный захват (режим контроля ошибок);
EINVAL - мьютекс использует протокол граничного приоритета для предотвращения инверсии (атрибут protocol установлен в значение PTHREAD_PRIO_PROTECT), но приоритет вызвавшего потока выше граничного приоритета, присвоенного мьютексу; поток должен быть блокирован (мьютекс не свободен), а значение поля abs_timeout, показывающее количество наносекунд, меньше нуля или больше 1000 миллионов; переменная, на которую указывает mutex, не является инициированным объектом - мьютексом.
ETIMEDOUT - мьютекс не может быть захвачен, поскольку указанный тайм-аут истек.
Освобождение мьютекса
int pthread_mutex_unlock(pthread_mutex_t* mutex);
Функция pthread_mutex_unlock() освобождает мьютекс, на который ссылается переменная mutex. Вызвавший поток должен быть владельцем мьютекса. Если есть потоки, блокированные в ожидании освобождения мьютекса, то поток с наивысшим приоритетом (или при равных приоритетах дольше всех ждавший) выходит из блокированного состояния и становится владельцем мьютекса.
Для мьютексов, разрешающих рекурсивный захват, функция освобождения должна вызываться столько же раз, сколько и функция захвата.
Возвращаемые значения:
EOK - успешное завершение;
EINVAL - переменная, на которую указывает mutex, не является инициализированным объектом - мьютексом;
EPERM - вызвавший поток не является владельцем мьютекса.
Разрушение объекта мьютекс
int pthread_mutex_destroy(pthread_mutex_t* mutex);
Вызов разрушает объект мьютекс, на который указывает переменная mutex. После чего эта переменная не может быть использована без предварительного вызова pthread_mutex_init().
Возвращаемые значения:
EOK - успешное завершение;
EBUSY- мьютекс захвачен и не может быть разрушен до освобождения;
EINVAL - переменная, на которую указывает mutex, не является инициированным объектом - мьютексом.
Операции, не поддерживаемые POSIX
В native QNX API есть ряд функций работы с мьютексом, которые не определены POSIX-стандартом, однако они могут оказаться весьма полезными. Поскольку тип POSIX-мьютекса порождается от sync_t, то вполне возможно использование комбинации функций, определенных POSIX, и "родных" native-функций QNX. Однако необходимо помнить, что в таком случае ни о какой межсистемной совместимости говорить уже не приходится.
Восстановление "мертвого" мьютекса
#include <sys/neutrino.h>
int SyncMutexRevive(sync_t* sync);
int SyncMutexRevive_r(sync_t* sync);
Эти функции предназначены для восстановления мьютекса, который находится в состоянии блокирования DEAD. Мьютекс попадает в состояние DEAD, когда память, использованная при захвате мьютекса, освобождается. Такое может произойти, например, когда умирает поток, захвативший мьютекс, расположенный в разделяемой памяти. В результате вызова вызвавший поток становится владельцем мьютекса, и его счетчик захватов устанавливается в 1 для рекурсивного мьютекса.
Ошибки выполнения функции:
ЕFAULT - ошибка при обращении к указанным в аргументах переменным;
EINVAL - указанный объект синхронизации не существует или не находится в состоянии DEAD;
ETIMEDOUT - отмена вызова по тайм-ауту ядра (устанавливается вызовом TimerTimeout()).
Установка уведомления о "смерти" мьютекса
Определить состояние мьютекса как DEAD можно с помощью функции SyncMutexEvent(), которая определяет событие, связанное со "смертью" мьютекса.
#include <sys/neutrino.h>
int SyncMutexEvent(sync_t* sync, struct sigevent* event);
int SyncMutexEvent_r(sync_t* sync, struct sigevent* event);
Данная функция предназначена для установки обработчика ситуации, когда мьютекс попадает в состояние DEAD (то есть перераспределяется память, из которой произошел захват мьютекса). Захватить мьютекс, оказавшийся в состоянии DEAD, можно далее с помощью вызова функции SyncMutexRevive().
Ошибки выполнения функции:
EAGAIN - в данный момент ядро не имеет ресурсов для обработки запроса;
EFAULT - ошибка произошла при попытке обращения к sync;
EINVAL - объект синхронизации, на который указывает sync, не существует.