尝试锁的源代码是什么？

所以我想我理解信号和等待的源代码（等待成为锁），但我不知道如何实现尝试锁。这里是我的等待代码：尝试锁的源代码是什么？

//if s->type is zero it is a binary semaphore type 
if (s->type == 0) 
    { 
      // binary semaphore 
      // if state is zero, then block task 

      if (s->state == 0) 
      { 
          // block task 


        // ?? move task from ready queue to blocked queue 

           //reschedule the tasks 
        return 1; 
      } 
      // state is non-zero (semaphore already signaled) 
      s->state = 0;    // reset state, and don't block 
      return 0; 
    } 
    else 
    { 
      // counting semaphore 
      s->state--; 
      // ?? implement counting semaphore 
      if (s->state < 0) 
      { 


      } 
    }

这是我迄今一试锁：

if (s->type == 0) 
{ 
      // binary semaphore 
      // if state is zero, then block task 

      if (s->state == 0) 
      { 
        tcb[curTask].event = s;   // block task 
        tcb[curTask].state = S_BLOCKED; 

        removeNode(tcb[curTask].priority, READY_QUEUE, curTask); 
        enqueue(tcb[curTask].priority, curTask, BLOCKED_QUEUE); 
        return 1; 
      } 
      // state is non-zero (semaphore already signaled) 
      s->state = 1;           // reset state, and don't block 
      return 0; 
} 
else 
{ 
     s->state--; 
     if (s->state >= 0) 
     { 
      s->state++; 
     } 
     else 
     { 
      tcb[curTask].event = s; 
      tcb[curTask].state = S_BLOCKED; 
      removeNode(tcb[curTask].priority, READY_QUEUE, curTask); 
      enqueue(tcb[curTask].priority, curTask, BLOCKED_QUEUE); 
     } 
}

来源

2012-10-13 Will

尝试锁定信号量，如果它已被其他进程锁定，则立即返回（非阻塞）并返回一些错误代码。 – SparKot

我一直在寻找一个非自旋锁的tryLock。我已经想出了要做什么。如果它是一个计数信号量，那么如果计数是正数并且我消耗资源，那么我递减。如果它是零或更少，我什么也不做，只是返回一个错误代码。我不减少数量或消耗资源。该程序然后能够继续超过这一点。如果它是一个二进制信号量，如果资源可用，则将其消耗。然后我将二进制信号量的值改为消耗。如果它不可用，那么我返回一个错误代码。

来源

2012-10-15 18:55:05 Will

定期自旋锁来实现这样的（伪C-codish ）：

void lock(locktype_t* LockVariable) 
{ 
    while (CompareAndSwap(LockVariable, 
         STATE_UNLOCKED /* state to wait for */, 
         STATE_LOCKED /* new state to try to set */) != 
     STATE_UNLOCKED /* expected state at the beginning of CAS() */) 
    { 
    // spin here, doing nothing useful, waiting for *LockVariable to 
    // first become STATE_UNLOCKED (CAS() returns its last value), after 
    // which we will set it to STATE_LOCKED (CAS() will do that atomically) 
    } 
} 

void unlock(locktype_t* LockVariable) 
{ 
    *LockVariable = STATE_UNLOCKED; 
}

在不定纺丝和等待锁成为第一解锁是不希望的情况下，我们使用上述这样的一个环路较少的变体：

int tryToLock(locktype_t* LockVariable) 
{ 
    if (CompareAndSwap(LockVariable, 
        STATE_UNLOCKED /* state to wait for */, 
        STATE_LOCKED /* new state to try to set */) != 
     STATE_UNLOCKED /* expected state at the beginning of CAS() */) 
    { 
    return 0; // the lock is still held by someone else, bail out 
    } 
    return 1; // the lock is now held by us, hurray! 
}

Compare-and-swap

来源

2012-10-14 03:41:46

'如果（AtomicSwap（LockVariable，STATE_LOCKED）== STATE_LOCKED）返回0;'工作呢？ – a3f

回答我自己的问题：你会的。 [这个答案]（http://stackoverflow.com/questions/5339769/relative-performance-of-swap-vs-compare-and-swap-locks-on-x86）可能是相关的。 – a3f

尝试锁的源代码是什么？

回答

相关问题