#pragma pack(push, 8)
typedef struct _MYSRWLOCK
{
	CRITICAL_SECTION csWriter;
	void* pSharedCount;
} MYSRWLOCK;
typedef MYSRWLOCK *PMYSRWLOCK;
#pragma pack(pop)

static void MyInitializeSRWLock(PMYSRWLOCK srwlock)
{
	InitializeCriticalSectionAndSpinCount(&srwlock->csWriter, 0xFA0);
	srwlock->pSharedCount = _aligned_malloc(sizeof(LONG), MEMORY_ALLOCATION_ALIGNMENT);
	_InterlockedExchange((volatile LONG*)srwlock->pSharedCount, 0);
}
static void MyFreeSRWLock(PMYSRWLOCK srwlock)
{
	DeleteCriticalSection(&srwlock->csWriter);
	_aligned_free(srwlock->pSharedCount);
}
class SRWLockShared
{
public:
	static void Acquire(PMYSRWLOCK srwlock)
	{
		EnterCriticalSection(&srwlock->csWriter);
		_InterlockedIncrement((volatile LONG*)srwlock->pSharedCount);
		LeaveCriticalSection(&srwlock->csWriter);
	}
	static void Release(PMYSRWLOCK srwlock)
	{
		_InterlockedDecrement((volatile LONG*)srwlock->pSharedCount);
	}
    SRWLockShared(PMYSRWLOCK srwlock) : m_srwlock(srwlock)
    {
		Acquire(m_srwlock);
    }

    ~SRWLockShared()
    {
		Release(m_srwlock);
    }

private:
    PMYSRWLOCK m_srwlock;
};

class SRWLockExclusive
{
public:
	static void Acquire(PMYSRWLOCK srwlock)
	{
		EnterCriticalSection(&srwlock->csWriter);
		while(_InterlockedCompareExchange((volatile LONG*)srwlock->pSharedCount, -1, 0) != 0);
	}
	static void Release(PMYSRWLOCK srwlock)
	{
		_InterlockedIncrement((volatile LONG*)srwlock->pSharedCount);
		LeaveCriticalSection(&srwlock->csWriter);
	}
    SRWLockExclusive(PMYSRWLOCK srwlock) : m_srwlock(srwlock)
    {
		Acquire(m_srwlock);
    }
    ~SRWLockExclusive()
    {
		Release(m_srwlock);
    }

private:
    PMYSRWLOCK m_srwlock;
};

MYSRWLOCK m_lock;

初始化
MyInitializeSRWLock(&m_lock);

销毁
MyFreeSRWLock(&m_lock);


共享锁
{
SRWLockShared lock(&m_lock);
}

互斥锁
{
SRWLockExclusive lock(&m_lock);
}

// 读写锁
#if !defined(_WIN32) && !defined(_WIN64)

#  include <pthread.h>

typedef pthread_mutex_t Lock_type;
typedef pthread_cond_t WaitCondition;
typedef pthread_t ThreadHandle;

#  define lock_init(x) pthread_mutex_init(&(x), NULL)
#  define lock_grab(x) pthread_mutex_lock(&(x))
#  define lock_release(x) pthread_mutex_unlock(&(x))
#  define lock_destroy(x) pthread_mutex_destroy(&(x))

#  define cond_init(x) pthread_cond_init(&(x), NULL)
#  define cond_destroy(x) pthread_cond_destroy(&(x))
#  define cond_signal(x) pthread_cond_signal(&(x))
#  define cond_timedwait(x,y,z) pthread_cond_timedwait(&(x),&(y),z)
#  define cond_wait(x,y) pthread_cond_wait(&(x),&(y))

#  define sem_init(x) pthread_cond_init(&(x), NULL)
#  define sem_destroy(x) pthread_cond_destroy(&(x))
#  define sem_signal_one(x) pthread_cond_signal(&(x))
#  define sem_signal_all(x) pthread_cond_broadcast(&(x))
#  define sem_timedwait(x,y,z) pthread_cond_timedwait(&(x),&(y),z)
#  define sem_wait(x,y) pthread_cond_wait(&(x),&(y))


#  define thread_create(x,f,id) !pthread_create(&(x),NULL,(void* (*)(void*))f,&(id))
#  define thread_join(x) pthread_join(x, NULL)

#else

#include <Windows.h>
#include <limits.h>

typedef CRITICAL_SECTION Lock_type;
typedef HANDLE WaitCondition;
typedef HANDLE ThreadHandle;

#define lock_init(x) InitializeCriticalSection(&(x))
#define lock_grab(x) EnterCriticalSection(&(x))
#define lock_release(x) LeaveCriticalSection(&(x))
#define lock_destroy(x) DeleteCriticalSection(&(x))

#define cond_init(x) { x = CreateEvent(0, FALSE, FALSE, 0); }
#define cond_destroy(x) CloseHandle(x)
#define cond_signal(x) SetEvent(x)
#define cond_timedwait(x,y,z) { lock_release(y); WaitForSingleObject(x,z); lock_grab(y); }
#define cond_wait(x,y) { cond_timedwait((x), (y), INFINITE); }

#define sem_init(x) { x = CreateSemaphore(0, 0, LONG_MAX, 0); }
#define sem_destroy(x) { CloseHandle((x)); }
#define sem_signal(x,y) { ReleaseSemaphore((x), (y), 0); }
#define sem_signal_one(x) { sem_signal((x), 1); }
#define sem_signal_all(x) { sem_signal((x), LONG_MAX); }
#define sem_timedwait(x,y,z) { lock_release((y)); WaitForSingleObject((x), (z));lock_grab((y));  }
#define sem_wait(x,y) { sem_timedwait((x), (y), INFINITE); }

#define thread_create(x,f,t) (x = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)f,(&t),0,NULL), x != NULL)
#define thread_join(x) { WaitForSingleObject(x, INFINITE); CloseHandle(x); }

#endif


typedef struct _swrlock_type
{
	// 互斥锁
	Lock_type lock;

	// 共享等待信号量
	WaitCondition shared_cond;

	// 独占等待信号量
	WaitCondition exclusive_cond;

	// 共享锁数目
	int shared_count;

	// 独占锁等待数目
	int exclusive_wait_count;

	// 是否独占状态
	bool exclusive;
}swrlock_type;

static void srwlock_init(swrlock_type* swrlock)
{
	lock_init(swrlock->lock);
	sem_init(swrlock->shared_cond);
	sem_init(swrlock->exclusive_cond);
	swrlock->shared_count = 0;
	swrlock->exclusive_wait_count = 0;
	swrlock->exclusive = false;
}
static void srwlock_destroy(swrlock_type* swrlock)
{
	sem_destroy(swrlock->exclusive_cond);
	sem_destroy(swrlock->shared_cond);
	lock_destroy(swrlock->lock);
}
static void srwlock_shared_grab(swrlock_type* swrlock)
{
	lock_grab(swrlock->lock);

	while(swrlock->exclusive || swrlock->exclusive_wait_count)
	{
		sem_wait(swrlock->shared_cond, swrlock->lock);
	}
	swrlock->shared_count ++;

	lock_release(swrlock->lock);
}
static void srwlock_shared_release(swrlock_type* swrlock)
{
	bool noshared;
	lock_grab(swrlock->lock);

	noshared = !(-- swrlock->shared_count);

	if(noshared)
	{
		sem_signal_one(swrlock->exclusive_cond);
		sem_signal_all(swrlock->shared_cond);
	}

	lock_release(swrlock->lock);
}
static void srwlock_exclusive_grab(swrlock_type* swrlock)
{
	lock_grab(swrlock->lock);

	swrlock->exclusive_wait_count ++;
	while(swrlock->exclusive || swrlock->shared_count)
	{
		sem_wait(swrlock->exclusive_cond, swrlock->lock);
	}
	swrlock->exclusive_wait_count --;
	swrlock->exclusive = true;

	lock_release(swrlock->lock);
}
static void srwlock_exclusive_release(swrlock_type* swrlock)
{
	lock_grab(swrlock->lock);

	swrlock->exclusive = false;
	sem_signal_one(swrlock->exclusive_cond);
	sem_signal_all(swrlock->shared_cond);

	lock_release(swrlock->lock);
}

PVOID __stdcall CreateRWLock()
{
	PRW_LOCK pLock=NULL;

	do 
	{
		pLock=(PRW_LOCK)malloc(sizeof(RW_LOCK));

		if (!pLock)
		{
			break;
		}

		RtlZeroMemory(pLock,sizeof(RW_LOCK));

		pLock->iNowReaderCount=0;

		pLock->hShareLock=CreateEvent(NULL,FALSE,TRUE,NULL);

		if (pLock->hShareLock)
		{
			InitializeCriticalSection(&pLock->ExclusiveLock);

			break;
		}

		free(pLock);

		pLock=NULL;

	} while (FALSE);

	return (PVOID)pLock;
}

VOID __stdcall DeleteRWLock(PVOID pLock)
{
	PRW_LOCK pRwLock=(PRW_LOCK)pLock;

	if (pRwLock->hShareLock)
	{
		DeleteCriticalSection(&pRwLock->ExclusiveLock);

		CloseHandle(pRwLock->hShareLock);
	}

	free(pLock);
}

VOID __stdcall AcquireShareLock(PVOID pLock)
{
	PRW_LOCK pRwLock=(PRW_LOCK)pLock;

	EnterCriticalSection(&pRwLock->ExclusiveLock);

	if(InterlockedIncrement(&pRwLock->iNowReaderCount)==1)
	{
		WaitForSingleObject(pRwLock->hShareLock,INFINITE);
	}

	LeaveCriticalSection(&pRwLock->ExclusiveLock);
}


VOID __stdcall ReleaseShareLock(PVOID pLock)
{
	PRW_LOCK pRwLock=(PRW_LOCK)pLock;

	if(InterlockedDecrement(&pRwLock->iNowReaderCount)==0)
	{
		SetEvent(pRwLock->hShareLock);
	}
}

VOID __stdcall AcquireExclusiveLock(PVOID pLock)
{
	PRW_LOCK pRwLock=(PRW_LOCK)pLock;

	EnterCriticalSection(&pRwLock->ExclusiveLock);//占用写锁，使得其它线程不可读(后续所有想获取读锁和写锁的操作，都会卡在这里)

	WaitForSingleObject(pRwLock->hShareLock,INFINITE);//等待所有已经获取读锁的线程完成操作(一定只有一个想获取写锁的线程在这里等待，因为其它想获取写锁的线程会卡在上面一行）

	SetEvent(pRwLock->hShareLock);
}



VOID __stdcall ReleaseExclusiveLock(PVOID pLock)
{
	PRW_LOCK pRwLock=(PRW_LOCK)pLock;

	LeaveCriticalSection(&pRwLock->ExclusiveLock);
}