Критические секции

Павел Блудов

Введение

Критические секции -- это объекты, используемые для блокировки доступа всех нитей (threads) приложения, кроме одной, к некоторым важным данным в один момент времени. Например, имеется переменная m_pObject и несколько нитей, вызывающих методы объекта, на который ссылается m_pObject, причем эта переменная может изменять свое значение время от времени. Иногда там даже оказывается нуль. Предположим, имеется вот такой код:

// Нить №1

void Proc1()

{

    if (m_pObject)

        m_pObject->SomeMethod();

}

// Нить №2

void Proc2(IObject *pNewObject)

{

    if (m_pObject)

        delete m_pObject;

    m_pObject = pNewobject;

}

Тут мы имеем потенциальную опасность вызова m_pObject->SomeMethod() после того, как объект был уничтожен при помощи delete m_pObject. Дело в том, что в системах с вытесняющей многозадачностью выполнение любой нити процесса может прерваться в самый неподходящий для нее момент времени, и начнет выполняться совершенно другая нить. В данном примере неподходящим моментом будет тот, в котором нить №1 уже проверила m_pObject, но еще не успела вызвать SomeMethod(). Выполнение нити №1 прервалось, и начала исполняться нить №2. Причем нить №2 успела вызвать деструктор объекта. Что же произойдет, когда нить №1 получит немного процессорного времени и вызовет-таки SomeMethod() у уже несуществующего объекта? Наверняка что-то ужасное.

Именно тут приходят на помощь критические секции. Перепишем наш пример.

// Нить №1

void Proc1()

{

    ::EnterCriticalSection(&m_lockObject);

    if (m_pObject)

        m_pObject->SomeMethod();

    ::LeaveCriticalSection(&m_lockObject);

}

// Нить №2

void Proc2(IObject *pNewObject)

{

    ::EnterCriticalSection(&m_lockObject);

    if (m_pObject)

        delete m_pObject;

    m_pObject = pNewobject;

    ::LeaveCriticalSection(&m_lockObject);

}

Код, помещенный между ::EnterCriticalSection() и ::LeaveCriticalSection() с одной и той же критической секцией в качестве параметра, никогда не будет выполняться параллельно. Это означает, что если нить №1 успела "захватить" критическую секцию m_lockObject, то при попытке нити №2 заполучить эту же критическую секцию в свое единоличное пользование, ее выполнение будет приостановлено до тех пор, пока нить №1 не "отпустит" m_lockObject при помощи вызова ::LeaveCriticalSection(). И наоборот, если нить №2 успела раньше нити №1, то та "подождет", прежде чем начнет работу с m_pObject.

Работа с критическими секциями

Что же происходит внутри критических секций и как они устроены? Прежде всего, следует отметить, что критические секции – это не объекты ядра операционной системы. Практически вся работа с критическими секциями происходит в создавшем их процессе. Из этого следует, что критические секции могут быть использованы только для синхронизации в пределах одного процесса. Теперь рассмотрим критические секции поближе.

Структура RTL_CRITICAL_SECTION

typedef struct _RTL_CRITICAL_SECTION {

    PRTL_CRITICAL_SECTION_DEBUG DebugInfo; // Используется операционной системой

    LONG LockCount;        // Счетчик использования этой критической секции

    LONG RecursionCount;    // Счетчик повторного захвата из нити-владельца

    HANDLE OwningThread;    // Уникальный ID нити-владельца

    HANDLE LockSemaphore;    // Объект ядра используемый для ожидания

    ULONG_PTR SpinCount;    // Количество холостых циклов перед вызовом ядра

} RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;

Поле LockCount увеличивается на единицу при каждом вызове ::EnterCriticalSection() и уменьшается при каждом вызове ::LeaveCriticalSection(). Это первая (а часто и единственная проверка) на пути к "захвату" критической секции. Если после увеличения в этом поле находится ноль, это означает, что до этого момента непарных вызовов ::EnterCriticalSection() из других ниток не было. В этом случае можно забрать данные, охраняемые этой критической секцией в монопольное пользование. Таким образом, если критическая секция интенсивно используется не более чем одной нитью, ::EnterCriticalSection() практически вырождается в ++LockCount, а ::LeaveCriticalSection() в --LockCount. Это очень важно. Это означает, что использование многих тысяч критических секций в одном процессе не повлечет значительного расхода ни системных ресурсов, ни процессорного времени.

СОВЕТ

Не стоит экономить на критических секциях. Много cэкономить все равно не получится.

В поле RecursionCount хранится количество повторных вызовов ::EnterCriticalSection() из одной и той же нити. Действительно, если вызвать ::EnterCriticalSection() из одной и той же нити несколько раз, все вызовы будут успешны. Т.е. вот такой код не остановится навечно во втором вызове ::EnterCriticalSection(), а отработает до конца.

// Нить №1

void Proc1()

{

    ::EnterCriticalSection(&m_lock);

    //. ..

    Proc2()

    //. ..

    ::LeaveCriticalSection(&m_lock);

}

// Все еще нить №1

void Proc2()

{

    ::EnterCriticalSection(&m_lock);

    //. ..

    ::LeaveCriticalSection(&m_lock);

}

Действительно, критические секции предназначены для защиты данных от доступа из нескольких ниток. Многократное использование одной и той же критической секции из одной нити не приведет к ошибке. Это вполне нормальное явление. Следите, чтобы количество вызовов ::EnterCriticalSection() и ::LeaveCriticalSection() совпадало, и все будет хорошо.

Поле OwningThread содержит 0 для никем не занятых критических секций или уникальный идентификатор нити-владельца. Это поле проверяется, если при вызове ::EnterCriticalSection() поле LockCount после увеличения на единицу оказалось больше нуля. Если OwningThread совпадает с уникальным идентификатором текущей нити, то RecursionCount просто увеличивается на единицу и ::EnterCriticalSection() возвращается немедленно. Иначе ::EnterCriticalSection() будет дожидаться, пока нить, владеющая критической секцией, не вызовет ::LeaveCriticalSection() необходимое количество раз.

Поле LockSemaphore используется, если нужно подождать, пока критическая секция освободится. Если LockCount больше нуля, и OwningThread не совпадает с уникальным идентификатором текущей нити, то ждущая нить создает объект ядра (событие) и вызывает ::WaitForSingleObject(LockSemaphore). Нить-владелец, после уменьшения RecursionCount, проверяет его, и если значение этого поля равно нулю, а LockCount больше нуля, то это значит, что есть как минимум одна нить, ожидающая, пока LockSemaphore не окажется в состоянии "случилось!". Для этого нить-владелец вызывает ::SetEvent(), и какая-то одна (только одна) из ожидающих ниток пробуждается и получает доступ к критическим данным.

WindowsNT/2k генерирует исключение, если попытка создать событие не увенчалась успехом. Это верно как для функций ::Enter/LeaveCriticalSection(), так и для ::InitializeCriticalSectionAndSpinCount() с установленным старшим битом параметра SpinCount. Но только не в WindowsXP. Разработчики ядра этой операционной системы поступили по-другому. Вместо генерации исключения, функции ::Enter/LeaveCriticalSection(), если не могут создать собственное событие, начинают использовать заранее созданный глобальный объект. Один на всех. Таким образом, в случае катастрофической нехватки системных ресурсов, программа под управлением WindowsXP ковыляет какое-то время дальше. Действительно, писать программы, способные продолжать работать после того, как ::EnterCriticalSection() сгенерировала исключение, чрезвычайно сложно. Как правило, если программистом и предусмотрен такой поворот событий, то дальше вывода сообщения об ошибке и аварийного завершения программы дело не идет. Как следствие, WindowsXP игнорирует старший бит поля LockCount.

И, наконец, поле SpinCount. Это поле используется только многопроцессорными системами. В однопроцессорных системах, если критическая секция занята другой нитью, можно только переключить управление на нее и подождать наступления события. В многопроцессорных системах есть альтернатива: прогнать некоторое количество раз холостой цикл, проверяя каждый раз, не освободилась ли наша критическая секция. Если за SpinCount раз это не получилось, переходим к ожиданию. Это гораздо эффективнее, чем переключение на планировщик ядра и обратно. Кроме того, в WindowsNT/2k старший бит этого поля служит для индикации того, что объект ядра, хендл которого находится в поле LockSemaphore, должен быть создан заранее. Если системных ресурсов для этого недостаточно, система сгенерирует исключение, и программа может "урезать" свою функциональность. Или совсем завершить работу.

ПРИМЕЧАНИЕ

Все это верно для Windows NT/2k/XP. В Windows 9x/Me используется только поле LockCount. Там находится указатель на объект ядра, возможно, просто взаимоисключение (mutex). Все остальные поля равны нулю.

API для работы с критическими секциями

BOOL InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount);

Заполняют поля структуры, адресуемой lpCriticalSection. После вызова любой из этих функций критическая секция готова к работе.

Критические секцииЛистинг 1. Псевдокод RtlInitializeCriticalSection из ntdll.dll

VOID RtlInitializeCriticalSection(LPRTL_CRITICAL_SECTION pcs)

{

  RtlInitializeCriticalSectionAndSpinCount(pcs, 0)

}

VOID RtlInitializeCriticalSectionAndSpinCount(

  LPRTL_CRITICAL_SECTION pcs, DWORD dwSpinCount)

{

  pcs->DebugInfo = NULL;

  pcs->LockCount = -1;

  pcs->RecursionCount = 0;

  pcs->OwningThread = 0;

  pcs->LockSemaphore = NULL;

  pcs->SpinCount = dwSpinCount;

  if (0x80000000 & dwSpinCount)

    _CriticalSectionGetEvent(pcs);

}

DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount);

Устанавливает значение поля SpinCount и возвращает его предыдущее значение. Напоминаю, что старший бит отвечает за "привязку" события, используемого для ожидания доступа к данной критической секции.

Критические секцииЛистинг 2. Псевдокод RtlSetCriticalSectionSpinCount из ntdll.dll

DWORD RtlSetCriticalSectionSpinCount(

  LPRTL_CRITICAL_SECTION pcs, DWORD dwSpinCount)

{

  DWORD dwRet = pcs->SpinCount;

  pcs->SpinCount = dwSpinCount;

  return dwRet;

}

VOID DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

Освобождает ресурсы, занимаемые критической секцией.

Критические секцииЛистинг 3. Псевдокод RtlDeleteCriticalSection из ntdll.dll

VOID RtlDeleteCriticalSection(LPRTL_CRITICAL_SECTION pcs)

{

  pcs->DebugInfo = NULL;

  pcs->LockCount = -1;

  pcs->RecursionCount = 0;

  pcs->OwningThread = 0;

  if (pcs->LockSemaphore)

  {

    ::CloseHandle(pcs->LockSemaphore);

    pcs->LockSemaphore = NULL;

  }

}

VOID EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

BOOL TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

Осуществляют "захват" критической секции. Если критическая секция занята другой нитью, то ::EnterCriticalSection() будет ждать, пока та освободится, а ::TryEnterCriticalSection() вернет FALSE. Отсутствует в Windows 9x/ME.

Критические секцииЛистинг 4. Псевдокод RtlEnterCriticalSection из ntdll.dll

VOID RtlEnterCriticalSection(LPRTL_CRITICAL_SECTION pcs)

{

  if (::InterlockedIncrement(&pcs->LockCount))

  {

    if (pcs->OwningThread == (HANDLE)::GetCurrentThreadId())

    {

      pcs->RecursionCount++;

      return;

    }

    RtlpWaitForCriticalSection(pcs);

  }

  pcs->OwningThread = (HANDLE)::GetCurrentThreadId();

  pcs->RecursionCount = 1;

}

BOOL RtlTryEnterCriticalSection(LPRTL_CRITICAL_SECTION pcs)

{

  if (-1L == ::InterlockedCompareExchange(&pcs->LockCount, 0, -1))

  {

    pcs->OwningThread = (HANDLE)::GetCurrentThreadId();

    pcs->RecursionCount = 1;

  }

  else if (pcs->OwningThread == (HANDLE)::GetCurrentThreadId())

  {

    ::InterlockedIncrement(&pcs->LockCount);

    pcs->RecursionCount++;

  }

  else

    return FALSE;

  return TRUE;

}

VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

Освобождает критическую секцию,

Критические секцииЛистинг 5. Псевдокод RtlLeaveCriticalSection из ntdll.dll

VOID RtlLeaveCriticalSectionDbg(LPRTL_CRITICAL_SECTION pcs)

{

  if (--pcs->RecursionCount)

    ::InterlockedDecrement(&pcs->LockCount);

  else if (::InterlockedDecrement(&pcs->LockCount) >= 0)

    RtlpUnWaitCriticalSection(pcs);

}

Классы-обертки для критических секций

Критические секцииЛистинг 6. Код классов CLock, CAutoLock и CScopeLock.

class CLock

{

  friend class CScopeLock;

  CRITICAL_SECTION m_CS;

public:

  void Init() { ::InitializeCriticalSection(&m_CS); }

  void Term() { ::DeleteCriticalSection(&m_CS); }

  void Lock() { ::EnterCriticalSection(&m_CS); }

  BOOL TryLock() { return ::TryEnterCriticalSection(&m_CS); }

  void Unlock() { ::LeaveCriticalSection(&m_CS); }

};

class CAutoLock : public CLock

{

public:

  CAutoLock() { Init(); }

  ~CAutoLock() { Term(); }

};

class CScopeLock

{

  LPCRITICAL_SECTION m_pCS;

public:

  CScopeLock(LPCRITICAL_SECTION pCS) : m_pCS(pCS) { Lock(); }

  CScopeLock(CLock& lock) : m_pCS(&lock.m_CS) { Lock(); }

  ~CScopeLock() { Unlock(); }

  void Lock() { ::EnterCriticalSection(m_pCS); }

  void Unlock() { ::LeaveCriticalSection(m_pCS); }

};

Классы CLock и CAutoLock удобно использовать для синхронизации доступа к переменным класса, а CScopeLock предназначен, в основном, для использования в процедурах. Удобно, что компилятор сам позаботится о вызове ::LeaveCriticalSection() через деструктор.

Критические секцииЛистинг 7. Пример использования CScopeLock.

CAutoLock m_lockObject;

CObject *m_pObject;

void Proc1()

{

  CScopeLock lock(m_ lockObject); // Вызов lock.Lock();

  if (!m_pObject)

    return; // Вызов lock.Unlock();

  m_pObject->SomeMethod();

  // Вызов lock.Unlock();

}

Отладка критических секций

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

Ошибки, связанные с реализацией

Это довольно легко обнаруживаемые ошибки, как правило, связанные с непарностью вызовов ::EnterCriticalSection() и ::LeaveCriticalSection().

Критические секцииЛистинг 8. Пропущен вызов ::EnterCriticalSection().

// Процедура предполагает, что m_lockObject.Lock(); уже был вызван

void Pool()

{

  for (int i = 0; i < m_vectSinks.size(); i++)

  {

    m_lockObject.Unlock();

    m_vectSinks[i]->DoSomething();

    m_lockObject.Lock();

  }

}

::LeaveCriticalSection() без ::EnterCriticalSection() приведет к тому, что первый же вызов ::EnterCriticalSection() остановит выполнение нити навсегда.

Критические секцииЛистинг 9. Пропущен вызов ::LeaveCriticalSection().

void Proc()

{

  m_lockObject.Lock();

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

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: