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

template <class TYPE, class FUNCTOR, class ACE_LOCK> intACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::cancel (long timer_id,                                                   const void **act,                                                   int dont_call){  ACE_TRACE ("ACE_Timer_List_T::cancel");  ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));  // Make sure we are getting a valid <timer_id>, not an error  // returned by schedule ()  if (timer_id == -1)    return 0;  ACE_Timer_Node_T<TYPE> *node =     ACE_reinterpret_cast (ACE_Timer_Node_T<TYPE> *,                          timer_id);  // Check to see if the node looks like a true ACE_Timer_Node_T<TYPE>  if (timer_id == node->get_timer_id ())    {      node->get_next ()->set_prev (node->get_prev ());      node->get_prev ()->set_next (node->get_next ());      if (act != 0)        *act = node->get_act ();      if (dont_call == 0)        this->upcall_functor ().cancellation (*this,                                              node->get_type ());      this->free_node (node);      return 1;    }  // Wasn't valid  return 0;}

void *ACE_DLL_Handle::symbol (const ACE_TCHAR *sym_name, int ignore_errors){  ACE_TRACE ("ACE_DLL_Handle::symbol");  ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0));  ACE_Auto_Array_Ptr <ACE_TCHAR> auto_name (ACE::ldname (sym_name));  // handle_ can be invalid especially when ACE_DLL_Handle resigned ownership  // BTW. Handle lifecycle management is a little crazy in ACE  if (this->handle_ != ACE_SHLIB_INVALID_HANDLE)    {#if defined (ACE_OPENVMS)      void *sym =  ACE::ldsymbol (this->handle_, auto_name.get ());#else      void *sym =  ACE_OS::dlsym (this->handle_, auto_name.get ());#endif      // Linux says that the symbol could be null and that it isn't an      // error.  So you should check the error message also, but since      // null symbols won't do us much good anyway, let's still report      // an error.      if (!sym && ignore_errors != 1)        {          if (ACE::debug ())            ACE_ERROR ((LM_ERROR,                        ACE_TEXT ("ACE (%P|%t) DLL_Handle::symbol (/"%s/") ")                        ACE_TEXT (" failed with /"%s/"./n"),                        auto_name.get (),                        this->error ()->c_str ()));          return 0;        }      return sym;    }  return 0;}

ACE_UINT32ACE_High_Res_Timer::global_scale_factor (void){#if (defined (ACE_WIN32) || defined (ACE_HAS_POWERPC_TIMER) || /     defined (ACE_HAS_PENTIUM) || defined (ACE_HAS_ALPHA_TIMER)) && /    !defined (ACE_HAS_HI_RES_TIMER) && /    ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || /     defined (ghs) || defined (__GNUG__) || defined (__KCC))  // Check if the global scale factor needs to be set, and do if so.  if (ACE_High_Res_Timer::global_scale_factor_status_ == 0)    {      // Grab ACE's static object lock.  This doesn't have anything to      // do with static objects; it's just a convenient lock to use.      ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,                                *ACE_Static_Object_Lock::instance (), 0));      // Double check      if (ACE_High_Res_Timer::global_scale_factor_status_ == 0)        {#         if defined (ACE_WIN32)            LARGE_INTEGER freq;            if (::QueryPerformanceFrequency (&freq))              {                // We have a high-res timer#             if defined (ghs)                ACE_UINT64 uint64_freq(freq.u.LowPart, (ACE_UINT32) freq.u.HighPart);                ACE_High_Res_Timer::global_scale_factor                  (uint64_freq / (ACE_UINT32) ACE_ONE_SECOND_IN_USECS);#             else                ACE_High_Res_Timer::global_scale_factor                  (ACE_static_cast (unsigned int,                                    freq.QuadPart / ACE_HR_SCALE_CONVERSION));#             endif // (ghs)                ACE_High_Res_Timer::global_scale_factor_status_ = 1;              }

template <PR_ST_1, ACE_SYNCH_DECL> intACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::put (ACE_Message_Block *mb,                                                       ACE_Time_Value *tv){  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, m, this->msg_queue ()->lock (), -1);  // Enqueue <mb> onto the message queue.  if (this->putq (mb, tv) == -1)    return -1;  else    {      // Update the current number of bytes on the queue.      this->current_buffer_size_ += mb->total_size ();      // Flush the buffer when the number of bytes exceeds the maximum      // buffer size or when the timeout period has elapsed.      if (this->current_buffer_size_ >= this->maximum_buffer_size_          || (this->timeoutp_ != 0              && this->next_timeout_ <= ACE_OS::gettimeofday ()))        return this->flush_i ();      else        return 0;    }}

    Monitor_Control_Types::NameList    Monitor_Base::get_list (void) const    {      Monitor_Control_Types::NameList retval;      if(this->data_.type_ != Monitor_Control_Types::MC_LIST)        {          ACE_ERROR ((LM_ERROR,                      ACE_TEXT ("get_list: %s is not a ")                      ACE_TEXT ("list monitor type/n"),                      this->name_.c_str ()));          return retval;        }      ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, retval);      for(size_t i = 0UL; i < this->data_.index_; ++i)        {          retval.push_back (this->data_.list_[i]);        }      return retval;    }

BattlegroundMap* MapInstanced::CreateBattleground(uint32 InstanceId, Battleground* bg){    // load/create a map    ACE_GUARD_RETURN(ACE_Thread_Mutex, Guard, Lock, NULL);    sLog->outDebug(LOG_FILTER_MAPS, "MapInstanced::CreateBattleground: map bg %d for %d created.", InstanceId, GetId());    PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(),bg->GetMinLevel());    uint8 spawnMode;    if (bracketEntry)        spawnMode = bracketEntry->difficulty;    else        spawnMode = REGULAR_DIFFICULTY;    BattlegroundMap *map = new BattlegroundMap(GetId(), GetGridExpiry(), InstanceId, this, spawnMode);    ASSERT(map->IsBattlegroundOrArena());    map->SetBG(bg);    bg->SetBgMap(map);    m_InstancedMaps[InstanceId] = map;    return map;}

ssize_tACE_MT_MEM_IO::recv_buf (ACE_MEM_SAP_Node *&buf,                         int flags,                         const ACE_Time_Value *timeout){  ACE_TRACE ("ACE_MT_MEM_IO::recv_buf");  // @@ Don't know how to handle timeout yet.  ACE_UNUSED_ARG (timeout);  ACE_UNUSED_ARG (flags);  if (this->shm_malloc_ == 0)    {      return -1;    }  // Need to handle timeout here.  if (this->recv_channel_.sema_->acquire () == -1)    {      return -1;    }  {    // @@ We can probably skip the lock in certain circumstance.    ACE_GUARD_RETURN (ACE_SYNCH_PROCESS_MUTEX, ace_mon, *this->recv_channel_.lock_, -1);    buf = this->recv_channel_.queue_.read ();        if (buf != 0)      {        return ACE_Utils::truncate_cast<ssize_t> (buf->size ());      }          return -1;  }}

ACE_Framework_Repository *ACE_Framework_Repository::instance (int size){    ACE_TRACE ("ACE_Framework_Repository::instance");    if (ACE_Framework_Repository::repository_ == 0)    {        // Perform Double-Checked Locking Optimization.        ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,                                  *ACE_Static_Object_Lock::instance (), 0));        if (ACE_Framework_Repository::repository_ == 0)        {            if (ACE_Object_Manager::starting_up () ||                    !ACE_Object_Manager::shutting_down ())            {                ACE_NEW_RETURN (ACE_Framework_Repository::repository_,                                ACE_Framework_Repository (size),                                0);            }        }    }    return ACE_Framework_Repository::repository_;}

boolRandom_File::open(const ACE_TCHAR* filename, size_t block_size){  ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, false);  this->block_size_ = block_size;  bool result = (this->close() == 0);  if (result)  {    if (DEBUG_LEVEL > 8) ORBSVCS_DEBUG ((LM_DEBUG,      ACE_TEXT ("(%P|%t) Opening file %s/n")      , filename      ));    ACE_HANDLE handle = ACE_OS::open(filename,      O_CREAT | O_RDWR | O_BINARY,      ACE_DEFAULT_FILE_PERMS);    if (handle == ACE_INVALID_HANDLE)    {      result = false;    }    else    {      this->set_handle(handle);      if (this->get_handle() == 0)      {        result = false;      }      else      {        result = (this->addr_.set(filename) == 0);      }    }  }  return result;}

const ACE_INET_Addr &TAO_SSLIOP_Endpoint::object_addr (void) const{  // The object_addr_ is initialized here, rather than at IOR decode  // time for several reasons:  //   1. A request on the object may never be invoked.  //   2. The DNS setup may have changed dynamically.  //   ...etc..  // Double checked locking optimization.  if (this->object_addr_.get_type () != AF_INET#if defined (ACE_HAS_IPV6)      && this->object_addr_.get_type () != AF_INET6#endif /* ACE_HAS_IPV6 */     )    {      const ACE_INET_Addr &iiop_addr = this->iiop_endpoint_->object_addr ();      ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,                        guard,                        this->addr_lookup_lock_,                        this->object_addr_);      if (this->object_addr_.get_type () != AF_INET#if defined (ACE_HAS_IPV6)          && this->object_addr_.get_type () != AF_INET6#endif /* ACE_HAS_IPV6 */     )        {          this->object_addr_ = iiop_addr;          this->object_addr_.set_port_number (this->ssl_component_.port);        }    }  return this->object_addr_;}

Sender *Connection_Cache::acquire_connection (void){  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, 0);  // Find a valid and IDLE sender.  int index = -1;  for (int i = 0; i < number_of_connections; ++i)    {      if (this->entries_[i].sender_ &&          this->entries_[i].state_ == IDLE)        index = i;    }  if (index == -1)    return 0;  this->entries_[index].sender_->add_reference ();  this->entries_[index].state_ = BUSY;  return this->entries_[index].sender_;}

CosNotifyChannelAdmin::SupplierAdmin_ptrTAO_Notify_EventChannel::default_supplier_admin (void){  if (CORBA::is_nil (default_supplier_admin_.in ()))    {      ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->default_admin_mutex_, CosNotifyChannelAdmin::SupplierAdmin::_nil());      if (CORBA::is_nil (default_supplier_admin_.in ()))        {          CosNotifyChannelAdmin::AdminID id;          this->default_supplier_admin_ =            this->new_for_suppliers (TAO_Notify_PROPERTIES::instance ()->defaultSupplierAdminFilterOp(), id);          PortableServer::ServantBase * admin_servant =            this->poa()->poa()->reference_to_servant (              this->default_supplier_admin_.in ());          TAO_Notify_Admin * pAdmin = dynamic_cast <TAO_Notify_Admin *> (admin_servant);          ACE_ASSERT (pAdmin != 0); // if this assert triggers, we have mixed implementations?          if (pAdmin != 0)            {              pAdmin->set_default (true);            }        }    }  return CosNotifyChannelAdmin::SupplierAdmin::_duplicate (this->default_supplier_admin_.in ());}

intACE_Based_Pointer_Repository::find (void *addr,                                    void *&base_addr){  ACE_TRACE ("ACE_Based_Pointer_Repository::find");  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1);  ACE_Based_Pointer_Repository_Rep::MAP_ENTRY *ce = 0;  for (ACE_Based_Pointer_Repository_Rep::MAP_ITERATOR iter (this->rep_->addr_map_);       iter.next (ce) != 0;       iter.advance ())    // Check to see if <addr> is within any of the regions.    if (addr >= ce->ext_id_        && addr < ((char *) ce->ext_id_ + ce->int_id_))      {        // Assign the base address.        base_addr = ce->ext_id_;        return 1;      }  // Assume base address 0 (e.g., if new'ed).  base_addr = 0;  return 0;}

longTRB_Proactor::schedule_timer (TRB_Handler &handler,                              const void *act,                              const ACE_Time_Value &time,                              const ACE_Time_Value &interval){    // absolute time.    ACE_Time_Value absolute_time =        this->timer_queue_->gettimeofday () + time;    // Only one guy goes in here at a time    ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX,                              ace_mon,                              this->timer_queue_->mutex (),                              -1));    // Schedule the timer    long result = this->timer_queue_->schedule (&handler,                  act,                  absolute_time,                  interval);    if (result != -1)    {        // no failures: check to see if we are the earliest time        if (this->timer_queue_->earliest_time () == absolute_time)            // wake up the timer thread            if (this->timer_handler_->timer_event_.signal () == -1)            {                // Cancel timer                this->timer_queue_->cancel (result);                result = -1;            }    }    return result;}

intTAO_Table_Adapter::dispatch (TAO::ObjectKey &key,                             TAO_ServerRequest &request,                             CORBA::Object_out forward_to){  TAO_IOR_Table_Impl_var rootref;  {    ACE_GUARD_RETURN (ACE_Lock,                      ace_mon,                      *this->lock_,                      TAO_Adapter::DS_MISMATCHED_KEY);    if (this->closed_)      return TAO_Adapter::DS_MISMATCHED_KEY;    rootref = this->root_;  }  if (this->find_object (key, forward_to))    {      request.forward_location (forward_to);      return TAO_Adapter::DS_FORWARD;    }  else    return TAO_Adapter::DS_MISMATCHED_KEY;}

int GDCT_Transfer::do_send_one_data(GDCT_Data *the_data){	int ret;	ACE_Time_Value to = default_timeout_;	unsigned char *buf = (unsigned char*) the_data->msg_->rd_ptr();	size_t buflen = the_data->msg_->length();	ret = KSGNetUtil::send_buffer(connector_.get_handle(),buf,buflen,&to);	if(ret)	{		int r = ACE_OS::last_error();		ACE_DEBUG((LM_ERROR,"发送数据到讯源错误,error[%d:%s]",r,ACE_OS::strerror(r)));		the_data->msg_->release();		REACTOR_SCHEDULER::instance()->close_error_socket(the_data->handle_);		return -1;	}	{		// 保存到等待接收队列		char seqno[11] = "";		memcpy(seqno,the_data->msg_->rd_ptr()+4,10);		ACE_GUARD_RETURN(ACE_Thread_Mutex,m,msg_mutex_,-1);		output_queue_.insert(MESSAGE_MAP_TYPE::value_type(seqno,*the_data));	}	return 0;}

PortableGroup::ObjectGroup_ptrTAO_PG_ObjectGroupManager::add_member (    PortableGroup::ObjectGroup_ptr object_group,    const PortableGroup::Location & the_location,    CORBA::Object_ptr member){  if (CORBA::is_nil (member))    throw CORBA::BAD_PARAM ();  ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,                    guard,                    this->lock_,                    PortableGroup::ObjectGroup::_nil ());  // Verify that the member's RepositoryId matches the object group's  // type ID.  const CORBA::Boolean check_type_id = 1;  return this->add_member_i (object_group,                             the_location,                             member,                             check_type_id);}

template <class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Time_Value *ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::calculate_timeout (ACE_Time_Value *max_wait_time){  ACE_TRACE ("ACE_Timer_Queue_T::calculate_timeout");  ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, max_wait_time));  if (this->is_empty ())    // Nothing on the Timer_Queue, so use whatever the caller gave us.    return max_wait_time;  else    {      ACE_Time_Value cur_time = this->gettimeofday ();      if (this->earliest_time () > cur_time)        {          // The earliest item on the Timer_Queue is still in the          // future.  Therefore, use the smaller of (1) caller's wait          // time or (2) the delta time between now and the earliest          // time on the Timer_Queue.          this->timeout_ = this->earliest_time () - cur_time;          if (max_wait_time == 0 || *max_wait_time > timeout_)            return &this->timeout_;          else            return max_wait_time;        }      else        {          // The earliest item on the Timer_Queue is now in the past.          // Therefore, we've got to "poll" the Reactor, i.e., it must          // just check the descriptors and then dispatch timers, etc.          this->timeout_ = ACE_Time_Value::zero;          return &this->timeout_;        }    }}

ACE_Proactor *ACE_Proactor::instance (size_t /* threads */){    ACE_TRACE ("ACE_Proactor::instance");    if (ACE_Proactor::proactor_ == 0)    {        // Perform Double-Checked Locking Optimization.        ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,                                  *ACE_Static_Object_Lock::instance (),                                  0));        if (ACE_Proactor::proactor_ == 0)        {            ACE_NEW_RETURN (ACE_Proactor::proactor_,                            ACE_Proactor,                            0);            ACE_Proactor::delete_proactor_ = true;            ACE_REGISTER_FRAMEWORK_COMPONENT(ACE_Proactor, ACE_Proactor::proactor_);        }    }    return ACE_Proactor::proactor_;}

bool MgServerFeatureReaderPool::Remove(STRING featureReader){    ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, m_mutex, false));    bool bResult = false;    INT32 ref = 0;    FeatureReaderCollection::iterator iterator = m_frCollection.find(featureReader);    if(m_frCollection.end() != iterator)    {        // Release resources        MgFeatureReader* reader = iterator->second;        if(reader)        {            ref = reader->Release();        }        // Remove the reader        m_frCollection.erase(iterator);        bResult = true;    }    return bResult;}

intClient_Task::svc (void){  ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting client task/n"));  try    {      while (1)        {          // run the even loop for 1 second...          ACE_Time_Value tv (1, 0);          this->orb_->run (tv);          ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, -1);          if (this->terminate_loop_ != 0)            break;        }    }  catch (const CORBA::Exception&)    {      return -1;    }  ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client task finished/n"));  return 0;}

intACE_Message_Queue_NT::pulse (void){  ACE_TRACE ("ACE_Message_Queue_NT::pulse");  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1);  int const previous_state = this->state_;  if (previous_state != ACE_Message_Queue_Base::DEACTIVATED)    {      this->state_ = ACE_Message_Queue_Base::PULSED;      // Get the number of shutdown messages necessary to wake up all      // waiting threads.      DWORD cntr =        this->cur_thrs_ - static_cast<DWORD> (this->cur_count_);      while (cntr-- > 0)        ::PostQueuedCompletionStatus (this->completion_port_,                                      0,                                      this->state_,                                      0);    }  return previous_state;}

int Sched_Ready_Queue<DSRT_Scheduler_Traits,                      More_Eligible_Comparator, ACE_LOCK>::remove (Guid_t guid){  ACE_GUARD_RETURN (ACE_LOCK, mon, lock_, -1);  RB_Tree_Dispatch_Item_Node* rb_tree_node = 0;  if (dispatch_items_hash_map_.find(guid, rb_tree_node) == 0)    {      dispatch_items_hash_map_.unbind (guid);      dispatch_items_prio_queue_.unbind (rb_tree_node);#ifdef KOKYU_DSRT_LOGGING      ACE_DEBUG ((LM_DEBUG,                  "<===Hash Table contents Begin===>/n"));      dispatch_items_hash_map_.dump ();      ACE_DEBUG ((LM_DEBUG,                  "<===Hash Table contents End===>/n"));#endif      return 0;    }  return -1;}

template <class T> intACE_Future_Rep<T>::get (T &value,                        ACE_Time_Value *tv) const{  // If the value is already produced, return it.  if (this->value_ == 0)    {      ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon,                        this->value_ready_mutex_,                        -1);      // If the value is not yet defined we must block until the      // producer writes to it.      while (this->value_ == 0)        // Perform a timed wait.        if (this->value_ready_.wait (tv) == -1)          return -1;      // Destructor releases the lock.    }  value = *this->value_;  return 0;}

intConnector::validate_connection(const TRB_Asynch_Connect::Result&  result,                               const ACE_INET_Addr& /*remote*/,                               const ACE_INET_Addr& /*local*/){  ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, monitor, this->mutex (), -1);  --this->ref_cnt_;  int rc = 0;  if (!result.success() || this->should_finish())    {      rc = -1;      ACE_DEBUG ((LM_DEBUG,                  ACE_TEXT ("(%t) Connector: Connect failed err=%d/n"),                  (int) result.error()));    }  if(this->is_safe_to_delete())    this->task().signal_main();  return rc;}

RequestEngine<SthenoPacket*>::RequestPtr* LeafClientHandler::sendRequest(SthenoPacket* packet,        ACE_Time_Value* timeout) {    ACE_GUARD_RETURN(ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, m_lock, 0);    if (m_close) {        return 0;    }    ACE_Message_Block* mb = serializePacket(packet);    if (m_debugLeafClientHandler) {        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: LeafClientHandler:sendRequest(): buffer_size=%d packet_serialize_size=%d/n"),                mb->length(), packet->getSerializationSize()));    }    UInt id = ((SthenoHeader*) (packet->getPacketHeader()))->getPacketID();    RequestEngine<SthenoPacket*>::RequestPtr* request =            new RequestEngine<SthenoPacket*>::RequestPtr(new Request<SthenoPacket*>(&m_requests, id, timeout));    m_requests.bind(request);    int ret = AbstractStreamChannel<ACE_SOCK_Stream, ACE_MT_SYNCH>::send(mb, timeout);    ACE_Message_Block::release(mb);    if (ret == -1) {        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)ERROR: LeafClientHandler:sendRequest() - register ID(%d) failed!"), id));        delete request;        return 0;    }    return request;}

intETCL_Interpreter::build_tree (const char* constraints){  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,                    guard,                    ETCL_Interpreter::parserMutex__,                    -1);  Lex_String_Input::reset ((char*)constraints);  yyval.constraint = 0;  int return_value = ::yyparse ();  if (return_value == 0 && yyval.constraint != 0)    {      this->root_ = yyval.constraint;    }  else    {      this->root_ = 0;    }  return return_value;}

static void *worker (void *c){  intptr_t count = reinterpret_cast<intptr_t> (c);  ACE_thread_key_t key = ACE_OS::NULL_key;  int *ip = 0;  // Make one key that will be available when the thread exits so that  // we'll have something to cleanup!  if (ACE_Thread::keycreate (&key, cleanup) == -1)    ACE_ERROR ((LM_ERROR,                "(%t) %p/n",                "ACE_Thread::keycreate"));  ACE_NEW_RETURN (ip,                  int,                  0);  if (ACE_Thread::setspecific (key, (void *) ip) == -1)    ACE_ERROR ((LM_ERROR,                "(%t) %p/n",                "ACE_Thread::setspecific"));  for (intptr_t i = 0; i < count; i++)    {      if (ACE_Thread::keycreate (&key, cleanup) == -1)        ACE_ERROR ((LM_ERROR,                    "(%t) %p/n",                    "ACE_Thread::keycreate"));      ACE_NEW_RETURN (ip,                      int,                      0);      ACE_DEBUG ((LM_DEBUG,                  "(%t) in worker 1, key = %d, ip = %x/n",                  key,                  ip));      {        // tmp is workaround for gcc strict aliasing warning.        void *tmp = reinterpret_cast <void *> (ip);        if (ACE_Thread::setspecific (key, tmp) == -1)          ACE_ERROR ((LM_ERROR,                      "(%t) %p/n",                      "ACE_Thread::setspecific"));        if (ACE_Thread::getspecific (key, &tmp) == -1)          ACE_ERROR ((LM_ERROR,                      "(%t) %p/n",                      "ACE_Thread::setspecific"));        if (ACE_Thread::setspecific (key, (void *) 0) == -1)          ACE_ERROR ((LM_ERROR,                      "(%t) %p/n",                      "ACE_Thread::setspecific"));      }      delete ip;      if (ACE_Thread::keyfree (key) == -1)        ACE_ERROR ((LM_ERROR,                    "(%t) %p/n",                    "ACE_Thread::keyfree"));      // Cause an error.      ACE_OS::read (ACE_INVALID_HANDLE, 0, 0);      // The following two lines set the thread-specific state.      tss_error->error (errno);      tss_error->line (__LINE__);      // This sets the static state (note how C++ makes it easy to do      // both).      tss_error->flags (ACE_Utils::truncate_cast<int> (count));      {        // Use the guard to serialize access to printf...        ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, printf_lock, 0);        // Print the thread id portably.        ACE_DEBUG ((LM_DEBUG,                    "(%t) errno = %d, lineno = %d, flags = %d/n",                    tss_error->error (),                    tss_error->line (),                    tss_error->flags ()));      }      key = ACE_OS::NULL_key;      if (ACE_Thread::keycreate (&key, cleanup) == -1)        ACE_ERROR ((LM_ERROR,                    "(%t) %p/n",                    "ACE_Thread::keycreate"));      ACE_NEW_RETURN (ip,                      int,                      0);//.........这里部分代码省略.........

size_t KSG_Task_Queue::count_of_preemptive_tasks(){	ACE_MT(ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,mon,_task_list_mutex,0));	return _list_of_preempt_tasks.size();}

intCallback_i::done (void){  ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, 0);  return this->remaining_samples_ == 0;}