求一个互斥变量的思路

[飞翔的薄荷]

互斥变量主要保护一个链表，（1）添加和删除时禁止其它任何操作，（2）读取链表时其它线程也可以读取链表，禁止删除和添加。

自己写了一个，但是添加和删除操作渴求而死。求一个更好的思路，能附上代码就更好了。


//MyLock.h

#pragma once

#include <list>

class CMyLock  
{
public:
	CMyLock();
	virtual ~CMyLock();
	enum LOCK_MODE
	{
		LOCK_MODE_NONE,
		LOCK_MODE_ONLY_ONE,   //独占模式
		LOCK_MODE_MORE_USER,  //分享模式
	};
private:
	struct  LOCK_ITME
	{
		DWORD nThreadID;
		LOCK_MODE nLockMode;
	} ;
	typedef std::list<LOCK_ITME> CListItem;
	typedef std::list<LOCK_ITME>::iterator CPListItem;

private:
	LOCK_MODE         m_curMode;
	CCriticalSection  m_cs;
	CListItem         m_listItem;
	CCriticalSection  m_csList;
public:
	BOOL Lock(LOCK_MODE const &nMode = LOCK_MODE_MORE_USER);
	BOOL Unlock();
};

//MyLock.cpp

#include "MyLock.h"


CMyLock::CMyLock()
	:m_curMode(LOCK_MODE_NONE)
{
	
}

CMyLock::~CMyLock()
{

}

BOOL CMyLock::Lock(LOCK_MODE const &lockMode)
{
	//注意 锁和当前线程关联，解锁时只能是当前线程。
	LOCK_ITME item = {0};
	item.nThreadID = GetCurrentThreadId();
	item.nLockMode = lockMode;
	
	BOOL bWait = TRUE;

	switch (lockMode)
	{
	case LOCK_MODE_ONLY_ONE:
		bWait = TRUE;
		break;
	case LOCK_MODE_MORE_USER:
		if (LOCK_MODE_MORE_USER == m_curMode)
		{
			bWait = FALSE;
		}
		else
		{
			bWait = TRUE;
		}
		break;
	default:
		ASSERT(0);
		return FALSE;
		break;
	}

	if (bWait)
	{
		m_cs.Lock();
	}

	m_csList.Lock();
	m_curMode = lockMode;
	m_listItem.push_back(item);
	m_csList.Unlock();

	return TRUE;
}

BOOL CMyLock::Unlock()
{
	//只能释放当前线程的锁
	DWORD const	nThreadID = GetCurrentThreadId();
	BOOL bFind = FALSE;
	m_csList.Lock();
	CPListItem it = m_listItem.begin();
	for (;it != m_listItem.end(); ++it)
	{
		if (nThreadID == it->nThreadID)
		{
			m_listItem.erase(it);
			bFind = TRUE;
			break;
		}
	}
	if (m_listItem.empty())
	{
		m_curMode = LOCK_MODE_NONE;
		m_cs.Unlock();
	}
	m_csList.Unlock();
	ASSERT(bFind);
	return bFind;
}

[hdg3707]

我告诉我用环形队列的大概思路:
一个线程增加数据,其它线程读取数据.
增加数据时进行部分锁定,也就是当环形队列满时(数据溢出)时,头指针就往前移动溢出数据量的位置,这时先锁定,头指针移动完成后解锁.如果在增加数据时不涉及到移动头指针就不锁定,这时其它线程可以读取数据.
读数据时先锁定头指针,读完后再解锁,然后再处理数据,这样锁定时间短,不至于丢失数据太多(数据溢出太多)
假设你是用单向链表做,也可以按这个思路锁定和解锁.添加时不用锁定(不影响读数据),删除时一定要锁定.如果是多个线程读时要锁定(多个读线程共享一个头指针,如果多个读线程是独立读数据不用锁定)

[Eleven]

临界区啊

 // Request ownership of the critical section.
    EnterCriticalSection(&CriticalSection); 

    // Access the shared resource.

    // Release ownership of the critical section.
    LeaveCriticalSection(&CriticalSection);