//// Multiple readers/single writer synchronization counter//// This counter allows multiple threads to read from a shared resource,// and permits a maximum of one thread at a time to write to that same// resource.//class SyncCounter{// Construction and destructionpublic:	SyncCounter();	~SyncCounter();// Reading interfacepublic:	void IncrementReadCount();	void DecrementReadCount();// Writing interfacepublic:	void LockForWriting();	bool TryLockForWriting();	void UnlockFromWriting();// Internal stateprivate:	// Note that these two members will lie on the same cache line,	// which can lead to false sharing and over-locking on most CPU	// architectures. The only real solution would be to ensure the	// memory lies on separate cache lines which requires knowledge	// of each target platform's cache line size, as well as a huge	// amount of wasted memory. All things considered, a little bit	// of false sharing is a fair price to pay for most purposes.	volatile LONG ReadCounter;	volatile LONG WriteCounter;	// We use two Windows events as controls for locking and unlocking	// the resource. The first event is signaled whenever there is not	// an active write lock, allowing us to block reader threads until	// writing is completed. When a read lock is in place, we unsignal	// the second event, which prevents any writer threads from taking	// out a write lock. The combination ensures that multiple threads	// can read while only one can write, and that readers and writers	// cannot operate simultaneously.	HANDLE NotBusyFlagEvent;	HANDLE WriteMutexEvent;	// We use some thread-local storage to ensure that individual	// threads can recursively take out locks without deadlocking	// themselves or losing track of the total read/write counts.	// These members hold the Windows TLS table indices.	DWORD TLSReadLockCount;	DWORD TLSWriteLockCount;};//// RAII wrapper class for automatically holding a read lock on a SyncCounter//class AutoReadLock{// Construction/destructionpublic:	AutoReadLock(SyncCounter& syncobject)	 : SyncObject(syncobject)	{		SyncObject.IncrementReadCount();	}	~AutoReadLock()	{		SyncObject.DecrementReadCount();	}// Internal trackingprivate:	SyncCounter& SyncObject;};//// RAII wrapper class for automatically holding a write lock on a SyncCounter//class AutoWriteLock{// Construction/destructionpublic:	AutoWriteLock(SyncCounter& syncobject)	 : SyncObject(syncobject)	{		SyncObject.LockForWriting();	}	~AutoWriteLock()	{		SyncObject.UnlockFromWriting();	}// Internal trackingprivate:	SyncCounter& SyncObject;};

SyncCounter::SyncCounter() :	ReadCounter(-1),	WriteCounter(-1){	NotBusyFlagEvent = ::CreateEvent(NULL, TRUE, TRUE, NULL);	WriteMutexEvent = ::CreateEvent(NULL, FALSE, TRUE, NULL);	TLSReadLockCount = ::TlsAlloc();	TLSWriteLockCount = ::TlsAlloc();	::TlsSetValue(TLSReadLockCount, 0);	::TlsSetValue(TLSWriteLockCount, 0);}SyncCounter::~SyncCounter(){	::CloseHandle(NotBusyFlagEvent);	::CloseHandle(WriteMutexEvent);	::TlsFree(TLSReadLockCount);	::TlsFree(TLSWriteLockCount);}void SyncCounter::IncrementReadCount(){	// We don't need a read-lock if we already have write control	DWORD writelockcount = reinterpret_cast<DWORD>(::TlsGetValue(TLSWriteLockCount));	if (writelockcount > 0) {		return;	}	// Make sure we don't deadlock by recursively taking out locks	DWORD readlockcount = reinterpret_cast<DWORD>(::TlsGetValue(TLSReadLockCount));	::TlsSetValue(TLSReadLockCount, reinterpret_cast<LPVOID>(readlockcount + 1));	if (readlockcount > 0) {		return;	}	::WaitForSingleObject(NotBusyFlagEvent, INFINITE);	if (::InterlockedIncrement(&ReadCounter) == 0) {		::WaitForSingleObject(WriteMutexEvent, INFINITE);	}}void SyncCounter::DecrementReadCount(){	// We don't need a read-lock if we already have write control	DWORD writelockcount = reinterpret_cast<DWORD>(::TlsGetValue(TLSWriteLockCount));	if (writelockcount > 0) {		return;	}	// Make sure we don't deadlock by recursively taking out locks	DWORD readlockcount = reinterpret_cast<DWORD>(::TlsGetValue(TLSReadLockCount));	::TlsSetValue(TLSReadLockCount, reinterpret_cast<LPVOID>(--readlockcount));	if (readlockcount > 0) {		return;	}	if (::InterlockedDecrement(&ReadCounter) < 0) {		::SetEvent(WriteMutexEvent);	}}void SyncCounter::LockForWriting(){	// Make sure we don't deadlock by recursively taking out locks	DWORD writelockcount = reinterpret_cast<DWORD>(::TlsGetValue(TLSWriteLockCount));	::TlsSetValue(TLSWriteLockCount, reinterpret_cast<LPVOID>(writelockcount + 1));	if (writelockcount > 0) {		return;	}	::WaitForSingleObject(WriteMutexEvent, INFINITE);	if (::InterlockedIncrement(&WriteCounter) == 0) {		::ResetEvent(NotBusyFlagEvent);	}}bool SyncCounter::TryLockForWriting(){	// Make sure we don't deadlock by recursively taking out locks	DWORD writelockcount = reinterpret_cast<DWORD>(::TlsGetValue(TLSWriteLockCount));	::TlsSetValue(TLSWriteLockCount, reinterpret_cast<LPVOID>(writelockcount + 1));	if (writelockcount > 0) {		return true;	}	if(::WaitForSingleObject(WriteMutexEvent, 0) == WAIT_OBJECT_0) {		if (::InterlockedIncrement(&WriteCounter) == 0) {			::ResetEvent(NotBusyFlagEvent);		}		return true;	}	::TlsSetValue(TLSWriteLockCount, reinterpret_cast<LPVOID>(writelockcount));	return false;}void SyncCounter::UnlockFromWriting(){	// Make sure we don't deadlock by recursively taking out locks	DWORD writelockcount = reinterpret_cast<DWORD>(::TlsGetValue(TLSWriteLockCount));	::TlsSetValue(TLSWriteLockCount, reinterpret_cast<LPVOID>(--writelockcount));	if (writelockcount > 0) {		return;	}	if (::InterlockedDecrement(&WriteCounter) < 0) {		::SetEvent(NotBusyFlagEvent);	}	::SetEvent(WriteMutexEvent);}