Создание инверсных семафоров и типов данных, безопасных в многопоточной среде
Как-то ряз я писал одну программу, и мне понадобился объект ядра, который вел бы себя прямо противоположно тому, как ведет себя семафор. Мне нужно было, чтобы он переходил в свободное состояние, когда его счетчик текущего числа ресурсов обнуляется, и оставался в занятом состоянии, пока значение этого счетчика больше 0.
Я мог бы придумать много применений такому объекту. Например, потокдолжсн пробудиться после того, как определенная операция будет выполнена 100 раз. Чтобы осуществить это, нужен объект ядра, счетчик которого можно было бы инициализи ровать этим значением. Пока он больше 0, объект остается в занятом состоянии. По окончании каждой операции Вы уменьшаете счетчик в объекте ядра на 1. Как только счетчик обнуляется, объект переходит в свободное состояние, сообщая другому по току, что тот может пробудиться и чем-то заняться. Это типичная задача, и я не пони маю, почему в Windows нет подходящего синхронизирующего объекта
В сущности, Microsoft могла бы легко решить эту задачу, предусмотрев в семафо ре возможность присвоения отрицательных значений его счетчику текущего числа ресурсов. Тогда Вы инициализировали бы счетчик семафора значением -99 и по окон чании каждой операции вызывали бы ReleaseSemaphore, Как только его счетчик дос тиг бы значения 1, объект перешел бы в свободное состояние. После этого мог бы пробудиться другой Ваш поток и выполнить свою работу. Увы, Microsoft запрещает
присвоение счетчику семафора отрицательных значений, и вряд ли здесь что-то пе ременится к обозримом будущем.
В этом разделе я познакомлю Вас со своим набором С++-классов, которые дей ствуют как инверсный семафор и делают уйму всяких других вещей. Исходный код этих классов находится в файле Interlocked.h (см листинг на рис. 10-2)
Когда я впервые взялся за решение этой проблемы, я понимал, что главное в нем — обеспечить безопасность манипуляций над переменной в многопоточной среде. Я хотел найти элегантное решение, которое позволило бы легко писать код, ссылаю щийся на эту переменную. Очевидно, что самый простой способ обезопасить какой то ресурс от повреждения в многопоточной среде, — защитить его с помощью кри тической секции. В С++ это можно сделать бсз особого труда. Достаточно создать C++ класс, который содержит защищаемую переменную и структуру CRITICAL_SECTION. В конструкторе Вы вызываете lnitializeCriticalSection, а в деструкторе — DeleteCritical Section. Затем для любой переменной-члена Вы вызываете EnterCriticalSection, что-то делаете с этой переменной и вызываете LeaveCriticalSection. Если Вы именно так реа лизуете С++-класс, то писать безопасный код, обращающийся к какой-либо структу ре данных, будет несложно. Этот принцип положен мной в основу всех С++-классов, о которых я буду рассказывать в данном разделе. (Конечно, вместо критических сек ций я мог бы использовать оптекс, рассмотренный в предыдущем разделе.)
Первый класс, CResGuard, охраняет доступ к ресурсу. Он содержит два элемента данных: CRITICAL_SECTION и LONG. Последний используется для слежения за тем, сколько раз поток, владеющий ресурсом, входил в критическую секцию. Эта инфор мация полезна при отладке. Конструктор и деструктор объекта CResGuard вызывают сответственно InitializeCriticalSeclion и DeleteCriticalSection. Поскольку создать объект может лишь единственный поток, конструктор и деструктор какого-либо С++-объек та не обязательно должен быть реентерабельным. Функция-член IsGuarded просто сообщает, была ли хоть раз вызвана EnterCriticalSection для данного объекта. Как я уже говорил, все это предназначено для отладки. Включение CRITICAL_SECTION в C++ объект гарантирует корректность инициализации и удаления критической секции.
Класс CResGuard также включает открытый вложенный С++-класс CGuard. Объект CGuard содержит ссылку на объект CResGuard и предусматривает лишь конструктор и деструктор. Конструктор обращается к функции-члену Guard класса CResGuard, вызывающей EnterCriticalSection, а деструктор — к функции-члену Unguard того же класса, вызывающей LeaveCriticalSection. Такая схема упрощает манипуляции с CRITI CAL_SECTION. Вот небольшой фрагмент кода, иллюстрирующий применение этих классов:
struct SomeDataStruct
{
...
} g_SomeSharedData;
// Создаем объект CResGuard, защищающий g_SomeSharedData.
// Примечание: Конструктор инициализирует критическую секцию, а деструктор удаляет ее.
CResGuard g_rgSomeSharedData;
void AFunction()
{
// эта функция работает с разделяемой структурой данных
// защищаем ресурс от одновременного доступа со стороны нескольких потоков
CResGuard::CGuard gDummy(g_rgSomeSharedData);
// входим в критическую секцию
// работаем c ресурсом g_SomeSharedData
...
}
// Примечание: LeaveCriticalSection вызывается, когда gDummy
// выходит за пределы области видимости
Следующий С++-класс, CInterlockedType, содержит все, что нужно для создания объекта данных, безопасного в многопоточной среде. Я сделал CInterlockediype клас сом шаблона, чтобы его можно было применять для любых типов данных. Поэтому Вы можете использовать его, например, с целочисленной переменной, строкой или произвольной структурой данных.
Каждый экземпляр объекта CInterlockedType содержит два элемента данных Пер вый - это экземпляр шаблонного типа данных, который Вы хотите сделать безопас ным в многопоточной среде Он является закрытым, и им можно манипулировать только через функции-члены класса CInterlockedType. Второй элемент данных пред ставляет собой экземпляр объекта CResGuard, так чго класс, производный от CInter lockedType, может легко защитить свои данные.
Предполагается, что Вы всегда будете создавать свой класс, используя класс CInter lockedType как базовый. Ранее я ужс говорил, что класс CInterlockedType предостав ляет все необходимое для создания объекта, безопасного в многопоточной среде, но производный класс должен сам позаботиться о корректном использовании элемен тов CInterlockedType.
Класс CInterlockedType содержит всего четыре открытые функции- конструктор, инициализирующий объект данных, и конструктор, не инициализирующий этот объ ект, а также виртуальный деструктор, который ничего не делает, и оператор приведе ния типа (cast operator). Последний просто гарантирует безопасный доступ к данным, охраняя ресурс и возвращая текущее значение объекта. (Ресурс автоматически раз блокируется при выходе локальной переменной x за пределы ее области видимости.) Этот оператор упрощает безопасную проверку значения объекта данных, содержаще гося в классе.
В классе CInterlockedType также присутствуют три невиртуальные защищенные функции, которые будут вызываться производным классом. Две функции GetVal воз вращают текущее значение объекта данных. В отладочных версиях файла обе эти функции сначала проверяют, охраняется ли объект данных. Если бы он не охранял ся, GetVal могла бы вернуть значение объекта, а затем позволить другому потоку из менить его до того, как первый поток успеет что-то сделать с этим значением. Я пред полагаю, что вызывающий поток получает значение объекта для того, чтобы как-то изменить его Поэтому функции GetVal требуют от вызывающего потока охраны дос тупа к данным. Определив, что данные охраняются, функции GetVal возвращают теку щее значение.
Эти функции идентичны с тем исключением, что одна из них манипулирует кон стантной версией объекта. Благодаря зтому Вы можете без проблем писать код, ра ботающий как с константными, так и с неконстантными данными.
Третья невиртуальная защищенная функция-член — SetVal, Желая модифицировать данные, любая функция-члсн производного класса должна защитить доступ к этим данным, а потом вызвать функцию SetVal. Как и GetVal, функция SetVal сначала прово дит отладочную проверку, чтобы убедиться, не пабыл ли код производного класса за щитить доступ к данным. Затем SetVal проверяет, действительно ли данные изменя ются. Если да, SetVal сохраняет старое значение, присваивает объекту новое значение и вызывает виртуальную защищенную функцию-члеи OnValChanged, передавая ей оба значения. В классе CInterlockedType последняя функция реализована так, что она
ничего не делает. Вы можете использовать эту функцию-член для того, чтобы расши рить возможности своего производного класса, но об этом мы поговорим, когда дой дем до рассмотрения класса CWhenZero.
До сих пор речь шла в основном об абстрактных классах и концепциях. Теперь посмотрим, как пользоваться этой архитектурой на благо всего человечества. Я пред ставлю Вам CInterlockedScalar — класс шаблона, производный от CInterlockedType. С его помощью Вы сможете создавать безопасные в многопоточной среде скалярные (простые) типы данных — байт, символ, l6-, 32- или 64-битное целое, вещественное значение (с плавающей точкой) и т. д. Поскольку CInterlockedScalar является произ водным от класса CInrerlockedType, у него нет собственных элементов данных. Кон структор CInterlockedScalar просто обращается к конструктору CInterlockedType, пе редавая ему начальное значение объекта скалярных данных Класс CInterlockedScalar работает только с числовыми значениями, и в качестве начального значения я выб рал нуль, чтобы наш объект всегда создавался в известном состоянии Ну а деструк тор класса CInterlockedScalar вообще ничего не делает.
Остальные функции-члены класса CInterlockedScalar отвечают за изменение ска лярного значения. Для каждой операции над ним предусмотрена отдельная функция член. Чтобы класс CInterlockedScalar мог безопасно манипулировать своим объектом данных, все функции-члены псрсд выполнением какой-либо операции блокируют доступ к этому объекту. Функции очень просты, и я не стану подробно объяснять их; просмотрев исходный код, Вы сами поймете, что они делают. Однако я покажу, как пользоваться этими классами. В следующем фрагменте кода объявляется безопасная в многопоточной среде переменная типа BYTE и над ней выполняется серия операций:
CInterlockedScalar<BYTE> b = 5, // безопасная переменнан типа BYTE
BYTE b2 = 10; // небезопасная переменная типа BYTF
b2 = b++; // b2=5, b=6
b *= 4; // b=24
b2 = b, // b2=24, b=24
b += b; // b=48
b %= 2; // b=0
Работа с безопасной скалярной переменной также проста, как и с небезопасной. Благодаря замещению (перегрузке) операторов в С++ даже код в таких случаях фак тически одинаков! С помощью С++-классов, о которых я уже рассказал, любую небе зопасную переменную можно легко превратить в безопасную, внеся лишь минималь ные изменения в исходный код своей программы.
Проектируя все эти классы, я хотел создать объект, чье поведение было бы про тивоположно поведению семафора. Эту функциональность предоставляет мой C++ класс CWhenZero, производный от CInrerlockedScaIar Когда скалярное значение рав но 0, объект CWhenZero пребывает в свободном состоянии, а когда оно не равно 0 — в занятом
Как Вам известно, С++-объекты не поддерживают такие состояния — в них могут находиться только объекты ядра. Значит, в CWhenZero нужны дополнительные эле менты данных с описателями объектов ядра "событие». Я включил в объект CWhenZero два элемента данных: m_hevtZero (описатель объекта ядра «событие», переходящего в свободное состояние, когда объект данных содержит нулевое значение) и m_hevt NotZero (описатель объекта ядра «событие», переходящего в свободное состояние, когда объект данных содержит ненулевое значение).
Конструктор CWhenZero принимает начальное значение для объекта данных, а также позволяет указать, какими должны быть объекты ядра "событие" — со сбросом
вручную (по умолчанию) или с автосбросом Далее конструктор, вызывая CreateEvent, создает два объекта ядра «событие» и переводит их в свободное или занятое состоя ние в зависимости от того, равно ли нулю начальное значение. Деструктор CWhenZero просто закрывает описатели этих двух объектов ядра Поскольку CWhenZero откры то наследует от класса CInterlockedScalar, все функции-члены перегруженного опера тора доступны и пользователям объекта CWhenZero.
Помните защищенную функцию- член OnValChanged, объявленную внутри класса CInterLockedType Так вот, класс CWhenZero замещает эту виртуальную функцию. Она отвечает за перевод объектов ядра «событие» в свободное или занятое состояние в соответствии со значением объекта данных. OnValChanged вызывается при каждом изменении этого значения Ее реализация в CWhenZero проверяет, равно ли нулю новое значение Если да, функция устанавливает событие m_hevtZero и сбрасывает событие m_hevtNotZero. Нет — все делается наоборот
Теперь, если Вы хотите, чтобы поток ждал нулевого значения объекта данных, от Вас требуется лишь следующее:
CWhenZero<BYTE> b = 0; // безопасная переменная типа BYTE
// немедленно возвращает управление, так как b равна 0
WaitForSingleObject(b, INFINITE);
b = 5;
// возвращает управление, только если другой поток присваивает D нулевое значение
WaitForSingleObject(b, INFINITE);
Вы можете вызывать WaitForSingleObject именно таким образом, потому что класс CWhenZero включает и функцию-член оператора приведения, которая приводит объ ект CWhenZero к типу HANDLE объекта ядра. Иначе говоря, передача С++-объекта CWhenZero любой Windows-функции, ожидающей HANDLE, приводит к автоматичес кому вызову функции-члена оператора приведения, возвращаемое значение которой и передастся Windows-функции В данном случае эта функция-член возвращает опи сатель объекта ядра «событие» m_hevtZero.
Описатель события m_hevtNotZero внутри класса CWhenZero позволяет писать код, ждущий ненулевого значения объекта данных. К сожалению, в класс нельзя включить второй оператор приведения HANDLE — для получения описателя m_hevtNotZero Поэтому мне пришлось добавить функцию-члсн GetNotZeroHandle, которая исполь зуется так.
CWhenZero<BYTE> b = 5; // безопасная переменная типа BYTE
// немедленно возвращает управление, так как b не равна 0
WaitForSingleObject(b GetNotZeroHandle(), INFINITE);
b = 0,
// возвращает управление, только если другой поток присваивает b ненулевое значение WaitForSingleObject(b.GetNotZeroHandle(), INFINITE);
