C++ condition::timed_wait方法代码示例

    bool dequeue( msg_type & msg, boost::xtime const& xt)
    {
      typename boost::mutex::scoped_lock lock( mtx_);
      if ( active_ == false && empty_() ) return false;
      not_empty_cond_.timed_wait( 
				 lock,
				 xt,
				 boost::bind(
					     & Queue< T, Q >::consumers_activate_,
					     this) );
      if ( empty_() )
	msg.reset();
      else
	dequeue_( msg);
      if ( active_ == true && queue_.size() <= low_water_mark_)
	not_full_cond_.notify_one();
      return msg ? true : false;
    }

    bool enqueue( msg_type const& msg, boost::xtime const& xt)
    {
      typename boost::mutex::scoped_lock lock( mtx_);
      if ( active_ == false) return false;
      not_full_cond_.timed_wait( 
				lock,
				xt,
				boost::bind(
					    & Queue< T, Q >::suppliers_activate_,
					    this) );
      if ( active_ != false)
	{
	  enqueue_( msg);
	  not_empty_cond_.notify_one();
	  return true;
	}
      else
	return false;
    }

void *SysQNode::Receive (int *pLen, bool Blocking)
{
  boost::mutex::scoped_lock lock (m_EventMutex);

  assert (m_Sanity == 0xEDFEEFBE) ;
  if (m_Sanity != 0xEDFEEFBE)
    throw vfeInvalidDataError("Invalid sanity field in SysQNode::Receive");

  if (m_Count == 0)
  {
    if (Blocking == false)
      return (NULL);

    // TODO: have a shorter wait but loop, and check for system shutdown
    // TODO FIXME - boost::xtime has been deprecated since boost 1.34.
    boost::xtime t;
    boost::xtime_get (&t, POV_TIME_UTC);
    t.nsec += 50000000 ;
    m_Event.timed_wait (lock, t);

    if (m_Count == 0)
      return (NULL) ;
  }

  DataNode *dNode = m_First ;
  if (dNode == NULL)
    throw vfeInvalidDataError("NULL data node in SysQNode::Receive");

  void *dPtr = dNode->Data ;
  *pLen = dNode->Len ;
  if (dNode == m_Last)
    m_Last = NULL ;
  m_First = dNode->Next ;
  m_Count-- ;
  assert (m_Count != 0 || (m_First == NULL && m_Last == NULL)) ;
  POVMS_Sys_Free (dNode) ;
  return (dPtr) ;
}

  /// Entry point for the asynchronous monitor thread
  void run()
  {
    bool run = true;
    typedef std::pair< callback_t , std::pair< file_action, std::string> > notification;
    std::vector< notification> notifications;

    for (;;)
    {
      {
        // Lock and check m_run; if it was set to false, we must return ASAP
        boost::mutex::scoped_lock lock(m_run_mutex);
        run = m_run;
        if (!run)
          return;
        // We release the lock, block the thread until one second
        m_run_cond.timed_wait(lock, moost::thread::xtime_util::add_ms(moost::thread::xtime_util::now(), m_sleep_ms));
      }
      // If we are not running (e.g. when the destructor woke us up), return
      if (!run)
        return;

      // Clear the notifications vector where we will collect the events
      // that will be fired
      notifications.clear();
      {
        // Lock m_file_mutex while we are working on m_file_callback
        boost::mutex::scoped_lock lock(m_file_mutex);
        for (std::map<std::string, callback_t>::iterator it = m_file_callback.begin(); it != m_file_callback.end(); ++it)
        {
          boost::filesystem::path p(it->first);

          // Does the path exist?
          std::time_t lw = last_write_time(p);
          if (lw != 0)
          {
            // Check its last modification time and compare it with what we had earlier
            std::map< std::string, std::pair<time_t, time_t> >::iterator it_mod = m_file_modified.find(it->first);

            if (it_mod == m_file_modified.end())
            {
              // We haven't seen this file so far, so insert it into the
              // map and add a creation event that will be fired
              m_file_modified[it->first] = std::make_pair(lw, lw);
              notifications.push_back(std::make_pair(it->second, std::make_pair(CREATED, it->first)));
            }
            else
            {
              // only case we consider a real modification: prev prev mod != prev mod,
              // but this mod == prev mod
              // the idea is that we want to capture a write to a file,
              // but only notify when the write is finished

              /**
               * \todo This could cause problems with frequent writing.
               *       We should really use boost.interprocess file locking
               *       instead (when we get 1.36 everywhere)
               */
              if (lw == it_mod->second.second && it_mod->second.first != it_mod->second.second)
                notifications.push_back(std::make_pair(it->second, std::make_pair(CHANGED, it->first)));
              it_mod->second.first = it_mod->second.second;
              it_mod->second.second = lw;
            }
          }
          else
          {
            // The path does not exist. Did we have it before? If so, fire
            // a deletion event.
            std::map< std::string, std::pair<time_t, time_t> >::iterator it_mod = m_file_modified.find(it->first);
            if (it_mod != m_file_modified.end())
            {
              m_file_modified.erase(it_mod);
              notifications.push_back(std::make_pair(it->second, std::make_pair(DELETED, it->first)));
            }
          }
        }
      }

      // okay!  we've released our lock on m_file_callback and m_file_modified
      // so it's time to send off our notifications
      for (std::vector<notification>::iterator it = notifications.begin(); it != notifications.end(); ++it)
      {
        try
        {
          it->first(it->second.first, it->second.second);
        }
        catch (...)
        {
          // \todo  can we do better here than silently ignoring the exception?
        }
      }
    }
  }

inline bool
boost_threaded_monitor::timed_wait(unsigned int sec, unsigned int nanos) {
	boost::xtime xtm = { sec, nanos };
	return cond_.timed_wait(lock_, xtm);
}