自学教程：C++ ACE_GUARD函数代码示例

        void AddNewSockets()        {            ACE_GUARD(ACE_Thread_Mutex, Guard, m_NewSockets_Lock);            if (m_NewSockets.empty())                return;            for (SocketSet::const_iterator i = m_NewSockets.begin(); i != m_NewSockets.end(); ++i)            {                WorldSocket* sock = (*i);                if (sock->IsClosed())                {                    sock->RemoveReference();                    --m_Connections;                }                else                    m_Sockets.insert(sock);            }            m_NewSockets.clear();        }

voidClient_Service_Handler::handle_write_stream (  const ACE_Asynch_Write_Stream::Result &result){  ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, guard, this->mtx_);  this->pending_writes_--;  if (!result.success () || 0 == result.bytes_transferred ())  {    // Error    result.message_block ().release ();    ACE_DEBUG ((LM_DEBUG, ACE_TEXT (      "Client_Service_Handler::handle_write_stream: error: %d/n"),      result.error ()));    this->cancel_and_close ();  }  else if (result.bytes_transferred () < result.bytes_to_write ())  {    // More to write...    if (this->write (result.message_block(),      result.bytes_to_write () - result.bytes_transferred ()) < 0)    {      result.message_block ().release ();      this->cancel_and_close ();    }  }  else  {    // Wrote it all    result.message_block ().release ();  }}

void ObjectAccessor::RemoveCorpse(Corpse* corpse){    ASSERT(corpse && corpse->GetType() != CORPSE_BONES);    //TODO: more works need to be done for corpse and other world object    if (Map* map = corpse->FindMap())    {        corpse->DestroyForNearbyPlayers();        if (corpse->IsInGrid())            map->Remove(corpse, false);        else        {            corpse->RemoveFromWorld();            corpse->ResetMap();        }    }    else        corpse->RemoveFromWorld();    // Critical section    {        //TRINITY_WRITE_GUARD(ACE_RW_Thread_Mutex, i_corpseLock);		ACE_GUARD(LockType, g, i_corpseGuard);        Player2CorpsesMapType::iterator iter = i_player2corpse.find(corpse->GetOwnerGUID());        if (iter == i_player2corpse.end()) // TODO: Fix this            return;		CellPair cell_pair = Trinity::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());		uint32 cell_id = (cell_pair.y_coord * TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;        // build mapid*cellid -> guid_set map        CellCoord cellCoord = Trinity::ComputeCellCoord(corpse->GetPositionX(), corpse->GetPositionY());        // sObjectMgr->DeleteCorpseCellData(corpse->GetMapId(), cellCoord.GetId(), GUID_LOPART(corpse->GetOwnerGUID()));		sObjectMgr->DeleteCorpseCellData(corpse->GetMapId(), cell_id, GUID_LOPART(corpse->GetOwnerGUID()));		        i_player2corpse.erase(iter);    }}

voidCC_LockSet::unlock (CosConcurrencyControl::lock_mode mode){  ORBSVCS_DEBUG ((LM_DEBUG,              "CC_LockSet::unlock/n"));  CC_LockModeEnum lm = lmconvert (mode);  ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mlock_);  if (lock_[lm] == 0) // This lock is not held.    throw CosConcurrencyControl::LockNotHeld();  else    lock_[lm]--;  // If we do not have a lock held in a weaker mode than the  // strongest held and we have requests on the semaphore signal  // the semaphore.  while (lock_queue_.size () > 0)    {      CC_LockModeEnum lock_on_queue = CC_EM;      lock_queue_.dequeue_head (lock_on_queue);      if (compatible (lock_on_queue) == 1)        {          if (semaphore_.release () == -1)            throw CORBA::INTERNAL ();          lock_[lock_on_queue]++;        }      else        {          lock_queue_.enqueue_head (lock_on_queue);          break;        }    }  this->dump ();}

void P3LeafMesh::createRemoteService(const SAPInfo* hint, const UUIDPtr& uuid, const UUIDPtr& sid, ServiceParamsPtr& params, UUIDPtr& iid) throw (ServiceException&) {    ACE_GUARD(ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, m_lock);    if (hint == 0) {        throw ServiceException(ServiceException::SERVICE_WITHOUT_IMPL);    }    Endpoint endpoint;    ACE_Connector<P3MeshClientHandler, ACE_SOCK_Connector> connector;    hint->getFirstEndpoint(endpoint);    QoSEndpoint qosE = *(endpoint.getQoS());    UUIDPtr runtimeUUID;    getUUID(runtimeUUID);    UUIDPtr fid;    getFID(fid);    P3MeshClientHandler* clientHandler = new P3MeshClientHandler(            runtimeUUID,            fid,            qosE,            false, false, 0, 0, 0, 0);    if (connector.connect(clientHandler, endpoint.getAddr()) == -1) {        ACE_ERROR((LM_ERROR, ACE_TEXT("(%T)%@/n"),                ACE_TEXT("(%T)ERROR: P3Mesh::createRemoteService - connect failed:")));        clientHandler->close();        clientHandler = 0;        delete clientHandler;    } else {        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3LeafMesh::createRemoteService - Connect OK!/n")));    }    int ret = clientHandler->createService(params, iid);    clientHandler->close();    delete clientHandler;    if (ret == -1) {        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3LeafMesh::createRemoteService - failed to create, not enough resources/n")));        throw ServiceException(ServiceException::INSUFFICIENT_RESOURCES);    }    ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3LeafMesh::createRemoteService - service created!/n")));}

voidLiveEntry::status (LiveStatus l){  {    ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);    this->liveliness_ = l;    if (l == LS_ALIVE)      {        ACE_Time_Value now (ACE_High_Res_Timer::gettimeofday_hr());        this->next_check_ = now + owner_->ping_interval();      }    if (l == LS_TRANSIENT && !this->reping_available())      {        this->liveliness_ = LS_LAST_TRANSIENT;      }  }  this->update_listeners ();  if (this->listeners_.size() > 0)    {      if (ImR_Locator_i::debug () > 2)        {          ORBSVCS_DEBUG ((LM_DEBUG,                          ACE_TEXT ("(%P|%t) LiveEntry::status change, ")                          ACE_TEXT ("server = %C status = %s/n"),                          this->server_.c_str(),                          status_name (this->liveliness_)));        }      this->owner_->schedule_ping (this);    }  else    {      if (this->owner_->remove_per_client_entry (this))        {          delete (this);        }    }}

voidTAO_Object_Adapter::close (int wait_for_completion){  this->check_close (wait_for_completion);  // Shutting down the ORB causes all object adapters to be destroyed,  // since they cannot exist in the absence of an ORB. Shut down is  // complete when all ORB processing (including request processing  // and object deactivation or other operations associated with  // object adapters) has completed and the object adapters have been  // destroyed. In the case of the POA, this means that all object  // etherealizations have finished and root POA has been destroyed  // (implying that all descendent POAs have also been destroyed).  TAO_Root_POA *root = 0;#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)  TAO_POAManager_Factory* factory = 0;#endif  {    ACE_GUARD (ACE_Lock, ace_mon, this->lock ());    if (this->root_ == 0)      return;    root = this->root_;    this->root_ = 0;#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)    if (this->poa_manager_factory_ == 0)      return;    factory = this->poa_manager_factory_;    this->poa_manager_factory_ = 0;#endif  }  CORBA::Boolean etherealize_objects = true;  root->destroy (etherealize_objects, wait_for_completion);  ::CORBA::release (root);#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)  release_poa_manager_factory (factory);#endif}

void ObjectAccessor::Update(uint32 /*diff*/) {	UpdateDataMapType update_players;	// Critical section	{		ACE_GUARD(LockType, g, i_updateGuard);		while (!i_objects.empty()) {			Object* obj = *i_objects.begin();			ASSERT(obj && obj->IsInWorld());			i_objects.erase(i_objects.begin());			obj->BuildUpdate(update_players);		}	}	WorldPacket packet; // here we allocate a std::vector with a size of 0x10000	for (UpdateDataMapType::iterator iter = update_players.begin();			iter != update_players.end(); ++iter) {		iter->second.BuildPacket(&packet);		iter->first->GetSession()->SendPacket(&packet);		packet.clear(); // clean the string	}}

voidTAO_CEC_MT_Dispatching::activate (void){  ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock_);  if (this->active_ != 0)    return;  this->active_ = 1;  if (this->task_.activate (this->thread_creation_flags_,                            this->nthreads_,                            1,                            this->thread_priority_) == -1)    {      if (this->force_activate_ != 0)        {          if (this->task_.activate (THR_BOUND, this->nthreads_) == -1)            ORBSVCS_ERROR ((LM_ERROR,                        "EC (%P|%t) cannot activate dispatching queue"));        }    }}

template <class ACE_LOCK, class ALLOCATOR> voidACE_Timeprobe_Ex<ACE_LOCK, ALLOCATOR>::timeprobe (u_long event){  ACE_GUARD (ACE_LOCK, ace_mon, this->lock_);  this->timeprobes_[this->current_size_].event_.event_number_ = event;  this->timeprobes_[this->current_size_].event_type_ = ACE_timeprobe_t::NUMBER;  this->timeprobes_[this->current_size_].time_ = ACE_OS::gethrtime ();  this->timeprobes_[this->current_size_].thread_ = ACE_OS::thr_self ();  ++this->current_size_;#if !defined (ACE_TIMEPROBE_ASSERTS_FIXED_SIZE)  // wrap around to the beginning on overflow  if (this->current_size_ >= this->max_size_)    {      this->current_size_ = 0;      this->report_buffer_full_ = 1;    }#endif /* ACE_TIMEPROBE_ASSERTS_FIXED_SIZE */  ACE_ASSERT (this->current_size_ < this->max_size_);}

voidTAO_Notify_ThreadPool_Supplier::subscription_change (const CosNotification::EventTypeSeq & added,                                      const CosNotification::EventTypeSeq & /*removed */                                      ){  ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);  // Count the number of consumers connect and signal the supplier thread when the expected count have connected.  // Only 1 consumer connects at a time.  if (added.length () > 0)    {      // Set the domain and type nams in the event's fixed header.      this->event_[consumer_count_].header.fixed_header.event_type.domain_name = CORBA::string_dup(added[0].domain_name);      this->event_[consumer_count_].header.fixed_header.event_type.type_name = CORBA::string_dup(added[0].type_name);      ++this->consumer_count_;      ACE_DEBUG ((LM_DEBUG, "(%P,%t) Received Type %d: (%s)/n", this->consumer_count_, added[0].type_name.in ()));      if (this->consumer_count_ == this->expected_consumer_count_)        this->consumers_connected_.signal ();    }}

voidClient_Service_Handler::open (ACE_HANDLE h, ACE_Message_Block&){  ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, guard, this->mtx_);  if (this->ssl_stream_.open (*this, h, 0, this->proactor ()) != 0)  {    ACE_DEBUG ((LM_DEBUG, ACE_TEXT (      "Client_Service_Handler::open: ACE_SSL_Asynch_Stream::open failed, %d/n"),      (int)errno));    this->cancel_and_close ();  }  else  {    ACE_Message_Block *mb = 0;    ACE_NEW_NORETURN(mb, ACE_Message_Block (DATA_SIZE));    if (this->read_data () < 0 || this->write_data () < 0)    {      this->cancel_and_close ();    }  }}

TAO_CEC_ProxyPushConsumer_Guard::    ~TAO_CEC_ProxyPushConsumer_Guard (void){  // This access is safe because guard objects are created on the  // stack, only one thread has access to them  if (!this->locked_)    return;  {    ACE_GUARD (ACE_Lock, ace_mon, *this->lock_);    // If the guard fails there is not much we can do, raising an    // exception is wrong, the client has *no* way to handle that kind    // of error.  Even worse, there is no exception to raise in that    // case.    // @@ Returning something won't work either, the error should be    // logged though!    --this->refcount_;    if (this->refcount_ != 0)      return;  }  this->event_channel_->destroy_proxy (this->proxy_);}

    void ConnectionCache::close_all_connections()      {        INET_TRACE ("ConnectionCache::close_all_connections");        ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX,                           guard_,                           this->lock_));        map_iter_type iter = this->cache_map_.end ();        for (iter = this->cache_map_.begin ();             iter != this->cache_map_.end ();             ++iter)          {            if ((*iter).int_id_.state () == ConnectionCacheValue::CST_CLOSED)              {                connection_type* conn = (*iter).int_id_.connection ();                (*iter).int_id_.connection (0);                (*iter).int_id_.state (ConnectionCacheValue::CST_CLOSED);                delete conn;              }          }        this->cache_map_.unbind_all ();      }

void WorldLog::outLog(char const *fmt, ...) {	if (LogWorld()) {		ACE_GUARD(ACE_Thread_Mutex, Guard, Lock);		ASSERT(i_file);		va_list args;		va_start(args, fmt);		vfprintf(i_file, fmt, args);		//fprintf(i_file, "/n");		va_end(args);		fflush(i_file);	}	if (sLog->GetLogDB() && m_dbWorld) {		va_list ap2;		va_start(ap2, fmt);		char nnew_str[MAX_QUERY_LEN];		vsnprintf(nnew_str, MAX_QUERY_LEN, fmt, ap2);		sLog->outDB(LOG_TYPE_WORLD, nnew_str);		va_end(ap2);	}}

TAO_AMH_Response_Handler::~TAO_AMH_Response_Handler (void){  this->transport_->remove_reference ();  // Since we are destroying the object we put a huge lock around the  // whole destruction process (just paranoid).  {    ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);    if (this->response_expected_ == 0) //oneway ?      {        return;      }    // If the ResponseHandler is being destroyed before a reply has    // been sent to the client, we send a system exception    // CORBA::NO_RESPONSE, with minor code to indicate the problem.    if (this->rh_reply_status_ == TAO_RS_SENT)      {        return;      }  }  // If sending the exception to the client fails, then we just give  // up, release the transport and return.  try    {      CORBA::NO_RESPONSE ex (CORBA::SystemException::_tao_minor_code                             (TAO_AMH_REPLY_LOCATION_CODE,                              EFAULT),                             CORBA::COMPLETED_NO);      this->_tao_rh_send_exception (ex);    }  catch (...)    {    }}

voidReliableSession::synack_received(ACE_Message_Block* control){  if (! this->active_) return; // sub send syn, then doesn't receive them.  // Already received ack.  if (this->acked_) return;  const TransportHeader& header =    this->link_->receive_strategy()->received_header();  // Not from the remote peer for this session.  if (this->remote_peer_ != header.source_) return;  Serializer serializer(control, header.swap_bytes());  MulticastPeer local_peer;  serializer >> local_peer; // sent as remote_peer  // Ignore sample if not destined for us:  if (local_peer != this->link_->local_peer()) return;  {    ACE_GUARD(ACE_SYNCH_MUTEX,              guard,              this->ack_lock_);    if (this->acked_) return; // already acked    this->syn_watchdog_.cancel();    this->acked_ = true;  }  // Force the TransportImpl to re-evaluate pending associations  // after deliver synack to every session.  this->link_->set_check_fully_association();}

void P3ReplicationGroup::onPeerClosure(UUIDPtr& uuid) {    ACE_GUARD(ACE_SYNCH_RECURSIVE_MUTEX, mon, m_lock);    ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3ReplicationGroup::onPeerClosure uuid=%s/n"), uuid->toString().c_str()));    bool isPrimary = this->isPeerPrimary(uuid);    if (isPrimary) {        if (m_replicas.size() == 0) {            ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3ReplicationGroup::onPeerClosure - PRIMARY CLOSED with no replicas available?/n")));            this->close();            return;        }        this->m_primaryPeer = m_replicas.front();        m_replicas.pop_front();        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3ReplicationGroup::onPeerClosure - PRIMARY CLOSED/n")));        this->printMembers();        if (this->isThisPeerPrimary()) {            ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3ReplicationGroup::onPeerClosure - NEW PRIMARY/n")));            if (!fireOnChangeToPrimary()) {                ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3ReplicationGroup::onPeerClosure - failed to change service mode!n")));                this->close();            }            UUIDPtr iid;            this->m_svcPtr->getIID(iid);            UUIDPtr currentReplicaIID(iid);            ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3ReplicationGroup::onPeerClosure - NEW PRIMARY - Change IID from (%s) to (%s)/n"),                    currentReplicaIID->toString().c_str(), m_groupUUID->toString().c_str()));            m_ft->getOverlay()->getRuntime()->changeIIDOfService(m_sid, currentReplicaIID, m_groupUUID); //m_iid);            return;        }    } else {        this->removeReplica(uuid); //updates the group, a new primary is implicit elected        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: P3ReplicationGroup::onPeerClosure - REPLICA CLOSED/n")));        this->printMembers();    }}

voidRecorderImpl::remove_all_associations(){  DBG_ENTRY_LVL("RecorderImpl","remove_all_associations",6);  OpenDDS::DCPS::WriterIdSeq writers;  int size;  ACE_GUARD(ACE_Recursive_Thread_Mutex, guard, this->publication_handle_lock_);  {    ACE_READ_GUARD(ACE_RW_Thread_Mutex, read_guard, this->writers_lock_);    size = static_cast<int>(writers_.size());    writers.length(size);    WriterMapType::iterator curr_writer = writers_.begin();    WriterMapType::iterator end_writer = writers_.end();    int i = 0;    while (curr_writer != end_writer) {      writers[i++] = curr_writer->first;      ++curr_writer;    }  }  try {    CORBA::Boolean dont_notify_lost = 0;    if (0 < size) {      remove_associations(writers, dont_notify_lost);    }  } catch (const CORBA::Exception&) {  }}

  void  Client_Request_Interceptor::send_request (PortableInterceptor::ClientRequestInfo_ptr ri)  {    // Test TC    test_transport_current (ACE_TEXT ("send_request"));    CORBA::Boolean const response_expected =      ri->response_expected ();    // Oneway?    if (response_expected)      ACE_DEBUG ((LM_DEBUG, ACE_TEXT("CRI    (%P|%t) Sending a two-way/n")));    else      ACE_DEBUG ((LM_DEBUG, ACE_TEXT("CRI    (%P|%t) Sending a one-way/n")));    // Make the context to send the context to the target    IOP::ServiceContext sc;    sc.context_id = Test::Transport::CurrentTest::ContextTag;    // How long can a number really get?    char temp[32];    {      ACE_GUARD (TAO_SYNCH_MUTEX, monitor, this->lock_);      ACE_OS::sprintf (temp, "%ld", this->requestID_);      ++this->requestID_;    }    CORBA::ULong string_len = ACE_OS::strlen (temp) + 1;    CORBA::Octet *buf = CORBA::OctetSeq::allocbuf (string_len);    ACE_OS::strcpy (reinterpret_cast <char *> (buf), temp);    sc.context_data.replace (string_len, string_len, buf, 1);    // Add this context to the service context list.    ri->add_request_service_context (sc, 0);  }

voidContinuous_Worker::print_stats (ACE_Sample_History &history,                                ACE_hrtime_t test_end){  ACE_GUARD (TAO_SYNCH_MUTEX,             mon,             this->synchronizers_.worker_lock_);  if (individual_continuous_worker_stats)    {      ACE_DEBUG ((LM_DEBUG,                  "/n************ Statistics for thread %t ************/n/n"));      ACE_DEBUG ((LM_DEBUG,                  "Iterations = %d/n",                  history.sample_count ()));      if (do_dump_history)        {          history.dump_samples (ACE_TEXT("HISTORY"), gsf);        }      ACE_Basic_Stats stats;      history.collect_basic_stats (stats);      stats.dump_results (ACE_TEXT("Total"), gsf);      ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,                                             test_end - test_start,                                             stats.samples_count ());    }  history.collect_basic_stats (this->collective_stats_);  ACE_hrtime_t elapsed_time_for_current_thread =    test_end - test_start;  if (elapsed_time_for_current_thread > this->time_for_test_)    this->time_for_test_ = elapsed_time_for_current_thread;}

void TAO::PG_Property_Set::remove (const PortableGroup::Properties & property_set){  ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);  size_t count = property_set.length ();  for (size_t nItem = 0; nItem < count; ++nItem)  {    const PortableGroup::Property & property = property_set[nItem];    const CosNaming::Name & nsName = property.nam;    // note assumption one level name with no kind    // @@ TODO: fix this    const CosNaming::NameComponent & nc = nsName[0];    ACE_CString name = static_cast<const char *> (nc.id);    const PortableGroup::Value * deleted_value;    if ( 0 == this->values_.unbind (name, deleted_value))    {      delete deleted_value;    }    else    {      // don't worry about it.    }  }}

  void Sender_exec_i::create_samples (void)  {    ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX, _guard,                      this->keys_lock_);    for (CORBA::UShort i = 1; i < this->keys_ + 1; ++i)      {        char key[7];        UL_ResetTopicTest *new_key = new UL_ResetTopicTest;        ACE_OS::sprintf (key, "KEY_%d", i);        new_key->key = CORBA::string_dup(key);        new_key->iteration = 0;        this->tests_[key] = new_key;        ::UL_ResetTopic::UL_ResetTopicTestConnector::Updater_var updater =          this->ciao_context_->get_connection_info_update_data();        updater->create_one (*new_key);        ACE_DEBUG ((LM_DEBUG, "Sender_exec_i::create_samples - "                  "Sample <%C> created/n",                  key));      }    this->last_key_ = this->tests_.begin ();  }

voidACE_SSL_Context::ssl_library_fini (void){  ACE_MT (ACE_GUARD (ACE_Recursive_Thread_Mutex,                     ace_ssl_mon,                     *ACE_Static_Object_Lock::instance ()));  --ssl_library_init_count;  if (ssl_library_init_count == 0)    {      ::ERR_free_strings ();      ::EVP_cleanup ();      // Clean up the locking callbacks after everything else has been      // cleaned up.#ifdef ACE_HAS_THREADS      ::CRYPTO_set_locking_callback (0);      ssl_locks = 0;      delete [] this->locks_;      this->locks_ = 0;#endif  /* ACE_HAS_THREADS */    }}

voidAIO_SSL_Client_Session::resume(){	if ( ssl_ )	{		{			ACE_GUARD(ACE_SYNCH_MUTEX, monitor, this->lock_);			if ( !is_paused() ) return;			n_op_r_ -= 8; n_op_w_ -= 8;			this->on_resume();			if ( this->has_pending_io() ) return;			if ( this->is_safe_to_delete_ == 0 ) { ssl_stream_.close(); return; }			this->on_close();		}		manager_->destroy_session(this);	}	else	{		AIO_Session::resume();	}}

static voidrecursive_worker (size_t nesting_level,                  ACE_Recursive_Thread_Mutex *rm){  if (nesting_level < n_iterations)    {      ACE_DEBUG ((LM_DEBUG,                  "(%P|%t) = trying to acquire, nesting = %d, thread id = %u/n",      rm->get_nesting_level (), rm->get_thread_id ()));      {        // This illustrates the use of the ACE_GUARD with an        // ACE_Recursive_Thread_Mutex.        ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, *rm);        ACE_DEBUG ((LM_DEBUG,                    "(%P|%t) = acquired, nesting = %d, thread id = %u/n",        rm->get_nesting_level (), rm->get_thread_id ()));        recursive_worker (nesting_level + 1, rm);      }      ACE_DEBUG ((LM_DEBUG,                  "(%P|%t) = released, nesting = %d, thread id = %u/n",      rm->get_nesting_level (), rm->get_thread_id ()));    }}

//// shutdown//void Standard_DAC_App::shutdown (void){  try  {    ACE_ERROR ((LM_ERROR,                ACE_TEXT ("%T (%t) - %M - %s received shutdown signal/n"),                DAC::EXECUTION_CONTEXT::instance ()->name ().c_str ()));    // Signal the application to exit.    ACE_GUARD (ACE_Thread_Mutex, guard, this->lock_);    this->exit_.signal ();  }  catch (const std::exception & ex)  {    ACE_ERROR ((LM_ERROR,                ACE_TEXT ("%T (%t) - %M - %s/n"),                ex.what ()));  }  catch (...)  {    ACE_ERROR ((LM_ERROR,    ACE_TEXT ("%T (%t) - %M - caught unknown exception [%N:%l]/n")));  }}

voidReceiver::open (ACE_HANDLE handle, ACE_Message_Block &){  {    ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->lock_);    if (this->flg_cancel_ ||        this->stream_.open (*this,                             handle,                             0, // completion key,                             this->task().get_proactor(this->index()),                             1 ) == -1)      {        this->flg_safe_delete_ = true;        ACE_ERROR ((LM_ERROR,                  ACE_TEXT ("%%s p/n"),                  this->get_name(),                  ACE_TEXT ("ACE_SSL_Asynch_Stream::open")));      }    else      {        this->flg_safe_delete_ = false;        if (this->initiate_read_stream () != 0)          this->cancel_i();      }    if (!this->is_safe_to_delete())      {        return;      }  }  this->manager()->destroy_session(this);}

////////////////////////////////////////////////////////////////////////////////// /brief/// Removes all long transaction name entries for the specified session.///void MgLongTransactionManager::RemoveLongTransactionNames(CREFSTRING sessionId){    MG_FEATURE_SERVICE_TRY()    ACE_MT(ACE_GUARD(ACE_Recursive_Thread_Mutex, ace_mon, sm_mutex));    LongTransactionNameCache::iterator iter = s_LongTransactionNameCache.find(sessionId);    while (iter != s_LongTransactionNameCache.end() && sessionId == iter->first)    {        STRING cacheKey = iter->first;        if (ACE_OS::strcasecmp(cacheKey.c_str(), sessionId.c_str()) == 0)        {            // We have a key match            delete iter->second;            s_LongTransactionNameCache.erase(iter++);        }        else        {            iter++;        }    }    MG_FEATURE_SERVICE_CATCH_AND_THROW(L"MgLongTransactionManager.RemoveLongTransactionNames")}