C++ CriticalSection::Unlock方法代码示例

//------------------------------------------------------------------------------------------------------------------------------------
// Helper for ErrorMessenger.
//------------------------------------------------------------------------------------------------------------------------------------
LogMgr::ErrorDialogResult LogMgr::Error(const std::string& errorMessage, bool isFatal, const char* funcName, const char* sourceFile, unsigned int lineNum)
{
	string tag = ((isFatal) ? ("FATAL") : ("ERROR"));

	// buffer for our final output string
	string buffer;
	GetOutputBuffer(buffer, tag, errorMessage, funcName, sourceFile, lineNum);

	// write the final buffer to all the various logs
	m_tagCriticalSection.Lock();
	Tags::iterator findIt = m_tags.find(tag);
	if (findIt != m_tags.end())
		OutputFinalBufferToLogs(buffer, findIt->second);
	m_tagCriticalSection.Unlock();

    // show the dialog box
    int result = ::MessageBoxA(NULL, buffer.c_str(), tag.c_str(), MB_ABORTRETRYIGNORE|MB_ICONERROR|MB_DEFBUTTON3);

	// act upon the choice
	switch (result)
	{
		case IDIGNORE : return LogMgr::LOGMGR_ERROR_IGNORE;
		case IDABORT  : __debugbreak(); return LogMgr::LOGMGR_ERROR_RETRY;  // assembly language instruction to break into the debugger
		case IDRETRY :	return LogMgr::LOGMGR_ERROR_RETRY;
		default :       return LogMgr::LOGMGR_ERROR_RETRY;
	}
}

    AsyncStream::~AsyncStream(void)
    {
        // Before we destroy ourselves... must remove ourselves from the linked list...
        // TODO: currently we don't wait for the server thread to flush any remaining data,
        //       so in theory when a thread is destoryed it is possible to lose some data in
        //       the outbound stream!!!!!
        g_listlock.Lock();
        if(s_head == this)
        {
            // We our the head element... simply replace the head with the next one...
            s_head = m_next;
        }
        else
        {
            // Search for the element before us and set its next to our next...
            for(AsyncStream *curr=s_head; curr; curr=curr->m_next)
            {
                if(curr->m_next == this)
                {
                    curr->m_next = m_next;
                    break;
                }
            }
        }
        g_listlock.Unlock();

        if(m_cacheBegin) free(m_cacheBegin);
        if(m_flushBegin) free(m_flushBegin);
    }

///////////////////////////////////////////////////////////////////////////////////////////////////////
// this function builds up the log string and outputs it to various places based on display flags
///////////////////////////////////////////////////////////////////////////////////////////////////////
void LogMgr::Log(const string& tag, const string& message, const char* func, const char* source, unsigned int line)
{
  _tag_critical_section.Lock();
  Tags::iterator it = _tags.find(tag);
  if(it != _tags.end())
  {
    _tag_critical_section.Unlock();
    string buffer;
    GetOutputBuffer(buffer, tag, message, func, source, line);
    OutputFinalBufferToLogs(buffer, it->second);
  }
  else
  {
    //critical section is exited in the if above, so need to do it here if above wasnt executed
    _tag_critical_section.Unlock();
  }
}

//------------------------------------------------------------------------------------------------------------------------------------
// This function builds up the log string and outputs it to various places based on the display flags (m_displayFlags).
//------------------------------------------------------------------------------------------------------------------------------------
void LogMgr::Log(const string& tag, const string& message, const char* funcName, const char* sourceFile, unsigned int lineNum)
{
	m_tagCriticalSection.Lock();
	Tags::iterator findIt = m_tags.find(tag);
	if (findIt != m_tags.end())
	{
		m_tagCriticalSection.Unlock();
		
		string buffer;
		GetOutputBuffer(buffer, tag, message, funcName, sourceFile, lineNum);
		OutputFinalBufferToLogs(buffer, findIt->second);
	}
	else
	{
		// Critical section is exited in the if statement above, so we need to exit it here if that didn't 
		// get executed.
        m_tagCriticalSection.Unlock();
	}
}  // end LogMgr::Log()

 // Flush all existing thread streams... returns false on socket error
 bool AsyncStream::FlushAll(Socket &s)
 {
     OVR_CAPTURE_CPU_ZONE(AsyncStream_FlushAll);
     bool okay = true;
     g_listlock.Lock();
     for(AsyncStream *curr=s_head; curr; curr=curr->m_next)
     {
         okay = curr->Flush(s);
         if(!okay) break;
     }
     g_listlock.Unlock();
     return okay;
 }

void FindContacts_Threaded(void *fc)
{
	static CriticalSection cs;

	ContactFinder *cf = (ContactFinder*)fc;

	map<ArbiterKey, Arbiter> &arbitersf = *cf->_arbiters;

	cf->last = min(cf->last, (i32)cf->potentials->size());

	for(int i=cf->first;i<cf->last;++i)
	{
		World::PotentiallyColliding pc = cf->potentials->at(i);

		Arbiter arb(pc.body1, pc.body2);
		ArbiterKey arbKey(pc.body1, pc.body2);

		if(arb.DoCollision())
		{
			ArbIter iter = arbitersf.find(arbKey);
			if(iter != arbitersf.end())
			{
				iter->second.Update(arb.contacts, arb.numContacts);
			}
			else
			{
				cs.Lock();
				cf->addList->push_back(Arbiter_ADD(arb, arbKey));
				cs.Unlock();
			}
		}
		else
		{
			cs.Lock();
			cf->eraseList->push_back(Arbiter_ERASE(arbKey));
			cs.Unlock();
		}
	}
};

//------------------------------------------------------------------------------------------------------------------------------------
// Sets one or more display flags
//------------------------------------------------------------------------------------------------------------------------------------
void LogMgr::SetDisplayFlags(const std::string& tag, unsigned char flags)
{
	m_tagCriticalSection.Lock();
	if (flags != 0)
	{
		Tags::iterator findIt = m_tags.find(tag);
		if (findIt == m_tags.end())
			m_tags.insert(std::make_pair(tag, flags));
		else
			findIt->second = flags;
	}
	else
	{
		m_tags.erase(tag);
	}
	m_tagCriticalSection.Unlock();
}

///////////////////////////////////////////////////////////////////////////////////////
// sets one or more display flags
///////////////////////////////////////////////////////////////////////////////////////
void LogMgr::SetDisplayFlags(const std::string& tag, unsigned char flags)
{
  _tag_critical_section.Lock();
  if(flags != 0)
  {
    Tags::iterator it = _tags.find(tag);
    if(it == _tags.end())
      _tags.insert(std::make_pair(tag, flags));
    else
      it->second = flags;
  }
  else
  {
    _tags.erase(tag);
  }
  _tag_critical_section.Unlock();
}

    AsyncStream::AsyncStream(void)
    {
        m_bufferLock  = 0;

    #if defined(OVR_CAPTURE_POSIX)
        OVR_CAPTURE_STATIC_ASSERT(sizeof(pid_t) <= sizeof(UInt32));
        union
        {
            UInt32 i;
            pid_t  t;
        };
        i = 0;
        t = gettid();
        m_threadID = i;
    #elif defined(OVR_CAPTURE_WINDOWS)
        m_threadID = static_cast<UInt32>(GetCurrentThreadId());
    #else
        #error UNKNOWN PLATFORM!
    #endif

        m_cacheBegin  = (UInt8*)malloc(s_bufferSize);
        m_cacheTail   = m_cacheBegin;
        m_cacheEnd    = m_cacheBegin + s_bufferSize;

        m_flushBegin  = (UInt8*)malloc(s_bufferSize);
        m_flushTail   = m_flushBegin;
        m_flushEnd    = m_flushBegin + s_bufferSize;

        // Make sure we are open by default... we don't close until we fill the buffer...
        m_gate.Open();

        // when we are finally initialized... add ourselves to the linked list...
        g_listlock.Lock();
        m_next = s_head;
        s_head = this;
        g_listlock.Unlock();

        // Try and acquire thread name...
        SendThreadName();
    }

//////////////////////////////////////////////////////////////////////////////////////////////
//helper for ErrorMessenger
/////////////////////////////////////////////////////////////////////////////////////////////
LogMgr::ErrorDialogResult LogMgr::Error(const std::string& error_message, bool is_fatal, const char* func, const char* source, unsigned int line)
{
  string tag = ((is_fatal) ? ("FATAL") : ("ERROR"));
  //buffer for final output string
  string buffer;
  GetOutputBuffer(buffer, tag, error_message, func, source, line);

  //write final buffer to various logs
  _tag_critical_section.Lock();
  Tags::iterator it = _tags.find(tag);
  if(it != _tags.end())
    OutputFinalBufferToLogs(buffer, it->second);
  _tag_critical_section.Unlock();

  //show the dialog box
  int result = ::MessageBoxA(NULL, buffer.c_str(), tag.c_str(),  MB_ABORTRETRYIGNORE|MB_ICONERROR|MB_DEFBUTTON3);
  switch(result)
  {
    case IDIGNORE:  return LogMgr::LOGMGR_ERROR_IGNORE;
    case IDABORT: __debugbreak(); return LogMgr::LOGMGR_ERROR_ABORT;
    case IDRETRY: return LogMgr::LOGMGR_ERROR_RETRY;
    default:  return LogMgr::LOGMGR_ERROR_RETRY;
  }
}

//------------------------------------------------------------------------------------------------------------------------------------
// Adds an error messenger to the list
//------------------------------------------------------------------------------------------------------------------------------------
void LogMgr::AddErrorMessenger(Logger::ErrorMessenger* pMessenger)
{
	m_messengerCriticalSection.Lock();
	m_errorMessengers.push_back(pMessenger);
	m_messengerCriticalSection.Unlock();
}

	~AutoCriticalSection() {
		m_pCS->Unlock();
	}

 void Unlock()
 {
     m_CriSection.Unlock();
 }

////////////////////////////////////////////////////////////////////////////////////////////////
// adds error message to list
////////////////////////////////////////////////////////////////////////////////////////////////
void LogMgr::AddErrorMessenger(Logger::ErrorMessenger* messenger)
{
  _messenger_critical_section.Lock();
  _error_messengers.push_back(messenger);
  _messenger_critical_section.Unlock();
}