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

void SC_LanguageClient::tick(){    if (trylock()) {		if (isLibraryCompiled()) {			::runLibrary(s_tick);		}		unlock();    }    flush();}

	bool Conditional::isLocked()	{		try {			trylock();			leave();			return false;		} catch (const ibrcommon::MutexException&) {			return true;		}	}

bool PIpcBuffer::trylock2(){	if (!isValid())		return false;	PIpcBufferHeader* h = (PIpcBufferHeader*) m_data;	pthread_mutex_t* mutex2 = &h->mutex2;	return trylock(mutex2, m_lockCount2);}

inlinevoidConsumer::consume(unsigned D){  /**   * This is the equivalent of do_send(must_send = 1)   */  m_force_send = 1;  do  {    if (trylock(&m_send_lock) != 0)    {      /* Other thread will send for us as we set m_force_send. */      return;    }    /**     * Now clear the flag, and start sending all data available to this node.     *     * Put a memory barrier here, so that if another thread tries to grab     * the send lock but fails due to us holding it here, we either     * 1) Will see m_force_send[nodeId] set to 1 at the end of the loop, or     * 2) We clear here the flag just set by the other thread, but then we     * will (thanks to mb()) be able to see and send all of the data already     * in the first send iteration.     */    m_force_send = 0;    mb();    /**     * This is the equivalent of link_thread_send_buffers     */    for (unsigned i = 0; i < cnt_threads; i++)    {      val[i] = rep.t[i].t.p.val[D];    }    /**     * Do a syscall...which could have affect on barriers...etc     */    if (DO_SYSCALL)    {      NdbTick_getCurrentTicks();    }    unlock(&m_send_lock);#if BUGGY_VERSION#else    mb();#endif  }  while (m_force_send != 0);}

void Thread::run(){  // The idea here is that if another thread locks this thread, that this loop  // should terminate, thus terminating the execution of this thread.  while(trylock())  {    m_runner->run();    sleep(1);    unlock();  }}

// Called by RT control loop to send oob datavoid EthercatOobCom::tx(){  if (!trylock(__LINE__))    return;  if (state_ == READY_TO_SEND) {    // Packet is in need of being sent    assert(frame_!=NULL);    handle_ = ni_->tx(frame_, ni_);    state_ = WAITING_TO_RECV;    pthread_cond_signal(&busy_cond_);  }   unlock(__LINE__);  }

/* Convenience method */Mutex::TRY_LOCK_STATUS_TMutex::trylock ( const char * theErrorLocation ){    Mutex::TRY_LOCK_STATUS_T returnValue = trylock();    if ( returnValue == Mutex::FAILURE )    {        if ( theErrorLocation == (const char *) NULL )            theErrorLocation = "";        FLUSHALL();        cerr << "[" << theErrorLocation << "]  Error:  "             << "Problems while trylock()'ing mutex." << endl;    }    return returnValue;}

//----------------------------------------------------------------------------// only allow one thread to execute any of these methods at a time//----------------------------------------------------------------------------inline int boost::stm::transaction::dir_tx_conflicting_lock_pthread_trylock_mutex(Mutex *mutex){   //--------------------------------------------------------------------------   throw "might not be possible to implement trylock for this";   bool txIsIrrevocable = false;   int val = trylock(mutex);   if (0 != val) return val;   lock(&latmMutex_);   if (transaction* t = get_inflight_tx_of_same_thread(false))   {      txIsIrrevocable = true;      t->must_be_in_conflicting_lock_set(mutex);      t->make_irrevocable();      t->add_to_obtained_locks(mutex);    }   try    {       //-----------------------------------------------------------------------      // if !core done, since trylock, we cannot stall & retry - just exit      //-----------------------------------------------------------------------      if (!dir_do_core_tx_conflicting_lock_pthread_lock_mutex(mutex, 0, 0, txIsIrrevocable))       {         unlock(mutex);         unlock(&latmMutex_);         return -1;      }   }   catch (...)   {      unlock(mutex);      unlock(&latmMutex_);      throw;   }   latmLockedLocksOfThreadMap_[mutex] = THREAD_ID;   unlock(&latmMutex_);   // note: we do not release the transactionsInFlightMutex - this will prevents    // new transactions from starting until this lock is released   return 0;}

  bool timedlock(int64_t milliseconds) const {#if defined(_POSIX_TIMEOUTS) && _POSIX_TIMEOUTS >= 200112L    PROFILE_MUTEX_START_LOCK();    struct timespec ts;    Util::toTimespec(ts, milliseconds);    int ret = pthread_mutex_timedlock(&pthread_mutex_, &ts);    if (ret == 0) {      PROFILE_MUTEX_LOCKED();      return true;    }    PROFILE_MUTEX_NOT_LOCKED();    return false;#else    // If pthread_mutex_timedlock isn't supported, the safest thing to do    // is just do a nonblocking trylock.    return trylock();#endif  }

/* THREAD: RT */intEngine::process ( nframes_t nframes ){    /* FIXME: wrong place for this */    _thread.set( "RT" );    if ( ! trylock() )    {        /* the data structures we need to access here (tracks and         * their ports, but not track contents) may be in an         * inconsistent state at the moment. Just punt and drop this         * buffer. */        ++_buffers_dropped;        return 0;    }    _process_callback(nframes, _process_callback_user_data);    unlock();    return 0;}

BOOLEANMutex::isLocked(){    Mutex::TRY_LOCK_STATUS_T  tryLockStatus;    switch ( tryLockStatus = trylock() )    {    case Mutex::SUCCESS:        /* We just locked ourself.  If unlock fails... *         * Well, we are locked...  And probably hosed. */        switch ( unlock() )        {        case ::SUCCESS:            return FALSE;        /* If this happens, something truly odd is going on... */        case ::FAILURE:        default:            FLUSHALL();            cerr << "[Mutex:isLocked]  Internal Failure:  "                 << "trylock() returned SUCCESS.   unlock() returned FAILURE.  "                 << "(So we've just locked the mutex.)" << endl;            return TRUE;        }    case Mutex::FAILURE:        return FALSE;    case Mutex::ALREADY_LOCKED:        return TRUE;    default:        FLUSHALL();        cerr << "[Mutex:isLocked]  Impossible Error: tryLock() returned: "             << int4(tryLockStatus) << ".  Assuming we are locked..." << endl;        return TRUE; /* Worst case scenario: Assume we are locked. */    }}

static int pipe_read(struct mill_pipe_s *mp, void *ptr) {    unsigned size = mp->sz;    int n, total = 0;    while (1) {        if (trylock(mp)) {again:            n = (int) read(mp->fd[0], (char *) ptr + total, size - total);            if (mill_slow(n == 0)) {                /* done */                mill_assert(total == 0);                unlock(mp);                return 0;            }            if (n > 0) {                total += n;                if (mill_fast(total == size)) {                    unlock(mp);                    return total;                }                goto again;            }            /* n == -1 */            if (errno == EINTR)                goto again;            if (errno == EAGAIN) {                mill_fdevent(mp->fd[0], FDW_IN, -1);                goto again;            }            unlock(mp);            break;        }        mill_fdevent(mp->fd[0], FDW_IN, -1);        /* Multiple threads may receive notification. Race for the lock. */    }    return -1;}

static int trylock1() {	return trylock(std::multimap<std::wstring, unsigned long long int>());}

void lock(struct lock* m) {#if SYNC	task_loop(trylock(m) == -1);#endif}