Семафоры

We use cookies. Read the Privacy and Cookie Policy

Семафоры

Для синхронизации процессов, а точнее, для синхронизации доступа нескольких процессов к разделяемым ресурсам, используются семафоры. Являясь одной из форм IPC, семафоры не предназначены для обмена большими объемами данных, как в случае FIFO или очередей сообщений. Вместо этого, они выполняют функцию, полностью соответствующую своему названию — разрешать или запрещать процессу использование того или иного разделяемого ресурса.

Применение семафоров поясним на простом примере. Допустим, имеется некий разделяемый ресурс (например, файл). Необходимо блокировать доступ к ресурсу для других процессов, когда некий процесс производит операцию над ресурсом (например, записывает в файл). Для этого свяжем с данным ресурсом некую целочисленную величину — счетчик, доступный для всех процессов. Примем, что значение 1 счетчика означает доступность ресурса, 0 — его недоступность. Тогда перед началом работы с ресурсом процесс должен проверить значение счетчика. Если оно равно 0 — ресурс занят и операция недопустима — процессу остается ждать. Если значение счетчика равно 1 — можно работать с ресурсом. Для этого, прежде всего, необходимо заблокировать ресурс, т. е. изменить значение счетчика на 0. После выполнения операции для освобождения ресурса значение счетчика необходимо изменить на 1. В приведенном примере счетчик играет роль семафора.

Для нормальной работы необходимо обеспечить выполнение следующих условий:

1. Значение семафора должно быть доступно различным процессам. Поэтому семафор находится не в адресном пространстве процесса, а в адресном пространстве ядра.

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

Таким образом семафоры являются системным ресурсом, действия над которым производятся через интерфейс системных вызовов.

Семафоры в System V обладают следующими характеристиками:

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

? Каждое из этих чисел может принимать любое неотрицательное значение в пределах, определенных системой (а не только значения 0 и 1).

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

struct ipc_perm sem_perm Описание прав доступа struct sem *sem_base Указатель на первый элемент массива семафоров ushort sem_nsems Число семафоров в группе time_t sem_otime Время последней операции time_t sem_ctime Время последнего изменения

Значение конкретного семафора из набора хранится во внутренней структуре sem:

ushort semval Значение семафора pid_t sempid Идентификатор процесса, выполнившего последнюю операцию над семафором ushort semncnt Число процессов, ожидающих увеличения значения семафора ushort semzcnt Число процессов, ожидающих обнуления семафора

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

Для получения доступа к семафору (и для его создания, если он не существует) используется системный вызов semop(2):

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

int semget(key_t key, int nsems, int semflag);

В случае успешного завершения операции функция возвращает дескриптор объекта, в случае неудачи - -1. Аргумент nsems задает число семафоров в группе. В случае, когда мы не создаем, а лишь получаем доступ к существующему семафору, этот аргумент игнорируется. Аргумент semflag определяет права доступа к семафору и флажки для его создания (IPC_CREAT, IPC_EXCL).

После получения дескриптора объекта процесс может производить операции над семафором, подобно тому, как после получения файлового дескриптора процесс может читать и записывать данные в файл. Для этого используется системный вызов semop(2):

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

int semop(int semid, struct sembuf *semop, size_t nops);

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

Каждый элемент набора операций semop имеет вид:

struct sembuf {

 short sem_num; /* номер семафора в группе */

 short sem_op;  /* операция */

 short sem_flg; /* флаги операции */

}

UNIX допускает три возможные операции над семафором, определяемые полем semop:

1. Если величина semop положительна, то текущее значение семафора увеличивается на эту величину.

2. Если значение semop равно нулю, процесс ожидает, пока семафор не обнулится.

3. Если величина semop отрицательна, процесс ожидает, пока значение семафора не станет большим или равным абсолютной величине semop. Затем абсолютная величина semop вычитается из значения семафора.

Можно заметить, что первая операция изменяет значение семафора (безусловное выполнение), вторая операция только проверяет его значение (условное выполнение), а третья — проверяет, а затем изменяет значение семафора (условное выполнение).

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

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

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

static struct sembuf sop_lock[2] = {

 0, 0, 0, /* ожидать обнуления семафора */

 0, 1, 0  /* затем увеличить значение семафора на 1 */

};

static struct sembuf sop_unlock[1] = {

 0,-1, 0 /* обнулить значение семафора */

};

Итак, для запирания ресурса процесс производит вызов:

semop(semid, &sop_lock[0], 2);

обеспечивающий атомарное выполнение двух операций:[43]

1. Ожидание доступности ресурса. В случае, если ресурс уже занят (значение семафора равно 1), выполнение процесса будет приостановлено до освобождения ресурса (значение семафора равно 0).

2. Запирание ресурса. Значение семафора устанавливается равным 1. Для освобождения ресурса процесс должен произвести вызов:

semop(semid, &sop_unlock[0], 1);

который уменьшит текущее значение семафора (равное 1) на 1, и оно станет равным 0, что соответствует освобождению ресурса. Если какой-либо из процессов ожидает ресурса (т. е. произвел вызов операции sop_lock), он будет "разбужен" системой, и сможет в свою очередь запереть ресурс и работать с ним.

Во втором примере изменим трактовку значений семафора: значению 1 семафора соответствует доступность некоторого ассоциированного с семафором ресурса, а нулевому значению — его недоступность. В этом случае содержание операций несколько изменится.

static struct sembuf sop_lock[2] = {

 0, -1, 0, /* ожидать разрешающего сигнала (1),

              затем обнулить семафор */

};

static struct sembuf sop_unlock[1] = {

 0, 1, 0   /* увеличить значение семафора на 1 */

};

Процесс запирает ресурс вызовом:

semop(semid, &sop_lock[0], 1);

а освобождает:

semop(semid, &sop_unlock[0], 1);

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

Можно предложить следующее решение данной проблемы:

/* Создаем семафор, если он уже существует semget

   возвращает ошибку, поскольку указан флаг IPC_EXCL */

if ((semid = semget(key, nsems, perms | IPC_CREAT | IPC_EXCL)) < 0) {

 if (errno = EEXIST) {

  /* Действительно, ошибка вызвана существованием объекта */

  if ((semid = semget(key, nsems, perms)) < 0)

   return(-1); /* Возможно, не хватает системных ресурсов */

 } else

 return(-1); /* Возможно, не хватает системных ресурсов * /

}

/* Если семафор создан нами, проинициализируем его */

else

 semop(semid, &sop_unlock[0], 1);

Данный текст является ознакомительным фрагментом.