自旋锁 SpinLock

工作中某些需要，正好在codeproject找到了，有兴趣看看~~

 

SpinLock.h

 

// (C) Copyright 2001// Craig Henderson//// [e-mail]// http://homepage.virgin.net/cdm.henderson//// SpinLock.h#ifndef __SPINLOCK_H_#define __SPINLOCK_H_// if we haven't got a DBG_FN macro defined for debug output, then// define it to be a simple TRACE#ifndef DBG_FN# define DBG_FN TRACE#endif// if we haven't got a TRACE macro defined for debug output, then// define a dummy to compile to a null statement#ifndef TRACE# define TRACE 1? (void)0 : (void)0#endif // TRACE// if we haven't got an ASSERT macro defined for debugging, then// define a dummy to compile to a null statement#ifndef ASSERT# define ASSERT 1? (void)0 : (void)0#endif // ASSERT// scope the class inside a namespace// this is always good practice to avoid clashes// with classes from external sourcesnamespace cdmh {// helper function to determine if the runtime operating system is a// member of the WindowNT family// Returns:// true for WinNT 4, Window 2000 and WinXP// false for Windows 95, 98, 98SE and Meinline bool IsWindowsNT(void){ static OSVERSIONINFO osvi = { sizeof(OSVERSIONINFO) }; static bool got_version = false; if (!got_version) got_version = (::GetVersionEx(&osvi) == TRUE); return (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT);}// we use a trick with a numeric template parameter to enable multiple locks// and to avoid the need for a .cpp implementation file just to instantiate// the static m_lock member// each object that is instantiated with the same template parameter value// will share the lock, and different values of the template parameter will// identify independent locks// For example, an if an application has two classes of worker threads, each// class of thread requires exclusive access to a shared resource, but these// resources are independent of each other, then one class of thread can use// CSpinLock<1> and the other can use CSpinLock<2>.template<size_t N=1>class CSpinLock{ private: // this is the value that will spin around the threads. the thread // with this value in it's m_plock member is the one that holds the // lock // this simplifies debugging as it is easy to see if a lock is held // by a lock object by casting the m_plock member to a char * in the // watch window enum { LockValue = 'kcol' }; // we declare a static member which will provide us with a cross-thread // value storing the actual value of the lock. each object that is // instantiated with the same template value will share the lock, and // different values of the template parameter will identify independent // locks static long m_lock; // this is the actual lock pointer that is used in the class. // it can be set through a parameter to the ctor, or by default, // uses the above member mutable long *m_plock; // SwitchToThread() is only available on the WindowsNT family, so we bind // dynamically at run-time so that we can still support Win9x family typedef BOOL (* PFNSwitchToThread)(void); PFNSwitchToThread m_pfnSwitchToThread; protected: // if these methods are not defined, then the compiler // will generate them if we try to use them. // we declare them but do not implement them as they are unused, // but if they are called in error, then we will get a linker // error. if we did not do this, the compiler will generate a basic // memcpy version, but that will be incorrect as the m_data vector // will not get copied correctly CSpinLock(const CSpinLock &); CSpinLock &operator=(const CSpinLock &); public: // this is the only public ctor // the parameter is optional, and can be omitted in most circumstances // to provide the default functionality. if the outer algorithm wants to // control the lock object more closely, then this parameter can be used explicit CSpinLock(long *plock = 0) { // if we haven't been supplied a lock variable, then use our own if (plock == NULL) m_plock = &m_lock; else m_plock = plock; // SwitchToThread() is only available on the WindowsNT family, so // we bind dynamically at run-time so that we can still support // Win9x family m_pfnSwitchToThread = NULL; if (cdmh::IsWindowsNT()) { HINSTANCE hInst = ::LoadLibrary("Kernel32.dll"); if (hInst != NULL) m_pfnSwitchToThread = (PFNSwitchToThread)::GetProcAddress(hInst, "SwitchToThread"); } } // class dtor ~CSpinLock() { // if this assert fails, then the object still holds the lock // when in is going out of scope ASSERT(!this->has_lock()); } void lock(void) const { // output to the debugger DBG_FN("0x%08x waiting for lock/n", this); // this is why it is called a spin lock; we simply sit in a loop // until the lock is released by the holding object. to make the // algorithm more efficient, we reliquish the processor to another // thread if we fail to get the lock // note that this is inefficient for anything more than the smallest // interval, as the execution thread does not block while the lock // is held while (::InterlockedExchange(m_plock, LockValue) != 0) { TRACE("0x%08x can't get lock/n", this); if (m_pfnSwitchToThread) m_pfnSwitchToThread(); } } // release the lock void unlock(void) const { // if this assert fails, then the object does not have the lock // while this is not an error in itself, and will not have any // adverse side effects, it generally signifies an error in the // outer algorithm ASSERT(this->has_lock()); // reset the lock value ::InterlockedExchange(m_plock, 0); // output to the debugger TRACE("0x%08x released lock/n", this); } // returns true/false to signify if the object currently holds the lock bool has_lock(void) const { return (*m_plock == LockValue); }};// instantiate the static memory and initialise it// to zero - the unlocked statetemplate<int N> long CSpinLock<N>::m_lock = 0;} // namespace cdmh#endif __SPINLOCK_H_