顺序锁机制

[jianmuyan]

windows下有类似linux下顺序锁的机制吗？怎么实现呢？

读线程不受阻塞。可以随时读。如果有两个写线程。那它们之间是互斥。

[cnzdgs]

不了解这种锁，不过按照你的描述，只要在写线程中使用互斥对象，读线程中不采取任何同步机制就可以了。

[flm007]

windows下没听说过顺序锁这个概念，只知道互锁！

[jianmuyan]

读线程如果不采取任何同步机制的话。会不会受到影响。你的意思是给数据里加个标志位吗？

[cnzdgs]

不采取任何同步机制，也不加标志位，这样才能实现“随时读”，但数据的完整性是没有保障的。

[jianmuyan]

就是想保证数据完整性。。ls的兄弟有什么好办法吗

[solomonlxd]

互斥体就ok啦，CreateEvent，SetEvent，ResetEvent
如果用Dx的话用CCritSec和CAutoLock也可以

[cnzdgs]

单个储存单元可以用InterlockedXxx来处理，数据较多就只能所有线程都互斥了。

[gaoteng1984]

[Quote=引用 4 楼 cnzdgs 的回复:]
不采取任何同步机制，也不加标志位，这样才能实现“随时读”，但数据的完整性是没有保障的。
[/Quote]
这里的术语应该是“一致性”，不是“完整性”。
可以自己实现个读写锁，例如：

class ReadWriteLock
{
public:
    int    m_currentLevel;
    int    m_readCount;  
    HANDLE m_unlockEvent;
    HANDLE m_accessMutex;
    CRITICAL_SECTION m_csStateChange;
public:
    ReadWriteLock()
    {
        m_currentLevel = LOCK_LEVEL_NONE;
        m_readCount    = 0;
        m_unlockEvent  = ::CreateEvent( NULL, TRUE, FALSE, NULL );
        m_accessMutex  = ::CreateMutex( NULL, FALSE, NULL );
        ::InitializeCriticalSection( &m_csStateChange );
    }
    ~ReadWriteLock()
    {
        ::DeleteCriticalSection( &m_csStateChange );
        if ( m_accessMutex ) ::CloseHandle( m_accessMutex );
        if ( m_unlockEvent ) ::CloseHandle( m_unlockEvent );
    }

 bool lock( int level, int timeout = INFINITE)
    {
        bool  bresult    = true;
        DWORD waitResult = 0;
       
        waitResult = ::WaitForSingleObject( m_accessMutex, timeout );
        if ( waitResult != WAIT_OBJECT_0 )  return false;

        if ( level == LOCK_LEVEL_READ && m_currentLevel != LOCK_LEVEL_WRITE )
        {
            ::EnterCriticalSection( &m_csStateChange );
            m_currentLevel = level;
            m_readCount += 1;
            ::ResetEvent( m_unlockEvent );
            ::LeaveCriticalSection( &m_csStateChange );
        }
        else if ( level == LOCK_LEVEL_READ &&
                  m_currentLevel == LOCK_LEVEL_WRITE )
        {
            waitResult = ::WaitForSingleObject( m_unlockEvent, timeout );
            if ( waitResult == WAIT_OBJECT_0 )
            {
                ::EnterCriticalSection( &m_csStateChange );
                m_currentLevel = level;
                m_readCount += 1;
                ::ResetEvent( m_unlockEvent );
                ::LeaveCriticalSection( &m_csStateChange );
            }
            else bresult = false;
        }
        else if ( level == LOCK_LEVEL_WRITE &&
                  m_currentLevel == LOCK_LEVEL_NONE )
        {
            ::EnterCriticalSection( &m_csStateChange );
            m_currentLevel = level;
            ::ResetEvent( m_unlockEvent );
            ::LeaveCriticalSection( &m_csStateChange );
        }
        else if ( level == LOCK_LEVEL_WRITE &&
                  m_currentLevel != LOCK_LEVEL_NONE )
        {
            waitResult = ::WaitForSingleObject( m_unlockEvent, timeout );
            if ( waitResult == WAIT_OBJECT_0 )
            {
                ::EnterCriticalSection( &m_csStateChange );
                m_currentLevel = level;
                ::ResetEvent( m_unlockEvent );
                ::LeaveCriticalSection( &m_csStateChange );
            }
            else bresult = false;
        }

        ::ReleaseMutex( m_accessMutex );
        return bresult;

    } // lock()
   
 bool unlock()
    {
        ::EnterCriticalSection( &m_csStateChange );
        if ( m_currentLevel == LOCK_LEVEL_READ )
        {
            m_readCount --;
            if ( m_readCount == 0 )
            {
                m_currentLevel = LOCK_LEVEL_NONE;
                ::SetEvent (m_unlockEvent);
            }
        }
        else if ( m_currentLevel == LOCK_LEVEL_WRITE )
        {
            m_currentLevel = LOCK_LEVEL_NONE;
            ::SetEvent ( m_unlockEvent );
        }
        ::LeaveCriticalSection( &m_csStateChange );

        return true;
    }
};  

[jianmuyan]

[Quote=引用 7 楼 cnzdgs 的回复:]
单个储存单元可以用InterlockedXxx来处理，数据较多就只能所有线程都互斥了。
[/Quote]

想请问下。。你这个读写锁实现的是什么功能。。实现写线程互斥，读线程随时读吗