// mcs.h
#ifndef __MCS_H__
#define __MCS_H__
#include <windows.h>
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
struct mcs_node_t_
{
struct mcs_node_t_ **lock; // ptr to tail of queue
struct mcs_node_t_ *next; // ptr to successor in queue
HANDLE readyFlag; // set after lock is released by predecessor
HANDLE nextFlag; // set after 'next' ptr is set by successor
};
typedef struct mcs_node_t_ mcs_local_node_t;
typedef struct mcs_node_t_* mcs_lock_t;
void mcs_lock_acquire(mcs_lock_t *lock, mcs_local_node_t *node);
int mcs_lock_try_acquire(mcs_lock_t *lock, mcs_local_node_t *node);
void mcs_lock_release(mcs_local_node_t *node);
void mcs_node_transfer(mcs_local_node_t *new_node, mcs_local_node_t *old_node);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // !__MCS_H__
// mcs.c
#include "mcs.h"
#include <stdint.h>
inline void mcs_flag_set(HANDLE *flag)
{
HANDLE e = (HANDLE)(int64_t)InterlockedCompareExchange64((volatile int64_t *)flag, (int64_t)-1, (int64_t)0);
if (((HANDLE)(int)0 != e) && ((HANDLE)(int)-1 != e))
{
// 唤醒等待在e上的线程
SetEvent(e);
}
}
inline void mcs_flag_wait(HANDLE *flag)
{
if ((int64_t)0 == InterlockedExchangeAdd64((volatile int64_t *)flag, (int64_t)0))
{
HANDLE e = CreateEvent(NULL, FALSE, FALSE, NULL);
if (e)
{
if ((int64_t)0 == InterlockedCompareExchange64((volatile int64_t *)flag, (int64_t)e, (int64_t)0))
{
WaitForSingleObject(e, INFINITE);
}
CloseHandle(e);
}
}
}
/**
* 获取锁
* 先将lock的值赋值为node
* 返回值pred如果为NULL表示当前锁处于空闲状态, 加锁成功
* 不为NULL时表示有人使用, 更新pred->next
*
* 问题1:node->next == 0, 为什么不会切断链表
* 因为lock的值也在同步更新
* 假设三个线程同时调用, 线程1最先获取到锁, 线程2,3的node分别为node2, node3
*
* 当线程3调用mcs_lock_acquire时lock的值为node2, 所以是对node2操作, 更新lock的值为node3, 同时将node3插入到node2后面
* 此时链表为 node1->node2->node3
*/
void mcs_lock_acquire(mcs_lock_t *lock, mcs_local_node_t *node)
{
mcs_local_node_t *pred;
node->lock = lock;
node->nextFlag = 0;
node->readyFlag = 0;
node->next = 0;
pred = (mcs_local_node_t *)InterlockedExchangePointer((volatile PVOID *)lock, (PVOID)node);
if (0 != pred)
{
InterlockedExchangePointer(((volatile PVOID*)&pred->next), ((PVOID)node));
mcs_flag_set(&pred->nextFlag);
mcs_flag_wait(&node->readyFlag);
}
}
int mcs_lock_try_acquire(mcs_lock_t *lock, mcs_local_node_t *node)
{
node->lock = lock;
node->nextFlag = 0;
node->readyFlag = 0;
node->next = 0;
return ((PVOID)InterlockedCompareExchangePointer(((volatile PVOID*)lock), ((PVOID)node), ((PVOID)0)) == (PVOID)0) ? 0 : EBUSY;
}
/**
* 释放锁
*
* 1、获取当前节点的下一个等待节点
* 如果下一个节点为空,
* 如果lock == node表示当前只有自己使用锁, 直接返回
* 如果lock != node表示此时有人尝试获取锁并且已经修改了lock的值处于wait状态,所以需要更新next的值,调用mcs_flag_wait是等待pred->next更新完成
* 不为空时, 此时node == node1(因为node1获取到锁, 能继续往下调用mcs_lock_release),下一个节点就是node2
*
* 最后通知next, 解除线程阻塞
*/
void mcs_lock_release(mcs_local_node_t *node)
{
mcs_lock_t *lock = node->lock;
mcs_local_node_t *next =
(mcs_local_node_t *)InterlockedExchangeAdd64((((volatile int64_t*)&node->next)), (((int64_t)0)));
if (0 == next)
{
/* no known successor */
if (node == (mcs_local_node_t *)InterlockedCompareExchangePointer(((volatile PVOID*)lock), ((PVOID)0), ((PVOID)node)))
{
/* no successor, lock is free now */
return;
}
/* wait for successor */
mcs_flag_wait(&node->nextFlag);
next = (mcs_local_node_t *)
InterlockedExchangeAdd64((((volatile int64_t*)&node->next)), (((int64_t)0))); /* MBR fence */
}
else
{
/* Even if the next is non-0, the successor may still be trying to set the next flag on us, therefore we must wait. */
mcs_flag_wait(&node->nextFlag);
}
/* pass the lock */
mcs_flag_set(&next->readyFlag);
}
void mcs_node_transfer(mcs_local_node_t *new_node, mcs_local_node_t *old_node)
{
new_node->lock = old_node->lock;
new_node->nextFlag = 0;
new_node->readyFlag = 0;
new_node->next = 0;
if ((mcs_local_node_t *)InterlockedCompareExchangePointer(((volatile PVOID*)new_node->lock), ((PVOID)new_node), ((PVOID)old_node))
!= old_node)
{
while (0 == old_node->next)
{
Sleep(0);
}
mcs_flag_wait(&old_node->nextFlag);
new_node->next = old_node->next;
new_node->nextFlag = old_node->nextFlag;
}
}
// main.cpp
#include <iostream>
#include <thread>
#include "mcs.h"
using namespace std;
mcs_lock_t globalLock;
int64_t counter;
void work_thread()
{
while (true)
{
mcs_local_node_t node;
mcs_lock_acquire(&globalLock, &node);
if (counter > 1000 * 1000) {
mcs_lock_release(&node);
break;
}
++counter;
std::cout << GetCurrentThreadId() << ": " << counter << std::endl;
mcs_lock_release(&node);
Sleep(10);
}
}
int main()
{
std::thread thread(std::bind(work_thread));
while (true)
{
mcs_local_node_t node;
mcs_lock_acquire(&globalLock, &node);
if (counter > 1000 * 1000) {
mcs_lock_release(&node);
break;
}
++counter;
std::cout << GetCurrentThreadId() << ": " << counter << std::endl;
mcs_lock_release(&node);
Sleep(10);
}
thread.join();
return 0;
}
此代码移植自pthread-win32