Семафоры

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

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

HANDLE CreateSemaphore(

LPSECURITY_ATTRIBUTES lpSemaphoreAttribute, // атрибуты защиты

LONG llnitialCount, // начальное значение семафора

LONG lMaximumCount, // максимальное значение семафора

LPCTSTR lpName // имя семафора

);

Пока значение параметра lpSemaphoreAttributes будем устанавливать в null. Основную смысловую нагрузку в этой функции несут второй и третий параметры. Значение параметра linitialcount устанавливает начальное значение семафора, которое должно быть не меньше 0 и не больше его максимального значения, которое устанавливается параметром lMaximumCount.

Параметр lpName может указывать на имя семафора или содержать значение null. В последнем случае создается безымянный семафор. В случае успешного завершения функция CreateSemaphore возвращает дескриптор семафора, в случае неудачи — значение null. Если семафор с заданным именем уже существует, то функция CreateSemaphore возвращает дескриптор этого семафора, а функция GetLastError, вызванная после функции CreateSemaphore, вернет Значение ERROR_ALREADY_EXISTS.

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

BOOL ReleaseSemaphore(

HANDLE hSemaphore, // дескриптор семафора

LONG lReleaseCount, // положительное число, на которое

// увеличивается значение семафора

LPLONG lpPreviousCount // предыдущее значение семафора

);

В случае успешного завершения функция ReleaseSemaphore возвращает ненулевое значение, а в случае неудачи — false. Если значение семафора плюс значение параметра IReleaseCount больше максимального значения семафора, то функция ReleaseSemaphore возвращает значение false и значение семафора не изменяется. Значение параметра lpPreviousCount этой функции может быть равно null. В этом случае предыдущее значение семафора не возвращается. Доступ к существующему семафору можно открыть с помощью одной из функций CreateSemaphore или OpenSemaphore. Если используется функция CreateSemaphore, то значения параметров UnitialCount и lMaximalcount этой функции игнорируются, т. к. они уже установлены другим потоком, а поток, вызвавший эту функцию, получает полный доступ к семафору с именем, заданным параметром lpName.

Теперь рассмотрим функцию OpenSemaphore, которая используется в случае, если известно, что семафор с заданным именем уже существует. Эта функция имеет следующий прототип:

HANDLE OpenSemaphore(

DWORD dwDesiredAccess, // флаги доступа

BOOL blnheritHandle, // режим наследования

LPCTSTR lpName // имя события

);

Параметр dwDesiredAccess определяет доступ к семафору и может быть равен любой логической комбинации следующих флагов:

- semaphore_all_access — полный доступ к семафору;

- semaphore_modify_state — изменение состояния семафора;

- SYNCHRONIZE — синхронизация.

Опишем назначение этих флагов чуть подробнее.

- флаг semaphore_all_access устанавливает для потока полный доступ к семафору. Это означает, что поток может выполнять над семафором любые действия;

- флаг semaphore_modify_state означает, что поток может использовать только функцию ReleaseSemaphore для изменения значения семафора;

- флаг synchronize означает, что поток может использовать семафор только в функциях ожидания. Отметим, что этот флаг поддерживается только на платформе Windows NT/2000.

Пример использования:

# include <windows.h>

#include <iostream.h>

volatile int a[10];

HANDLE hSemaphore;

DWORD WINAPI thread(LPVOID)

{

for (int i = 0; i < 10; i++)

{

a[i] = i + 1;

// отмечаем, что один элемент готов

ReleaseSemaphore(hSemaphore,1,NULL);

SleepE00);

}

return 0;

}

int mainO

{

int i;

HANDLE hThread;

DWORD IDThread;

cout «"An initial state of the array: ";

for (i = 0; i < 10; i++)

cout «a[i] «' ';

cout «endl;

// создаем семафор

hSemaphore=CreateSemaphore(NULL, 0, 10, NULL);

if (hSemaphore == NULL)

return GetLastError();

// создаем поток, который готовит элементы массива

hThread = CreateThread(NULL, 0, thread, NULL, 0, &IDThread);

if (hThread == NULL)

return GetLastError();

// поток main выводит элементы массива

// только после их подготовки потоком thread

cout «"A final state of the array: ";

for (i = 0; i < 10; i++)

{

WaitForSingleObject(hSemaphore/ INFINITE);

cout «a[i] «" \a" «flush;

}

cout «endl;

CloseHandle(hSemaphore);

CloseHandle(hThread);

return 0;

}

Может возникнуть следующий вопрос: почему для решения этой задачи используется именно считающий семафор и почему его максимальное значение равно 10? Конечно, поставленную задачу можно было бы решить и другими способами. Но дело в том, что считающие семафоры предназначены именно для решения подобных задач. Считающие семафоры используются для синхронизации доступа к однотипным ресурсам, которые производятся одним или несколькими потоками, а потребляются другими — одним или несколькими потоками. В этом случае значение считающего семафора равно количеству произведенных ресурсов, а его максимальное значение устанавливается равным максимально возможному количеству таких ресурсов. При производстве единицы ресурса значение семафора увеличивается на единицу, а при потреблении единицы ресурса значение семафора уменьшается на единицу. В нашем примере ресурсами являются элементы массива, заполненные потоком thread, который является производителем этих ресурсов. В свою очередь, поток main является потребителем этих ресурсов — он выводит их на консоль. Так как в общем случае мы не можем сделать предположений о скоростях работы параллельных потоков, то максимальное значение считающего семафора должно быть установлено в максимальное количество производимых ресурсов. Если поток-потребитель ресурсов работает быстрее чем поток-производитель ресурсов, то, вызвав функцию ожидания считающего семафора, он вынужден будет ждать, пока поток-производитель не произведет очередной ресурс. Если же наоборот — поток-производитель работает быстрее чем поток-потребитель, то первый поток произведет все ресурсы и закончит свою работу, не дожидаясь, пока второй использует их. Такая синхронизация потоков-производителей и потребителей обеспечивает их максимально быструю работу.