动手实现读写锁

排他锁的弊端

     在多个线程之间共享数据，普遍做法是加锁读写，也就是同一个时刻只有一个线程能够读或者写，以保证数据一致性，即线程安全。例如下面的伪代码是常见的做法

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