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

  if (!m_pObject)

    return;

  //. .. 

  m_lockObject.Unlock();

}

В этом примере, конечно, имеет смысл воспользоваться классом типа CScopeLock.

Кроме того, случается, что ::EnterCriticalSection() вызывается без инициализации критической секции с помощью ::InitializeCriticalSection(). Особенно часто такое случается с проектами, написанными с помощью ATL. Причем в debug-версии все работает замечательно, а release-версия рушится. Это происходит из-за так называемой "минимальной" CRT (_ATL_MIN_CRT), которая не вызывает конструкторы статических объектов (Q166480, Q165076). В ATL версии 7.0 эту проблему решили.

Еще я встречал такую ошибку: программист пользовался классом типа CScopeLock, но для экономии места называл эту переменную одной буквой:

CScopeLock l(m_lock);

и как-то раз просто пропустил имя у переменной. Получилось

CScopeLock (m_lock);

Что это означает? Компилятор честно сделал вызов конструктора CScopeLock и тут же уничтожил этот безымянный объект, как и положено по стандарту. Т.е. сразу же после вызова метода Lock() последовал вызов Unlock(), и синхронизация перестала иметь место. Вообще, давать переменным, даже локальным, имена из одной буквы – путь быстрого наступления на всяческие грабли.

СОВЕТ

Если у вас в процедуре больше одного цикла, то вместо int i,j,k стоит все-таки использовать что-то вроде int nObject, nSection, nRow.

Архитектурные ошибки

Самая известная из них – это взаимоблокировка (deadlock), когда две нити пытаются захватить две или более критических секций, причем делают это в разном порядке.

Критические секцииЛистинг 10. Взаимоблокировка двух ниток.

void Proc1()

// Нить №1

{

  ::EnterCriticalSection(&m_lock1);

  //. .. 

    ::EnterCriticalSection(&m_lock2);

    //. .. 

    ::LeaveCriticalSection(&m_lock2);

  //. .. 

  ::LeaveCriticalSection(&m_lock1);

}

// Нить №2

void Proc2()

{

  ::EnterCriticalSection(&m_lock2);

  //. .. 

    ::EnterCriticalSection(&m_lock1);

    //. .. 

    ::LeaveCriticalSection(&m_lock1);

  //. .. 

  ::LeaveCriticalSection(&m_lock2);

}

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

CRITICAL_SECTION sec1;

CRITICAL_SECTION sec2;

//. ..

sec1 = sec2;

Из такого присвоения трудно извлечь какую-либо пользу. А вот такой код иногда пишут:

struct SData

{

  CLock m_lock;

  DWORD m_dwSmth;

} m_data;

void Proc1(SData& data)

{

  m_data = data;

}

и все бы хорошо, если бы у структуры SData был конструктор копирования, например такой:

SData(const SData data)

{

  CScopeLock lock(data.m_lock);

  m_dwSmth = data.m_dwSmth;

}

Но нет, программист посчитал, что хватит за глаза простого копирования полей, и, в результате, переменная m_lock была просто скопирована, хотя именно в этот момент из другой нити она была "захвачена", и значение поля LockCount у нее в этот момент больше либо равно нулю. После вызова ::LeaveCriticalSection() в той нити, у исходной переменной m_lock значение поля LockCount уменьшилось на единицу. А у скопированной переменной – осталось прежним. И любой вызов ::EnterCriticalSection() в этой нити никогда не вернется. Он будет вечно ждать неизвестно чего.

Это только цветочки. С ягодками вы очень быстро столкнетесь, если попытаетесь написать что-нибудь действительно сложное. Например, ActiveX-объект в многопоточном подразделении (MTA), создаваемый из скрипта, запущенного из-под контейнера, размещенного в однопоточном подразделении (STA). Ни слова не понятно? Не беда. Сейчас я попытаюсь выразить проблему более понятным языком. Итак. Имеется объект, вызывающий методы другого объекта, причем живут они в разных нитях. Вызовы производятся синхронно. Т.е. объект №1 переключает выполнение на нить объекта №2, вызывает метод и переключается обратно на свою нить. При этом выполнение нити №1 приостановлено до тех пор, пока не отработает нить объекта №2. Теперь, положим, объект №2 вызывает метод объекта №1 из своей нити. Получается, что управление вернулось в объект №1, но из нити объекта №2. Если объект №1 вызывал метод объекта №2, захватив какую-либо критическую секцию, то при вызове метода объекта №1 тот заблокирует сам себя при повторном входе в ту же критическую секцию.

Листинг 11. Самоблокировка средствами одного объекта.

// Нить №1

void IObject1::Proc1()

{

  // Входим в критическую секцию объекта №1

  m_lockObject.Lock();

  // Вызываем метод объекта №2, происходит переключение на нить объекта №2

  m_pObject2->SomeMethod();

  // Сюда мы попадем только по возвращении из m_pObject2->SomeMethod()

  m_lockObject.Unlock();

}

// Нить №2

void IObject2::SomeMethod()

{

  // Вызываем метод объекта №1 из нити объекта №2

  m_pObject1->Proc2();

}

// Нить №2

void IObject1::Proc2()

{

  // Пытаемся войти в критическую секцию объекта №1

  m_lockObject.Lock();

  // Сюда мы не попадем никогда

  m_lockObject.Unlock();

}

Если бы в примере не было переключения нитей, все вызовы произошли бы в нити объекта №1, и никаких проблем не возникло. Сильно надуманный пример? Ничуть. Именно переключение ниток лежит в основе подразделений (apartments) COM. А из этого следует одно очень, очень неприятное правило.

СОВЕТ

Избегайте вызовов каких бы то ни было объектов при захваченных критических секциях.

Помните пример из начала статьи? Так вот, он абсолютно неприемлем в подобных случаях. Его придется переделать на что-то вроде примера, приведенного в листинге 12.

Листинг 12. Простой пример, не подверженный самоблокировке.

// Нить №1

void Proc1()

{

  m_lockObject.Lock();

  CComPtr<IObject> pObject(m_pObject); // вызов pObject->AddRef();

  m_lockObject.Unlock();

  if (pObject)

    pObject->SomeMethod();

}

// Нить №2

void Proc2(IObject *pNewObject)

{

  m_lockObject.Lock();

  m_pObject = pNewobject;

  m_lockObject.Unlock();

}

Доступ к объекту по-прежнему синхронизован, но вызов SomeMethod(); происходит вне критической секции. Победа? Почти. Осталась одна маленькая деталь. Давайте посмотрим, что происходит в Proc2():

void Proc2(IObject *pNewObject)

{

  m_lockObject.Lock();

  if (m_pObject.p)

    m_pObject.p->Release();

  m_pObject.p = pNewobject;

  if (m_pObject.p)

    m_pObject.p->AddRef();

  m_lockObject.Unlock();

}

Очевидно, что вызовы m_pObject.p->AddRef(); и m_pObject.p->Release(); происходят внутри критической секции. И если вызов метода AddRef(), как правило, безвреден, то вызов метода Release() может оказаться последним вызовом Release(), и объект самоуничтожится. В методе FinalRelease() объекта №2 может быть все что угодно, например, освобождение объектов, живущих в других подразделениях. А это опять приведет к переключению ниток и может вызвать самоблокировку объекта №1 по уже известному сценарию. Придется воспользоваться той же техникой, что и в методе Proc1():

Листинг 13

// Нить №2

void Proc2(IObject *pNewObject)

{

  CComPtr<IObject> pPrevObject;

  m_lockObject.Lock();

  pPrevObject.Attach(m_pObject.Detach());

  m_pObject = pNewobject;

  m_lockObject.Unlock();

  // pPrevObject.Release();

}

Теперь потенциально последний вызов IObject2::Release() будет осуществлен после выхода из критической секции. А присвоение нового значения по-прежнему синхронизовано с вызовом IObject2::SomeMethod() из нити №1.

Способы обнаружения ошибок

Сначала стоит обратить внимание на "официальный" способ обнаружения блокировок. Если бы кроме ::EnterCriticalSection() и ::TryEnterCtiticalSection() существовал еще и ::EnterCriticalSectionWithTimeout(), то достаточно было бы просто указать какое-нибудь резонное значение для интервала ожидания, например, 30 секунд. Если критическая секция не освободилась в течение указанного времени, то с очень большой вероятностью она не освободится никогда. Имеет смысл подключить отладчик и посмотреть, что же творится в соседних нитях. Но увы. Никаких ::EnterCriticalSectionWithTimeout() в Win32 не предусмотрено. Вместо этого есть поле CriticalSectionDefaultTimeout в структуре IMAGE_LOAD_CONFIG_DIRECTORY32, которое всегда равно нулю и, судя по всему, не используется. Зато используется ключ в реестре "HKLMSYSTEMCurrentControlSetControlSession ManagerCriticalSectionTimeout", который по умолчанию равен 30 суткам, и по истечению этого времени в системный лог попадает строка "RTL: Enter Critical Section Timeout (2 minutes)nRTL: Pid.Tid XXXX.YYYY, owner tid ZZZZnRTL: Re-Waitingn". К тому же это верно только для систем WindowsNT/2k/XP и только с CheckedBuild. У вас установлен CheckedBuild? Нет? А зря. Вы теряете исключительную возможность увидеть эту замечательную строку.

Ну, а какие у нас альтернативы? Да, пожалуй, только одна. Не использовать API для работы с критическими секциями. Вместо них написать свои собственные. Пусть даже не такие обточенные напильником, как в Windows NT. Не страшно. Нам это понадобится только в debug-конфигурациях. В release'ах мы будем продолжать использовать оригинальный API от Майкрософт. Для этого напишем несколько функций, полностью совместимых по типам и количеству аргументов с "настоящим" API, и добавим #define, как у MFC, для переопределения оператора new в debug-конфигурациях.

Листинг 14. Собственная реализация критических секций.

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

#define DEADLOCK_TIMEOUT 30000

#define CS_DEBUG 1

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

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

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 pcs)

{

  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", DEADLOCK_TIMEOUT,

          ::GetCurrentThreadId(), pcs->OwningThread);

    }

  }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 EnterCriticalSectionDbg(LPCRITICAL_SECTION pcs)

{

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

  {

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

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

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

    {

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

      pcs->RecursionCount++;

      return;

    }

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

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

    _WaitForCriticalSectionDbg(pcs);

  }

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

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

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

  pcs->RecursionCount = 1;

}

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

inline BOOL TryEnterCriticalSectionDbg(LPCRITICAL_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;

}

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

inline VOID LeaveCriticalSectionDbg(LPCRITICAL_SECTION pcs)

{

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

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

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

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

  if (--pcs->RecursionCount)

  {

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

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

    ::InterlockedDecrement(&pcs->LockCount);

  }

  else

  {

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

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

    ATLASSERT(NULL != pcs->OwningThread);

    pcs->OwningThread = NULL;

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

    {

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

      _UnWaitCriticalSectionDbg(pcs);

    }

  }

}

//

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

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

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

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