众所周知，windows平台上实现线程同步，或者说资源的加锁与解锁的方法有内核事件、临界区、互斥量、信号量，甚至interlocked系列函数等多种手段。但是在日常的编程中，我们使用这些手段对 “多个线程同时对同一个资源进行读写”的时候，在读写之前先要对资源假锁，读写完之后要对资源解锁。

设想这样一种情况，有一个ftp服务器，每天有很频繁的对这个ftp服务的文件进行下载，但是几乎好几天才会对这些文件进行更新。在我们每一次对文件下载的时候，读取文件的时候都要对文件进行加锁，以保证同时没有其他人对文件进行写入。但是这些加锁的行为，在99%的时候都是不会有人同时写入文件的，只有1%的情况下会有人同时也要写入文件。这样的话，我们多锁就大大的浪费了，而且你在加锁的同时，别人即使也只是读取文件，也需要等你先解锁。

解决这个问题的办法是，对文件的读取设置共享锁，多个线程可以同时读文件，不会互相阻塞。再设置独占锁，当要对文件进行写入的时候，加上独占锁，这样别的线程此时不能读也不能写。

windows提供了一个称为slim 的共享/独占锁来解决这个问题。但是呢，slim只在vista和window server 2008才支持。在之前的版本上没有支持。于是，我就w利用现有的线程同步手段，来模拟达到slim这一个共享/独占锁的功能，代码封装如下：

</pre><pre name="code" class="cpp">//共享和独占锁（读不锁，写锁），适用于资源的读的频率比写的频率高的情况
//共享锁: 大家都可以同时读，但是不能写。
//独占锁: 就是只有一个人独占使用，不管是读还是写
//规定：acquire和release必须成对出现，不支持嵌套以及互相嵌套
//缺点：需要对加锁过程本身进行临界区控制，会带来细微的性能损失
#ifdef __cplusplus
extern "C" {
#endif
struct SELock //Shared & Exclusive lock
{   
    RTL_CRITICAL_SECTION sec_shared,sec_exclusive; //对加锁代码本身进行临界区控制
    HANDLE exclusive_evt;
    HANDLE shared_evt;
    volatile long shared_count;
};

//初始化一个SE锁
_inline void InitializeSELock(SELock *lock)
{
    InitializeCriticalSection(&lock->sec_shared);
    InitializeCriticalSection(&lock->sec_exclusive);
    lock->exclusive_evt = CreateEventW(NULL,TRUE,TRUE,NULL);
    lock->shared_evt = CreateEventW(NULL,TRUE,TRUE,NULL);
    lock->shared_count = 0;
}

//清理一个SE锁
_inline void DeleteSELock(SELock *lock)
{    
    DeleteCriticalSection(&lock->sec_shared);
    DeleteCriticalSection(&lock->sec_exclusive);
    CloseHandle(lock->exclusive_evt);
    CloseHandle(lock->shared_evt);
    lock->shared_count = 0;
}

//请求共享锁，用于读
_inline void AcquireSELockShared(SELock *lock)
{
    EnterCriticalSection(&lock->sec_exclusive);   
    EnterCriticalSection(&lock->sec_shared);     
    WaitForSingleObject(lock->exclusive_evt,INFINITE); //等待独占锁    
    ++lock->shared_count;
    if(lock->shared_count)
        ResetEvent(lock->shared_evt); //打开共享锁      
    LeaveCriticalSection(&lock->sec_shared);
    LeaveCriticalSection(&lock->sec_exclusive);
}

//释放共享锁
_inline void ReleaseSELockShared(SELock *lock)
{
    EnterCriticalSection(&lock->sec_shared);    
    --lock->shared_count;    
    if(!lock->shared_count)
        SetEvent(lock->shared_evt); //关闭共享锁        
    LeaveCriticalSection(&lock->sec_shared);    
}

//请求独占锁
_inline void AcquireSELockExclusive(SELock *lock)
{
    EnterCriticalSection(&lock->sec_exclusive);    
    WaitForSingleObject(lock->exclusive_evt,INFINITE); //等待独占锁
    WaitForSingleObject(lock->shared_evt,INFINITE); //等待共享锁
    ResetEvent(lock->exclusive_evt); //打开独占锁
    LeaveCriticalSection(&lock->sec_exclusive);
}

//释放独占锁
_inline void ReleaseSELockExclusive(SELock *lock)
{
    SetEvent(lock->exclusive_evt); //关闭独占锁
}


#ifdef __cplusplus
}
#endif