读写锁

《windows核心编程》中讲到读写锁，slim读写锁。总结如下：

当前读写锁rwLock被ReadThread_A占有读共享锁，之后有一线程ReadThread_B申请读共享锁。
（1）.如果ReadThread_A线程释放共享锁之前（或者是ReadThread_A释放了读共享锁，但读共享锁仍被其他读线程占用着），没有写线程申请过写锁（排它锁），这时ReadThread_B是能够

直接获得读共享锁的，不会被阻塞。
（2）.如果ReadThread_A线程释放共享锁之前（或者是ReadThread_A释放了读共享锁，但读共享锁仍被其他读线程占用着），有写线程WriteThread申请过写锁（排它锁）,这时ReadThread_B是不能立即获得读共享锁的，它必须等到WriteThread释放了写锁之后才能获得读共享锁。
      这一点同数据库操作中获取锁的模式有点相似。（针对同一张数据表）在数据库中，如果当前有查询操作在进行时，如果没有写入请求，这时新来的查询请求会立即获得Share锁，而不需要等待。如果当前查询进行时，来了一个写请求，之后又来了一个查询请求，这个新来的查询请求会被阻塞，需要等到写操作完成之后才能进行查询。

针对第2点，我存在怀疑，做了验证，特记录如下，以备查询。

 

#include "stdafx.h"
#include <iostream>
#include <Windows.h>
#include <process.h>
using namespace std;


SRWLOCK rwLock;

unsigned int WINAPI readPro(void* param)
{
    printf("Thread %d is going to acquire read lock.\n",GetCurrentThreadId());
    AcquireSRWLockShared(&rwLock);
    printf("Thread %d got the read lock.\n...reading...\n",GetCurrentThreadId());
    Sleep(10000);
    ReleaseSRWLockShared(&rwLock);
    printf("Thread %d released read lock.\n,",GetCurrentThreadId());
    return 2;
}

unsigned int WINAPI writePro(void* param)
{
    printf("Thread %d is going to acquire write lock.\n",GetCurrentThreadId());
    AcquireSRWLockExclusive(&rwLock);
    printf("Thread %d got the write lock.\n...writing...\n",GetCurrentThreadId());
    Sleep(5000);
    ReleaseSRWLockExclusive(&rwLock);
    printf("Thread %d released write lock.\n",GetCurrentThreadId());
    return 3;
}


int _tmain(int argc, _TCHAR* argv[])
{
    InitializeSRWLock(&rwLock);
    
    HANDLE hR1 = (HANDLE)_beginthreadex(NULL,0,readPro,NULL,0,NULL);
    HANDLE hR2 = (HANDLE)_beginthreadex(NULL,0,readPro,NULL,0,NULL);

    Sleep(2000);    
    HANDLE hW1 = (HANDLE)_beginthreadex(NULL,0,writePro,NULL,0,NULL);
    HANDLE hR3 = (HANDLE)_beginthreadex(NULL,0,readPro,NULL,0,NULL);    

    WaitForSingleObject(hR1,INFINITE);
    CloseHandle(hR1);
    hR1 = INVALID_HANDLE_VALUE;

    WaitForSingleObject(hR2,INFINITE);
    CloseHandle(hR2);
    hR2 = INVALID_HANDLE_VALUE;

    WaitForSingleObject(hR3,INFINITE);
    CloseHandle(hR3);
    hR3 = INVALID_HANDLE_VALUE;

    WaitForSingleObject(hW1,INFINITE);
    CloseHandle(hW1);
    hW1 = INVALID_HANDLE_VALUE;

    system("pause");

	return 0;
}

 

运行结果：