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

Удостоверяемся, что ::EnterCriticalSection() была вызвана

// до вызова этого метода

inline BOOL CheckCriticalSection(LPCRITICAL_SECTION pcs)

{

  return pcs->LockCount >= 0

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

}

// Переопределяем все функции для работы с критическими секциями.

// Определение класса CLock должно быть после этих строк

#define EnterCriticalSection EnterCriticalSectionDbg

#define TryEnterCriticalSection TryEnterCriticalSectionDbg

#define LeaveCriticalSection LeaveCriticalSectionDbg

#endif

Ну и заодно добавим еще один метод в наш класс Clock (листинг 15).

Листинг 15. Класс CLock с новым методом.

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); }

  BOOL Check() { return CheckCriticalSection(&m_CS); }

};

Использовать метод Check() в release-конфигурациях не стоит, возможно, что в будущем, в какой-нибудь Windows64, структура RTL_CRITICAL_SECTION изменится, и результат такой проверки будет не определен. Так что ему самое место "жить" внутри всяческих ASSERT'ов.

Итак, что мы имеем? Мы имеем проверку на лишний вызов ::LeaveCriticalSection() и ту же трассировку для блокировок. Не так уж много. Особенно если трассировка о блокировке имеет место, а вот нить, забывшая освободить критическую секцию, давно завершилась. Как быть? Вернее, что бы еще придумать, чтобы ошибку проще было выявить? Как минимум, прикрутить сюда __LINE__ и __FILE__, константы, соответствующие текущей строке и имени файла на момент компиляции этого метода.

VOID EnterCriticalSectionDbg(LPCRITICAL_SECTION pcs

  , int nLine = __LINE__, azFile = __FILE__);

Компилируем, запускаем... Результат удивительный. Хотя правильный. Компилятор честно подставил номер строки и имя файла, соответствующие началу нашей EnterCriticalSectionDbg(). Так что придется попотеть немного больше. __LINE__ и __FILE__ нужно вставить в #define'ы, тогда мы получим действительные номер строки и имя исходного файла. Теперь вопрос, куда же сохранить эти параметры для дальнейшего использования? Причем хочется оставить за собой возможность вызова стандартных функций API наряду с нашими собственными? На помощь приходит C++: просто создадим свою структуру, унаследовав ее от RTL_CRITICAL_SECTION (листинг 16).

Листинг 16. Реализация критических секций с сохранением строки и имени файла.

#if defined(_DEBUG) && !defined(_NO_DEADLOCK_TRACE)

#define DEADLOCK_TIMEOUT 30000

#define CS_DEBUG 2

// Наша структура взамен CRITICAL_SECTION

struct CRITICAL_SECTION_DBG : public CRITICAL_SECTION

{

  // Добавочные поля

  int     m_nLine;

  LPCSTR    m_azFile;

};

typedef struct CRITICAL_SECTION_DBG *LPCRITICAL_SECTION_DBG;

// Создаем на лету событие для операций ожидания,

// но никогда его не освобождаем. Так удобней для отладки.

static inline HANDLE _CriticalSectionGetEvent(LPCRITICAL_SECTION pcs)

{

  HANDLE ret = pcs->LockSemaphore;

  if (!ret)

  {

    HANDLE sem = ::CreateEvent(NULL, false, false, NULL);

    ATLASSERT(sem);

    if (!(ret = (HANDLE)::InterlockedCompareExchangePointer(

        &pcs->LockSemaphore, sem, NULL)))

      ret = sem;

    else

      ::CloseHandle(sem); // Кто-то успел раньше

  }

  return ret;

}

// Ждем, пока критическая секция не освободится либо время ожидания

// будет превышено

static inline VOID _WaitForCriticalSectionDbg(LPCRITICAL_SECTION_DBG pcs

  , int nLine, LPCSTR azFile)

{

  HANDLE sem = _CriticalSectionGetEvent(pcs);

  DWORD dwWait;

  do

  {

    dwWait = ::WaitForSingleObject(sem, DEADLOCK_TIMEOUT);

    if (WAIT_TIMEOUT == dwWait)

    {

      ATLTRACE("Critical section timeout (%u msec):"

        " tid 0x%04X owner tid 0x%04Xn"

        "Owner lock from %hs line %u, waiter %hs line %un"

        , DEADLOCK_TIMEOUT

        , ::GetCurrentThreadId(), pcs->OwningThread

        , pcs->m_azFile, pcs->m_nLine, azFile, nLine);

    }

  }while(WAIT_TIMEOUT == dwWait);

  ATLASSERT(WAIT_OBJECT_0 == dwWait);

}

// Выставляем событие в активное состояние

static inline VOID _UnWaitCriticalSectionDbg(LPCRITICAL_SECTION pcs)

{

  HANDLE sem = _CriticalSectionGetEvent(pcs);

  BOOL b = ::SetEvent(sem);

  ATLASSERT(b);

}

// Инициализируем критическую секцию.

inline VOID InitializeCriticalSectionDbg(LPCRITICAL_SECTION_DBG pcs)

{

  // Пусть система заполнит свои поля

  InitializeCriticalSection(pcs);

  // Заполняем наши поля

  pcs->m_nLine = 0;

  pcs->m_azFile = NULL;

}

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

inline VOID DeleteCriticalSectionDbg(LPCRITICAL_SECTION_DBG pcs)

{

  // Проверяем, чтобы не было удалений "захваченных" критических секций

  ATLASSERT(0 == pcs->m_nLine && NULL == pcs->m_azFile);

  // Остальное доделает система

  DeleteCriticalSection(pcs);

}

// Заполучаем критическую секцию в свое пользование

inline VOID EnterCriticalSectionDbg(LPCRITICAL_SECTION_DBG pcs

  , int nLine, LPSTR azFile)

{

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

  {

    // LockCount стал больше нуля.

    // Проверяем идентификатор нити

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

    {

      // Нить та же самая. Критическая секция наша.

      // Никаких дополнительных действий не производим.

      // Это не совсем верно, так как возможно, что непарный

      // вызов ::LeaveCriticalSection() был сделан на n-ном заходе,

      // и это придется отлавливать вручную, но реализация

      // стека для __LINE__ и __FILE__ сделает нашу систему

      // более громоздкой. Если это действительно необходимо,

      // вы всегда можете сделать это самостоятельно

      pcs->RecursionCount++;

      return;

    }

    // Критическая секция занята другой нитью.

    // Придется подождать

    _WaitForCriticalSectionDbg(pcs, nLine, azFile);

  }

  // Либо критическая секция была "свободна",

  // либо мы дождались. Сохраняем идентификатор текущей нити.

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

  pcs->RecursionCount = 1;

  pcs->m_nLine = nLine;

  pcs->m_azFile = azFile;

}

// Заполучаем критическую секцию, если она никем не занята

inline BOOL TryEnterCriticalSectionDbg(LPCRITICAL_SECTION_DBG pcs

  , int nLine, LPSTR azFile)

{

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

  {

    // Это первое обращение к критической секции

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

    pcs->RecursionCount = 1;

    pcs->m_nLine = nLine;

    pcs->m_azFile = azFile;

  }

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

  {

    // Это не первое обращение, но из той же нити

    ::InterlockedIncrement(&pcs->LockCount);

    pcs->RecursionCount++;

  }

  else

    return FALSE; // Критическая секция занята другой нитью

  return TRUE;

}

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

inline VOID LeaveCriticalSectionDbg(LPCRITICAL_SECTION_DBG pcs)

{

  // Проверяем, чтобы идентификатор текущей нити совпадал

  // с идентификатором нити-влядельца.

  // Если это не так, скорее всего мы имеем дело с ошибкой

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

  if (--pcs->RecursionCount)

  {

    // Не последний вызов из этой нити.

    // Уменьшаем значение поля LockCount

    ::InterlockedDecrement(&pcs->LockCount);

  }

  else

  {

    // Последний вызов. Нужно "разбудить" какую-либо

    // из ожидающих ниток, если таковые имеются

    ATLASSERT(NULL != pcs->OwningThread);

    pcs->OwningThread = NULL;

    pcs->m_nLine = 0;

    pcs->m_azFile = NULL;

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

    {

      // Имеется, как минимум, одна ожидающая нить

      _UnWaitCriticalSectionDbg(pcs);

    }

  }

}

// Удостоверяемся, что ::EnterCriticalSection() была вызвана

// до вызова этого метода

inline BOOL CheckCriticalSection(LPCRITICAL_SECTION pcs)

{

  return pcs->LockCount >= 0

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

}

// Переопределяем все функции для работы с критическими секциями.

// Определение класса CLock должно быть после этих строк

#define InitializeCriticalSection InitializeCriticalSectionDbg

#define InitializeCriticalSectionAndSpinCount(pcs, c)

     InitializeCriticalSectionDbg(pcs)

#define DeleteCriticalSection DeleteCriticalSectionDbg

#define EnterCriticalSection(pcs) EnterCriticalSectionDbg(pcs, __LINE__, __FILE__)

#define TryEnterCriticalSection(pcs)

  TryEnterCriticalSectionDbg(pcs, __LINE__, __FILE__)

#define LeaveCriticalSection LeaveCriticalSectionDbg

#define CRITICAL_SECTION CRITICAL_SECTION_DBG

#define LPCRITICAL_SECTION LPCRITICAL_SECTION_DBG

#define PCRITICAL_SECTION PCRITICAL_SECTION_DBG

#endif

Приводим наши классы в соответствие (листинг 17).

Листинг 17. Классы CLock и CScopeLock, вариант для отладки.

class CLock

{

  friend class CScopeLock;

  CRITICAL_SECTION m_CS;

public:

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

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

#if defined(CS_DEBUG)

  BOOL Check() { return CheckCriticalSection(&m_CS); }

#endif

#if CS_DEBUG > 1

  void Lock(int nLine, LPSTR azFile) { EnterCriticalSectionDbg(&m_CS, nLine, azFile); }

  BOOL TryLock(int nLine, LPSTR azFile) { return TryEnterCriticalSectionDbg(&m_CS, nLine, azFile); }

#else

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

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

#endif

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

};

class CScopeLock

{

  LPCRITICAL_SECTION m_pCS;

public:

#if CS_DEBUG > 1

  CScopeLock(LPCRITICAL_SECTION pCS, int nLine, LPSTR azFile) : m_pCS(pCS) { Lock(nLine, azFile); }

  CScopeLock(CLock& lock, int nLine, LPSTR azFile) : m_pCS(&lock.m_CS) { Lock(nLine, azFile); }

  void Lock(int nLine, LPSTR azFile) { EnterCriticalSectionDbg(m_pCS, nLine, azFile); }

#else

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

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

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

#endif

  ~CScopeLock() { Unlock(); }

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

};

#if CS_DEBUG > 1

#define Lock() Lock(__LINE__, __FILE__)

#define TryLock() TryLock(__LINE__, __FILE__)

#define lock(cs) lock(cs, __LINE__, __FILE__)

#endif

К сожалению, пришлось даже переопределить CScopeLock lock(cs), причем жестко привязаться к имени переменной. Не стоит говорить о том, что наверняка получился конфликт имен - все-таки Lock довольно популярное название для метода. Такой код не будет собираться, например, с популярнейшей библиотекой ATL. Тут есть два способа. Переименовать методы Lock() и TryLock() во что-нибудь более уникальное, либо переименовать Lock() в ATL:

// StdAfx.h

//. ..

#define Lock ATLLock

#include <AtlBase.h>

//. ..

Сменим тему

А что это мы все про Win32 API да про C++? Давайте посмотрим, как обстоят дела с критическими секциями в более современных языках программирования.

C#

Тут стараниями Майкрософт имеется полный набор старого доброго API под новыми именами.

Критические секции представлены классом System.Threading.Monitor, вместо ::EnterCriticalSection() есть Monitor.Enter(object), а вместо ::LeaveCriticalSection() Monitor.Exit(object), где object – это любой объект C#. Т.е. каждый объект где-то в потрохах CLR (Common Language Runtime) имеет свою собственную критическую секцию либо заводит ее по необходимости. Типичное использование этой секции выглядит так:

Monitor.Enter(this);

m_dwSmth = dwSmth;

Monitor.Exit(this);

Если нужно организовать отдельную критическую секцию для какой-либо переменной, самым логичным способом будет поместить ее в отдельный объект и использовать этот объект как аргумент при вызове Monitor.Enter/Exit(). Кроме того, в C# существует ключевое слово lock, это полный аналог нашего класса CScopeLock.

lock (this)

{

  m_dwSmth = dwSmth;

}

А вот Monitor.TryEnter() в C# (о, чудо!) принимает в качестве параметра максимальный период ожидания.

Замечу, что CLR – это не только C#, все это применимо и к другим языкам, использующим CLR.

Java

В этом языке используется подобный механизм, только место ключевого слова lock есть ключевое слово synchronized, а все остальное – точно так же.

synchronized (this)

{

  m_dwSmth = dwSmth;

}

MC++ (управляемый C++)

Тут тоже появился атрибут [synchronized] ведущий себя точно так же, как и одноименное ключевое слово из Java. Странно, что архитекторы из Майкрософт решили позаимствовать синтаксис из продукта от Sun Microsystems вместо своего собственного.

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

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

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

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