C11中mutex標頭檔案內容

Mutex

類，基本的互斥鎖

recursive_mutex

類， 同一執行緒可以遞迴呼叫的互斥鎖

timed_mutex

類，在指定的時間內能返回的鎖

recursive_timed_mutex

類，在指定的時間內能返回且同一執行緒能遞迴呼叫的鎖

adopt_lock_t

空結構體，用於控制unique_lock，lock_guard的處理策略（假定當前執行緒已經獲得互斥物件的所有權，所以不再請求鎖。）

例如：std::unique_lock<std::mutex> lck(mt, std:: adopt_lock);

defer_lock_t

空結構體，用於控制unique_lock 的處理策略（不請求鎖）

try_to_lock_t

空結構體，用於控制unique_lock 的處理策略（嘗試請求鎖，但不阻塞執行緒，鎖不可用時也會立即返回。）

lock_guard

建構函式自動加鎖，解構函式自動釋放鎖。

unique_lock

具備lock_guard的功能外，增加增加了解鎖，加鎖等功能。等於是更小粒度的資源控制。

swap

交換兩個互斥鎖

try_lock

嘗試同時鎖多個物件。

lock

同時鎖住多個鎖物件。

once_flag

結構體用於儲存函式呼叫記錄標誌。

call_once

保證函式只被呼叫一次，用once_flag當作記錄看是否已經被呼叫。

C11中的鎖在linux 平臺上的實現

就是對pthread_mutex物件的封裝，具備了pthread_mutex的所有特性。

C11中的鎖在win 平臺上的實現

是對臨界區的封裝嗎？ 答案是否定的。

通過對鎖函式上鎖的跟蹤發現如下程式碼：

boolcritical_section::_Acquire_lock(void * _PLockingNode,bool _FHasExternalNode)

{

LockQueueNode * pNewNode =reinterpret_cast<LockQueueNode*>(_PLockingNode);

LockQueueNode * pActiveNode =reinterpret_cast<LockQueueNode*>(&_M_activeNode);

if (pNewNode->m_pContext == pActiveNode->m_pContext)

{

throw improper_lock("Lock alreadytaken");

}

LockQueueNode * pPrevious =reinterpret_cast<LockQueueNode*>(InterlockedExchangePointer(&_M_pTail, pNewNode));

// 通過原子操作對指標進行判斷，看是否已經上鎖，NULL表示未上鎖

if (pPrevious == NULL)

{

_M_pHead = pNewNode;

pNewNode->UpdateQueuePosition(pActiveNode);

pNewNode->UnblockWithoutContext();

pNewNode->TryCompensateTimer();

}

else

{

pNewNode->UpdateQueuePosition(pPrevious);

pPrevious->m_pNextNode = pNewNode;

//  在下面的函式中去競爭鎖

 pNewNode->Block(pActiveNode->m_ticketState);

 if(pNewNode->m_trigger != TriggeredByTimeout)

{

pNewNode->UpdateQueuePosition(pActiveNode);

}

}

if (_FHasExternalNode)

{

pActiveNode->Copy(pNewNode);

_M_pHead = pNewNode;

}

returnpNewNode->m_trigger != TriggeredByTimeout;

}

我們繼續跟蹤競爭鎖的程式碼

void Block(unsignedint currentTicketState =0)

{

unsignedint numberOfProcessors =Concurrency::GetProcessorCount();

_CONCRT_ASSERT(numberOfProcessors> 0);

if (!IsPreviousBlocked())

{

unsignedint placeInLine =IsTicketValid() ? ((m_ticketState >> NumberOfBooleanStates) -(currentTicketState >> NumberOfBooleanStates)) : 1;

_CONCRT_ASSERT(placeInLine >0);

if (placeInLine <=numberOfProcessors + TicketThreshold)

{

constunsignedint defaultSpin =_SpinCount::_Value();

unsignedint totalSpin =defaultSpin + (defaultSpin * (placeInLine - 1)) / (numberOfProcessors +TicketThreshold);

_SpinWaitNoYield spinWait;

spinWait._SetSpinCount(totalSpin);

  // 在這邊開始自旋，自旋到一定次數後，跳出這個迴圈

while (IsBlocked() &&spinWait._SpinOnce())

{

}

}

}

//如果自旋完成後，依然得不到鎖，本執行緒進入這個函式後，陷入核心態開始睡眠

m_pContext->Block();

}

睡眠函式如下：

void ExternalContextBase::Block()

{

ASSERT(this ==SchedulerBase::FastCurrentContext());

TraceContextEvent(CONCRT_EVENT_BLOCK,TRACE_LEVEL_INFORMATION, m_pScheduler->Id(), m_id);

if(InterlockedIncrement(&m_contextSwitchingFence) == 1)

{

WaitForSingleObjectEx(m_hBlock,INFINITE, FALSE);

}

else

{

}

}

呼叫WaitForSingleObjectEx函式而進入核心態。

總結

C11鎖的原理就是先自旋，不能成功後，執行WaitForSingleObjectEx函式後進入核心態睡眠。

通過跟蹤windos提供的臨界區程式碼，發現也有原子操作，進入核心態睡眠。在作業系統提供的功能下，兩種方法是同級的，來自於不同產品的包裝而已。