2线程同步-C++11中的互斥锁

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提供的临界区代码，发现也有原子操作，进入内核态睡眠。在操作系统提供的功能下，两种方法是同级的，来自于不同产品的包装而已。