众所周知，windows平台上实现线程同步。或者说资源的加锁与解锁的方法有内核事件、临界区、相互排斥量、信号量，甚至interlocked系列函数等多种手段。

可是在日常的编程中，我们使用这些手段对 “多个线程同一时候对同一个资源进行读写” 的时候，在读写之前先要对资源假锁，读写完之后要对资源解锁。

设想这样一种情况，有一个ftpserver。每天有非常频繁的对这个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