285 lines
5.7 KiB
C++
285 lines
5.7 KiB
C++
#include "Lock.h"
|
||
using namespace CleverLock;
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// CWithLock
|
||
/////////////////////////////////////////////////////////////////////////
|
||
CWithLock::CWithLock()
|
||
{
|
||
InitializeCriticalSection( &m_csAccess );
|
||
}
|
||
|
||
CWithLock::~CWithLock()
|
||
{
|
||
DeleteCriticalSection( &m_csAccess );
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
void CWithLock::Lock()
|
||
{
|
||
EnterCriticalSection(&m_csAccess);
|
||
}
|
||
|
||
void CWithLock::UnLock()
|
||
{
|
||
LeaveCriticalSection(&m_csAccess);
|
||
}
|
||
|
||
BOOL CWithLock::TryLock()
|
||
{
|
||
return TryEnterCriticalSection(&m_csAccess);
|
||
}
|
||
|
||
HANDLE CWithLock::GetOwnerThread()
|
||
{
|
||
return m_csAccess.OwningThread;
|
||
}
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// CLock
|
||
/////////////////////////////////////////////////////////////////////////
|
||
CLock::CLock( CWithLock &door, bool b_lock)
|
||
{
|
||
m_pDoor = &door;
|
||
m_bLocked = b_lock;
|
||
if (m_bLocked)
|
||
Lock(*m_pDoor);
|
||
}
|
||
|
||
CLock::~CLock()
|
||
{
|
||
if (m_bLocked)
|
||
UnLock(*m_pDoor);
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
void CLock::Lock()
|
||
{
|
||
if(!m_bLocked)
|
||
{
|
||
m_bLocked = true;
|
||
Lock(*m_pDoor);
|
||
}
|
||
}
|
||
|
||
void CLock::UnLock()
|
||
{
|
||
if (m_bLocked)
|
||
{
|
||
m_bLocked = false;
|
||
UnLock(*m_pDoor);
|
||
}
|
||
}
|
||
|
||
BOOL CLock::TryLock()
|
||
{
|
||
if(!m_bLocked)
|
||
{
|
||
if ( m_pDoor->TryLock() )
|
||
{
|
||
m_bLocked = true;
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
void CLock::Lock(CWithLock &door)
|
||
{
|
||
door.Lock();
|
||
}
|
||
|
||
void CLock::UnLock(CWithLock &door)
|
||
{
|
||
door.UnLock();
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// CResourceMgr
|
||
/////////////////////////////////////////////////////////////////////////
|
||
//CResourceMgr::CResourceMgr()
|
||
//{
|
||
//}
|
||
//
|
||
//CResourceMgr::~CResourceMgr()
|
||
//{
|
||
// LOCK(*this);
|
||
// if (m_pInstance)
|
||
// m_pInstance = NULL;
|
||
//}
|
||
//
|
||
///////////////////////////////////////////////////////////////////////////
|
||
//CResourceMgr * CResourceMgr::m_pInstance = NULL;
|
||
//
|
||
//CResourceMgr * CResourceMgr::GetInstance()
|
||
//{
|
||
// LOCK_CODE();
|
||
// if (m_pInstance == NULL)
|
||
// m_pInstance = new CResourceMgr;
|
||
//
|
||
// return m_pInstance;
|
||
//
|
||
//}
|
||
//
|
||
//void CResourceMgr::AddResource(CWithManagedLock * p_resource)
|
||
//{
|
||
// LOCK(*this);
|
||
// m_aResourceArray.Add(p_resource);
|
||
//}
|
||
//
|
||
//void CResourceMgr::RemoveResource(CWithManagedLock * p_resource)
|
||
//{
|
||
// LOCK(*this);
|
||
// int i,n;
|
||
// for (i = 0, n = m_aResourceArray.GetSize(); i<n; ++i)
|
||
// {
|
||
// if (p_resource == m_aResourceArray[i])
|
||
// {
|
||
// m_aResourceArray.RemoveAt(i);
|
||
// return;
|
||
// }
|
||
// }
|
||
//}
|
||
//
|
||
//CWithManagedLock * CResourceMgr::CheckDeadLock()
|
||
//{
|
||
// LOCK(*this);
|
||
// CWithManagedLock * Ret = NULL;
|
||
// HANDLE hThread;
|
||
//
|
||
// int WholeSize = m_aResourceArray.GetSize();
|
||
//
|
||
// if (WholeSize<=0)
|
||
// return NULL;
|
||
//
|
||
// int ri,rn,si, CurIndex,Thread_i,Thread_n;
|
||
// CArray<int, int> Queue;
|
||
//
|
||
// for (ri = 0, rn = m_aResourceArray.GetSize(); ri<rn; ++ri)
|
||
// CLock::Lock(m_aResourceArray[ri]->m_WaitQueueLock);
|
||
//
|
||
// char *State = new char[WholeSize];
|
||
// memset(State, 0, WholeSize);
|
||
//
|
||
// for (ri = 0; ri<WholeSize && Ret == NULL; ++ri)
|
||
// {
|
||
// if (State[ri]!=0)
|
||
// continue;
|
||
//
|
||
// Queue.RemoveAll();
|
||
// Queue.Add(ri);
|
||
// State[ri] = 1;
|
||
//
|
||
// for (;Queue.GetSize()>0 && Ret == NULL; )
|
||
// {
|
||
// CurIndex = Queue[0];
|
||
// Queue.RemoveAt(0);
|
||
//
|
||
// for (Thread_i = 0, Thread_n = m_aResourceArray[CurIndex]->m_aWaitingThread.GetSize();
|
||
// Thread_i<Thread_n && Ret == NULL;
|
||
// ++ Thread_i)
|
||
// {
|
||
// hThread = m_aResourceArray[CurIndex]->m_aWaitingThread[Thread_i];
|
||
//
|
||
// for (si = ri; si<WholeSize && Ret == NULL; ++si)
|
||
// {
|
||
// if (hThread == m_aResourceArray[si]->GetOwnerThread() )
|
||
// {
|
||
// switch (State[si])
|
||
// {
|
||
// case 0: // δ<><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
// Queue.Add( si);
|
||
// State[si] = 1;
|
||
// break;
|
||
// case 1: //<2F><><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD>,<2C><><EFBFBD><EFBFBD>ѭ<EFBFBD><D1AD>
|
||
// if ( CurIndex != si)
|
||
// {
|
||
// Ret = m_aResourceArray[si];
|
||
// State[si] = 3;
|
||
// }
|
||
// break;
|
||
// case 2: //<2F>ѱ<EFBFBD>֤ʵ<D6A4><CAB5>ѭ<EFBFBD><D1AD>
|
||
// break;
|
||
// case 3: //<2F>ѱ<EFBFBD>֤ʵѭ<CAB5><D1AD><EFBFBD><EFBFBD>
|
||
// break;
|
||
// }
|
||
//
|
||
// break;
|
||
// } // m_aWaitingThread == m_aResourceArray[si]->GetOwnerThread()
|
||
// }//si<WholeSize
|
||
// }//Thread_i<Thread_n
|
||
// }//Queue.GetSize()>0
|
||
//
|
||
// for (si = ri; si< WholeSize; ++si)
|
||
// {
|
||
// if (State[si] == 1)
|
||
// State[si] = 2;
|
||
// }
|
||
// }
|
||
//
|
||
// delete[] State;
|
||
// for (ri = 0, rn = m_aResourceArray.GetSize(); ri<rn; ++ri)
|
||
// CLock::UnLock(m_aResourceArray[ri]->m_WaitQueueLock);
|
||
//
|
||
// return Ret;
|
||
//}
|
||
//
|
||
//
|
||
///////////////////////////////////////////////////////////////////////////
|
||
//// CWithManagedLock
|
||
///////////////////////////////////////////////////////////////////////////
|
||
//CWithManagedLock::CWithManagedLock()
|
||
//{
|
||
// CResourceMgr::GetInstance()->AddResource(this);
|
||
//}
|
||
//
|
||
//CWithManagedLock::~CWithManagedLock()
|
||
//{
|
||
// CResourceMgr::GetInstance()->RemoveResource(this);
|
||
//}
|
||
//
|
||
///////////////////////////////////////////////////////////////////////////
|
||
//void CWithManagedLock::ForceFree()
|
||
//{
|
||
// for (;m_csAccess.LockCount>0;)
|
||
// LeaveCriticalSection(&m_csAccess);
|
||
//}
|
||
//
|
||
//HANDLE CWithManagedLock::GetWaitingThread(int index)
|
||
//{
|
||
// LOCK(m_WaitQueueLock);
|
||
// if (index>=0 && index < m_aWaitingThread.GetSize())
|
||
// return m_aWaitingThread[index];
|
||
//
|
||
// return (HANDLE)0;
|
||
//}
|
||
//
|
||
//void CWithManagedLock::Lock()
|
||
//{
|
||
// HANDLE hThread = GetCurrentThread();
|
||
// if (hThread == GetOwnerThread())
|
||
// {
|
||
// CWithLock::Lock();
|
||
// return;
|
||
// }
|
||
//
|
||
// LOCK2(m_WaitQueueLock,a);
|
||
// m_aWaitingThread.Add( hThread );
|
||
// UNLOCK2(a);
|
||
//
|
||
// CWithLock::Lock();
|
||
//
|
||
// int i,n;
|
||
// LOCK2(m_WaitQueueLock,b);
|
||
// for (i = 0, n = m_aWaitingThread.GetSize(); i<n; ++i)
|
||
// {
|
||
// if (hThread == m_aWaitingThread[i])
|
||
// {
|
||
// m_aWaitingThread.RemoveAt(i);
|
||
// break;
|
||
// }
|
||
// }
|
||
//
|
||
// UNLOCK2(b);
|
||
//}
|