src/Git/SharedMutex.cpp

   1 /**
   2 * SharedMutex.cpp
   3 * @Author   Tu Yongce <yongce (at) 126 (dot) com>
   4 * @Created  2008-11-17
   5 * @Modified 2008-11-17
   6 * @Version  0.1
   7 */
   8 #include "stdafx.h"
   9 #include "SharedMutex.h"
  10
  11
  12 SharedMutex::SharedMutex(): m_sharedNum(0), m_exclusiveNum(0), m_lockType(LOCK_NONE), m_mutex(0), m_sharedEvent(0),m_exclusiveEvent(0)
  13 {
  14 }
  15
  16 SharedMutex::~SharedMutex()
  17 {
  18 }
  19
  20 void SharedMutex::Release()
  21 {
  22         if (m_mutex)
  23         {
  24                 ::CloseHandle(m_mutex);
  25                 m_mutex = NULL;
  26         }
  27         if (m_sharedEvent)
  28         {
  29                 ::CloseHandle(m_sharedEvent);
  30                 m_sharedEvent = NULL;
  31         }
  32         if (m_exclusiveEvent)
  33         {
  34                 ::CloseHandle(m_exclusiveEvent);
  35                 m_exclusiveEvent = NULL;
  36         }
  37 }
  38 void SharedMutex::Init()
  39 {
  40         m_sharedNum = m_exclusiveNum = 0;
  41         m_lockType = LOCK_NONE;
  42
  43     // 创建用于保护内部数据的互斥量
  44     m_mutex = ::CreateMutex(NULL, FALSE, NULL);
  45     // 创建用于同步共享访问线程的事件（手动事件）
  46     m_sharedEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
  47     // 创建用于同步独占访问线程的事件（自动事件）
  48     m_exclusiveEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
  49 }
  50
  51 // 获取共享访问权
  52 bool SharedMutex::AcquireShared(DWORD waitTime)
  53 {
  54     ::WaitForSingleObject(m_mutex, INFINITE);
  55     ++m_sharedNum;
  56     if (m_lockType == LOCK_EXCLUSIVE) {
  57         DWORD retCode = ::SignalObjectAndWait(m_mutex, m_sharedEvent, waitTime, FALSE);
  58         if (retCode == WAIT_OBJECT_0) {
  59             return true;
  60         } else {
  61             if (retCode == WAIT_TIMEOUT)
  62                 ::SetLastError(WAIT_TIMEOUT);
  63             return false;
  64         }
  65     }
  66     m_lockType = LOCK_SHARED;
  67     ::ReleaseMutex(m_mutex);
  68     return true;
  69 }
  70
  71 // 释放共享访问权
  72 void SharedMutex::ReleaseShared()
  73 {
  74     //assert(m_lockType == LOCK_SHARED);
  75     ::WaitForSingleObject(m_mutex, INFINITE);
  76     --m_sharedNum;
  77     if (m_sharedNum == 0) {
  78         if (m_exclusiveNum > 0) {
  79             // 唤醒一个独占访问线程
  80             m_lockType = LOCK_EXCLUSIVE;
  81             ::SetEvent(m_exclusiveEvent);
  82         } else {
  83             // 没有等待线程
  84             m_lockType = LOCK_NONE;
  85         }
  86     }
  87     ::ReleaseMutex(m_mutex);
  88 }
  89
  90 // 获取独占访问权
  91 bool SharedMutex::AcquireExclusive(DWORD waitTime)
  92 {
  93
  94     ::WaitForSingleObject(m_mutex, INFINITE);
  95     ++m_exclusiveNum;
  96     if (m_lockType != LOCK_NONE) {
  97         DWORD retCode = ::SignalObjectAndWait(m_mutex, m_exclusiveEvent, waitTime, FALSE);
  98         if (retCode == WAIT_OBJECT_0) {
  99             return true;
 100         } else {
 101             if (retCode == WAIT_TIMEOUT)
 102                 ::SetLastError(WAIT_TIMEOUT);
 103             return false;
 104         }
 105     }
 106     m_lockType = LOCK_EXCLUSIVE;
 107     ::ReleaseMutex(m_mutex);
 108     return true;
 109 }
 110
 111 // 释放独占访问权
 112 void SharedMutex::ReleaseExclusive()
 113 {
 114 //    assert(m_lockType == LOCK_EXCLUSIVE);
 115     ::WaitForSingleObject(m_mutex, INFINITE);
 116     --m_exclusiveNum;
 117     // 独占访问线程优先
 118     if (m_exclusiveNum > 0) {
 119         // 唤醒一个独占访问线程
 120         ::SetEvent(m_exclusiveEvent);
 121     } else if (m_sharedNum > 0) {
 122         // 唤醒当前所有共享访问线程
 123         m_lockType = LOCK_SHARED;
 124         ::PulseEvent(m_sharedEvent);
 125     } else {
 126         // 没有等待线程
 127         m_lockType = LOCK_NONE;
 128     }
 129     ::ReleaseMutex(m_mutex);
 130 }