几个用于线程同步的锁

It's well known that synchronous processing is necessary for multithreaded programming. The operating system provides some basic way, such as critical section, mutex. However, those methods are not enough for large systems. I present three locks that can provide higher performance.

 

Recursive lock

It can be acquired repeatedly by the thread holding the lock. And that will not result in deadlock. There must be a unlock operation corresponding to each lock operation in the thread holding the lock so that the other thread can acquire it. It's useful in the scenario that a thread may acquire a lock many times, especially in the recursive functions. However, it's slower than non-recursive lock.

 

Spin lock

The waiting thread doesn't block at the synchronizing point, but "spins" to try to acquire the lock. Spinlocks do have a advantage in that no context switch is required when a thread must wait on a lock, and a context switch may take considerable time. Thus, when locks are expected to be held for short times, spinlocks are useful. They are often employed on multiprocessor systems where one thread can "spin" on one processor while another thread run on another processor. Note that misuse of it may reulst in thread starvation. It can be solved by queuing the waiting threads.

 

Read and write lock

It is also called as multiple read/single-write lock. It permit multiple thread to read the shared resources concurrently, while only one thread can be authorised to perform write operation at most. It's a high performance mechanism for those applications which multiple threads may often read the shared resources at the same time and the write operation is performed less times. Well for long shared data, it's desirable to divide it into more segments to use read-write lock for synchronizing.

 

The code is shown as follow:

class RecLock { public: RecLock(); ~RecLock(); void lock(); bool tryLock(); void unlock(); bool willUnlock() const; private: // noncopyable RecLock(const RecLock&); void operator=(const RecLock&); CRITICAL_SECTION m_criticalSection; int m_count; //count the repeated lock times }; class SpinLock { public: SpinLock(); ~SpinLock(); void lock(); bool tryLock(); void unlock(); private: // noncopyable SpinLock(const SpinLock&); void operator=(const SpinLock&); volatile LONG m_spin; static LONG m_numberOfCPU; static LONG numberOfCPU(); }; class RWRecLock { public: RWRecLock(); ~RWRecLock(); void readLock(); bool tryReadLock(); void writeLock(); bool tryWriteLock(); void unlock(); private: CRITICAL_SECTION m_cs; // to protect the other member variables //Because the value of m_nActive is -1, the accesses are rejected when multiple threads call the readlock. All those threads will wait for this Semaphore. When the last thread waiting for writing has called unlock, the semaphore is released which amount is m_nWaitingReaders. As a result, it awake all the thread waiting for reading. HANDLE m_hsemReaders; //Because the value of m_nActive is bigger than 0, the accesses are rejected when multiple threads call the writelock. When the last thread waiting for reading has called unlock, the semaphore is released which amount is 1. As a result, it awake all the thread waiting for writing. HANDLE m_hsemWriters; //It represents the amount of the thread waiting to read. It is initialed to be 0. When the m_nActive is -1, it is added by one each time the thread call readlock. int m_nWaitingReaders; //It represents the amount of the thread waiting to write. It is initialed to be 0. When the m_nActive is bigger than 0, it is added by one each time the thread call writelock. int m_nWaitingWriters; //If it is 0, it means no thread is accessing the resource. If it is bigger than 0, it represents the amount of thread reading the resource. If it is negative, it means there is a thread writing the resource. The only valid value is -1. int m_nActive; };

 

#define DEFAULT_SPIN_COUNT 500 RecLock::RecLock(): m_count(0) { InitializeCriticalSection(&m_criticalSection); } RecLock::~RecLock() { _assert(m_count == 0); DeleteCriticalSection(&m_criticalSection); } void RecLock::lock() { EnterCriticalSection(&m_criticalSection); if(++m_count > 1) { LeaveCriticalSection(&m_criticalSection); } } bool RecLock::tryLock() { #if(_WIN32_WINNT >= 0x0400) if(!TryEnterCriticalSection(&m_criticalSection)) { return false; } if(++m_count > 1) { LeaveCriticalSection(&m_criticalSection); } return true; #else return false; #endif } void RecLock::unlock() { if(--m_count == 0) { LeaveCriticalSection(&m_criticalSection); } } bool RecLock::willUnlock() const { return m_count == 1; } LONG SpinLock::m_numberOfCPU = 0; SpinLock::SpinLock():m_spin(0) { if(m_numberOfCPU == 0) { numberOfCPU(); } } SpinLock::~SpinLock() { } void SpinLock::lock() { if(0 == InterlockedCompareExchange(&m_spin, 1, 0)) { return ; // acquire the lock } // single CPU if(m_numberOfCPU == 1) { while(0 != InterlockedCompareExchange( &m_spin, 1, 0)) { // use SwitchToThread instead of Sleep(0) so that the low priority thread can run #if(_WIN32_WINNT >= 0x0400) if(!SwitchToThread()) Sleep(0); #else Sleep(0); #endif // _WIN32_WINNT >= 0x0400 } return ; } else // multi-CPU, "spin" { LONG counter = 0; while(0 != InterlockedCompareExchange(&m_spin, 1, 0)) { for(counter = 0; counter < DEFAULT_SPIN_COUNT; counter++) { if(0 == InterlockedCompareExchange(&m_spin, 1, 0)) { return ; } } #if(_WIN32_WINNT >= 0x0400) if(!SwitchToThread()) Sleep(1); #else Sleep(0); #endif // _WIN32_WINNT >= 0x0400 } // while loop return ; } // multi-CPU } bool SpinLock::tryLock() { if(0 == InterlockedCompareExchange(&m_spin, 1, 0)) { return true; } else { return false; } } void SpinLock::unlock() { if(1 != InterlockedCompareExchange(&m_spin,0,1)) { _assert(false); } } LONG SpinLock::numberOfCPU() { if(m_numberOfCPU == 0) { SYSTEM_INFO info = {0}; GetSystemInfo(&info); m_numberOfCPU = (LONG) info.dwNumberOfProcessors; } return m_numberOfCPU; } RWRecLock::RWRecLock() { m_nWaitingReaders = 0; m_nWaitingWriters = 0; m_nActive = 0; m_hsemReaders = CreateSemaphore(NULL,0,MAXLONG,NULL); SORBA_ASSERT(m_hsemReaders); m_hsemWriters = CreateSemaphore(NULL,0,MAXLONG,NULL); SORBA_ASSERT(m_hsemWriters); InitializeCriticalSection(&m_cs); } RWRecLock::~RWRecLock() { #ifdef _DEBUG if(m_nActive != 0) { _assert(false); } #endif CloseHandle(m_hsemReaders); CloseHandle(m_hsemWriters); DeleteCriticalSection(&m_cs); } void RWRecLock::readLock() { EnterCriticalSection(&m_cs); bool bWritePending = (m_nWaitingWriters || (m_nActive<0)); if (bWritePending) { ++m_nWaitingReaders; } else { ++m_nActive; } if(bWritePending) { LeaveCriticalSection(&m_cs); WaitForSingleObject(m_hsemReaders,INFINITE); return; } LeaveCriticalSection(&m_cs); } bool RWRecLock::tryReadLock() { return false; } void RWRecLock::writeLock() { EnterCriticalSection(&m_cs); bool bResourceOwned = (m_nActive != 0); if(bResourceOwned) { ++m_nWaitingWriters; } else { m_nActive = -1; } if(bResourceOwned) { LeaveCriticalSection(&m_cs); WaitForSingleObject(m_hsemWriters,INFINITE); return; } LeaveCriticalSection(&m_cs); } bool RWRecLock::tryWriteLock() { return false; } void RWRecLock::unlock() { EnterCriticalSection(&m_cs); if(m_nActive > 0) { --m_nActive; } else { ++m_nActive; } HANDLE hsem = NULL; LONG lCount = 1; if(m_nActive == 0) { //the write thread first if(m_nWaitingWriters > 0) { m_nActive = -1; --m_nWaitingWriters; hsem = m_hsemWriters; lCount = 1; } else if(m_nWaitingReaders >0) { m_nActive = m_nWaitingReaders; m_nWaitingReaders = 0; hsem = m_hsemReaders; lCount = m_nActive; } else { //do nothing } } if(hsem != NULL) { LeaveCriticalSection(&m_cs); if(!ReleaseSemaphore(hsem,lCount,NULL)) { _assert(false); } return; } LeaveCriticalSection(&m_cs); }