動手實現讀寫鎖

排他鎖的弊端

     在多個線程之間共享數據，普遍做法是加鎖讀寫，也就是同一個時刻只有一個線程能夠讀或者寫，以保證數據一致性，即線程安全。例如下面的偽代碼是常見的做法

void Read()
{
    Lock(mutex);

    // 讀取數據

    UnLock(mutex);
}

void Write()
{
    Lock(mutex);

    // 寫入數據

    UnLock(mutex);
}

 

讀寫鎖的設計

     這樣的鎖是具有排他性的，會在一定程度上影響程序的效率。假設有多個線程競爭獲得讀寫權利，顯然同一個時刻只有一個線程能夠獲得，要么進行讀操作，要么進行寫操作，而且，在讀操作和讀操作之間，或在寫操作和寫操作之間，同樣具有排他性，存在下面的關系

1、讀-寫，排他

2、寫-寫，排他

3、讀-讀，排他

     既然排他鎖影響程序效率，那么該如何優化呢？排他鎖的目的，為了避免出現這樣的競爭條件，在一個線程在未完成讀操作之前，另一個線程寫操作改變了數據，或者多個線程同時進行寫操作。顯然，在讀操作和寫操作之間，或在寫操作和寫操作之間，要求具有排他性，而排他鎖帶入到負面影響是，在讀操作和讀操作之間也具有了排他性。到這里，可以設想一下讀寫鎖能夠解決什么問題，沒錯，就是為了屏蔽這個負面影響，能夠滿足下面的關系

1、讀-寫，排他

2、寫-寫，排他

3、讀-讀，共享

     簡單地說，就是多個線程能夠同時進行讀操作。思路如下（偽代碼）

void Read()
{
    Wait(condition);

    Lock(mutex);
    if(0 == Count++)
        Lock(semaphore);
    UnLock(mutex);

    // 讀取數據

    Lock(mutex);
    if(0 == --Count)
        UnLock(semaphore);
    UnLock(mutex);
}

void Write()
{
    Destroy(condition);
    Lock(semaphore);

    // 寫入數據

    UnLock(semaphore);
    Create(condition);
}

　　在代碼中，信號量semaphore的初值為1，為了讀-寫能夠排他和寫-寫排他這兩個關系。Count記錄有多少個讀操作，而mutex是為了保證Count線程安全。忽略condition相關的代碼，可以說，已經實現了前面提到的讀寫鎖。但為什么加入condition呢？原因是這樣的，如果有多個線程在連續進行讀操作，可能導致長時間不能進行寫操作，也就是通常說的寫鎖飢餓。condition可以解決這個問題，如果有線程正在等待寫操作，那么新的讀操作先等待，等到寫操作完成后再開始。這樣可以保證獲得讀寫操作的機會是相對公平的。

在Windows中實現讀寫鎖

　　在Windows平台，Vista和Server 2008及其更高的版本才開始提供讀寫鎖相關的API，如果需要支持XP系統，那么往往需要自己實現讀寫鎖機制。前面已經介紹過如何實現讀寫鎖，這里不費口舌，直接貼出代碼

// 實現代碼

class RWLock
{
public:
    RWLock();
    ~RWLock();
public:
    void AcquireReadLock();
    void ReleaseReadLock();
    void AcquireWriteLock();
    void ReleaseWriteLock();
private:
    volatile DWORD      m_cnt;
    CRITICAL_SECTION    m_cs;
    HANDLE              m_evt;
    HANDLE              m_sem;
};

RWLock::RWLock()
    : m_cnt(0)
    , m_evt(NULL)
    , m_cs(NULL)
    , m_sem(NULL)
{
    // 提倡的做法在專門的初始化函數里創建和初始化這些變量

    ::InitializeCriticalSection(&m_cs);

    // Event必須是手動重置，否則存在死鎖隱患，即等待Event前，先被激活了
    m_evt = ::CreateEvent(NULL, TRUE, TRUE, NULL);
    m_sem = ::CreateSemaphore(NULL, 1, 1, NULL);
}

RWLock::~RWLock()
{
    ::CloseHandle(m_sem);
    ::CloseHandle(m_evt);
    ::DeleteCriticalSection(&m_cs);
}

void RWLock::AcquireReadLock()
{
    ::WaitForSingleObject(m_evt, INFINITE);

    ::EnterCriticalSection(&m_cs);
    if(0 == m_cnt++)
        ::WaitForSingleObject(m_sem, INFINITE);
    ::LeaveCriticalSection(&m_cs);
}

void RWLock::ReleaseReadLock()
{
    ::EnterCriticalSection(&m_cs);
    if(0 == --m_cnt)
        ::ReleaseSemaphore(m_sem, 1, NULL);
    ::LeaveCriticalSection(&m_cs);
}

void RWLock::AcquireWriteLock()
{
    ::ResetEvent(m_evt);
    ::WaitForSingleObject(m_sem, INFINITE);
}

void RWLock::ReleaseWriteLock()
{
    ::ReleaseSemaphore(m_sem, 1, NULL);
    ::SetEvent(m_evt);
}

// 使用示例

void Read()
{
    // 多個線程能夠同時進行讀操作

    rwLock.AcquireReadLock();

    // 讀取數據
    
    rwLock.ReleaseReadLock();
}

void Write()
{
    rwLock.AcquireWriteLock();

    // 寫入數據

    rwLock.ReleaseWriteLock();
}

 

PS：本文為博主的原創文章，請尊重博主辛苦碼字的成果，轉載請注明鏈接

http://www.cnblogs.com/coldberry/p/ReadWriteLock.html