基于Lamport面包店算法实现的无等待互斥锁

最新推荐文章于 2022-04-13 15:34:56 发布
最新推荐文章于 2022-04-13 15:34:56 发布
阅读量659 收藏
点赞数
分类专栏： clang 算法 文章标签： 算法 clang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jdh99/article/details/115689250
版权
算法 同时被 2 个专栏收录
27 篇文章 1 订阅
订阅专栏
clang
13 篇文章 0 订阅
订阅专栏

文章目录

基于Lamport面包店算法实现的无等待互斥锁

本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.

介绍

C语言实现的基于Lamport面包店算法的无等待互斥锁。可用于没有提供锁的系统，比如无RTOS的单片机中。

开源

API

// NWLCreate 创建锁
// total: 使用此锁的最大用户数量
// 返回锁的句柄.如果是0表示创建失败
intptr_t NWLCreate(int total);

// NWLDelete 删除锁
void NWLDelete(intptr_t handle);

// NWLLock 上锁.如果返回false表示上锁失败.上锁成功后必须要解锁
bool NWLLock(intptr_t handle, int id);

// NWLUnlock 解锁.必须上锁成功后才能解锁
void NWLUnlock(intptr_t handle, int id);

测试用例

windows下创建若干线程，按顺序打印数据。

#include <stdio.h>
#include <winsock2.h>
#include <process.h>
#include <windows.h>
#include <time.h>

#include "nowaitlock.h"

#pragma comment(lib,"ws2_32.lib")

#define MAX_THREAD_NUM 5

// 锁及保护的资源
static intptr_t lock;
// 顺序控制字
static int seq = 0;

static void case1(void);

static void case2(void);
static DWORD WINAPI thread(LPVOID lpParam);

int main() {
    case2();
    return 0;
}

static void case1(void) {
    intptr_t lock = NWLCreate(3);

    // 本轮应该0获取锁成功
    printf("---------->0\n");
    printf("0:%d\n", NWLLock(lock, 0));
    printf("1:%d\n", NWLLock(lock, 1));
    printf("2:%d\n", NWLLock(lock, 2));
    NWLUnlock(lock, 0);

    // 本轮应该0获取锁成功
    printf("---------->0\n");
    printf("0:%d\n", NWLLock(lock, 0));
    printf("1:%d\n", NWLLock(lock, 1));
    printf("2:%d\n", NWLLock(lock, 2));
    NWLUnlock(lock, 0);

    // 本轮应该1获取锁成功
    printf("---------->1\n");
    printf("1:%d\n", NWLLock(lock, 1));
    printf("0:%d\n", NWLLock(lock, 0));
    printf("2:%d\n", NWLLock(lock, 2));
    NWLUnlock(lock, 1);

    // 本轮应该2获取锁成功
    printf("---------->2\n");
    printf("2:%d\n", NWLLock(lock, 2));
    printf("0:%d\n", NWLLock(lock, 0));
    printf("1:%d\n", NWLLock(lock, 1));
    NWLUnlock(lock, 2);

    NWLDelete(lock);
}

static void case2(void) {
    lock = NWLCreate(MAX_THREAD_NUM);

    int a[MAX_THREAD_NUM] = {0};
    for (int i = 0; i < MAX_THREAD_NUM; i++) {
        a[i] = i;
        CreateThread(NULL, 0, thread, &a[i], 0, NULL);
    }
    while(1) {}
}

static DWORD WINAPI thread(LPVOID lpParam) {
    int id = *(int*)lpParam;

    printf("id:%d thread run\n", id);
    Sleep(1000);

    while (1) {
        if (NWLLock(lock, id) == false) {
            Sleep(0);
            continue;
        }

        printf("id:%d start\n", id);
        if (seq % MAX_THREAD_NUM == id) {
            seq++;
            printf("----->id:%d seq:%d\n", id, seq);
        }
        if (seq >= 20) {
            printf("id:%d exit\n", id);
            NWLUnlock(lock, id);
            break;
        }
        printf("id:%d stop\n", id);

        NWLUnlock(lock, id);
        Sleep(0);
    }
    return 0;
}

输出：

id:0 thread run
id:1 thread run
id:2 thread run
id:3 thread run
id:4 thread run
id:4 start
id:4 stop
id:0 start
----->id:0 seq:1
id:0 stop
id:2 start
id:2 stop
id:0 start
id:0 stop
id:1 start
----->id:1 seq:2
id:1 stop
id:2 start
----->id:2 seq:3
id:2 stop
id:1 start
id:1 stop
id:3 start
----->id:3 seq:4
id:3 stop
id:2 start
id:2 stop
id:4 start
----->id:4 seq:5
id:4 stop
id:0 start
----->id:0 seq:6
id:0 stop
id:1 start
----->id:1 seq:7
id:1 stop
id:2 start
----->id:2 seq:8
id:2 stop
id:0 start
id:0 stop
id:3 start
----->id:3 seq:9
id:3 stop
id:2 start
id:2 stop
id:3 start
id:3 stop
id:1 start
id:1 stop
id:4 start
----->id:4 seq:10
id:4 stop
id:0 start
----->id:0 seq:11
id:0 stop
id:1 start
----->id:1 seq:12
id:1 stop
id:2 start
----->id:2 seq:13
id:2 stop
id:1 start
id:1 stop
id:2 start
id:2 stop
id:1 start
id:1 stop
id:2 start
id:2 stop
id:4 start
id:4 stop
id:0 start
id:0 stop
id:4 start
id:4 stop
id:2 start
id:2 stop
id:3 start
----->id:3 seq:14
id:3 stop
id:4 start
----->id:4 seq:15
id:4 stop
id:2 start
id:2 stop
id:2 start
id:2 stop
id:4 start
id:4 stop
id:1 start
id:1 stop
id:1 start
id:1 stop
id:2 start
id:2 stop
id:3 start
id:3 stop
id:2 start
id:2 stop
id:3 start
id:3 stop
id:1 start
id:1 stop
id:3 start
id:3 stop
id:3 start
id:3 stop
id:3 start
id:3 stop
id:4 start
id:4 stop
id:1 start
id:1 stop
id:2 start
id:2 stop
id:2 start
id:2 stop
id:4 start
id:4 stop
id:0 start
----->id:0 seq:16
id:0 stop
id:2 start
id:2 stop
id:3 start
id:3 stop
id:0 start
id:0 stop
id:1 start
----->id:1 seq:17
id:1 stop
id:0 start
id:0 stop
id:3 start
id:3 stop
id:2 start
----->id:2 seq:18
id:2 stop
id:0 start
id:0 stop
id:3 start
----->id:3 seq:19
id:3 stop
id:4 start
----->id:4 seq:20
id:4 exit
id:2 start
id:2 exit
id:1 start
id:1 exit
id:0 start
----->id:0 seq:21
id:0 exit
id:3 start
id:3 exit

源码

最新源码请查看github或者gitee仓库。

nowaitlock.h

// Copyright 2021-2021 The jdh99 Authors. All rights reserved.
// 无等待锁.应用Lamport面包店算法
// Authors: jdh99 <jdh821@163.com>

#ifndef NOWAITLOCK_H
#define NOWAITLOCK_H

#include <stdint.h>
#include <stdbool.h>

// NWLCreate 创建锁
// total: 使用此锁的最大用户数量
// 返回锁的句柄.如果是0表示创建失败
intptr_t NWLCreate(int total);

// NWLDelete 删除锁
void NWLDelete(intptr_t handle);

// NWLLock 上锁.如果返回false表示上锁失败.上锁成功后必须要解锁
bool NWLLock(intptr_t handle, int id);

// NWLUnlock 解锁.必须上锁成功后才能解锁
void NWLUnlock(intptr_t handle, int id);

#endif

nowaitlock.c

// Copyright 2021-2021 The jdh99 Authors. All rights reserved.
// 无等待锁.应用Lamport面包店算法
// Authors: jdh99 <jdh821@163.com>

#include "nowaitlock.h"
#include <stdlib.h>
#include <string.h>

#pragma pack(1)

typedef struct {
    bool* entering;
    int* number;
    // 线程数量
    int total;
} tLock;

#pragma pack()

static int max(tLock* lock);

// NWLCreate 创建锁
// total: 使用此锁的最大用户数量
// 返回锁的句柄.如果是0表示创建失败
intptr_t NWLCreate(int total) {
    tLock* lock = (tLock*)malloc(sizeof(tLock));
    if (lock == NULL) {
        return 0;
    }
    memset(lock, 0, sizeof(tLock));

    lock->entering = malloc(sizeof(bool) * (uint64_t)total);
    if (lock->entering == NULL) {
        free(lock);
        return 0;
    }
    memset(lock->entering, 0, sizeof(bool) * (uint64_t)total);

    lock->number = malloc(sizeof(int) * (uint64_t)total);
    if (lock->number == NULL) {
        free(lock);
        return 0;
    }
    memset(lock->number, 0, sizeof(int) * (uint64_t)total);

    lock->total = total;
    return (intptr_t)lock;
}

// NWLDelete 删除锁
void NWLDelete(intptr_t handle) {
    if (handle == 0) {
        return;
    }
    tLock* lock = (tLock*)malloc(sizeof(tLock));
    free(lock->entering);
    free(lock->number);
    free(lock);
}

// NWLLock 上锁.如果返回false表示上锁失败.上锁成功后必须要解锁
bool NWLLock(intptr_t handle, int id) {
    tLock* lock = (tLock*)(handle);

    if (lock->number[id] == 0) {
        lock->entering[id] = true;
        lock->number[id] = 1 + max(lock);
        lock->entering[id] = false;
    }

    for (int j = 0; j < lock->total; j++) {
        if (lock->entering[j]) {
            lock->number[id] = 0;
            return false;
        }
        if (lock->number[j] != 0 &&
            (lock->number[j] < lock->number[id] || (lock->number[j] == lock->number[id] && j < id))) {
            lock->number[id] = 0;
            return false;
        }
    }
    return true;
}

static int max(tLock* lock) {
    int max = lock->number[0];
    for (int i = 1; i < lock->total; i++) {
        if (lock->number[i] > max) {
            max = lock->number[i];
        }
    }
    return max;
}

// NWLUnlock 解锁.必须上锁成功后才能解锁
void NWLUnlock(intptr_t handle, int id) {
    tLock* lock = (tLock*)(handle);
    lock->number[id] = 0;
}
jdh99
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lamport面包店算法详细讲解及代码实现
qq_46419229的博客
11-06 5675
lamport面包店算法详细讲解及代码实现1 算法详解1.1 一个较为直观的解释1.2 Lamport算法的时间戳原理1.3 Lamp算法的5个原则1.4 一个小栗子2 算法实现功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1
面包店算法带有代码的详细讲解
somemoods的博客
03-25 1875
适合新手，或者仍不清晰的读者来看
Lamport面包店算法详解
等鱼煎的博客
09-28 8740
范例1： boolean  choosing[n];表示进程是否在取号 int  number[n];记录每个进程取到的号码 这些数据结构分别初始化为false和0，为了方便，定义如下符号： 若a do {     　　　　　　　　　 　 choosing[i] = true; 　 number[i] = max{number[0],number[1],…,n
进程互斥软件算法(Lamport面包店算法和Eisenberg算法)
12-01 7589
实现进程互斥的软件的结构框架是： Framework          Repeat                    entry section                    critical section                    exit section                    remainder section          Unt
面包店算法
不是码农
09-12 5729
转自维基百科http://zh.wikipedia.org/wiki/Lamport%E9%9D%A2%E5%8C%85%E5%BA%97%E7%AE%97%E6%B3%95 Lamport面包店算法是解决多个线程并发访问一个共享的单用户资源的互斥问题的算法。 由Leslie Lamport（英语：Leslie Lamport）发明[1]。 [编辑] 类比算法 [编
93-教学课件-Lamport面包房算法（N进程）1
08-04
93-教学课件-Lamport面包房算法（N进程）1
Lamport 向量时钟算法的 C++ 实现
06-08
Lamport 向量时钟算法的 C++ 实现 矢量时钟是一种算法，用于在分布式系统中生成事件的部分排序并检测因果关系违规。就像在 Lamport 时间戳中一样，进程间消息包含发送进程的逻辑时钟的状态。N个进程系统的向量时钟...
基于软件互斥算法的临界区进程互斥的模拟实现
11-20
操作系统的实验课设，实现Dekker，Lamport，Peterson，Eisenberg进程互斥访问临界区算法，使用java语言完成，可以动态显示进程访问临界区时各个进程的状态
Linux下模拟软件互斥实现算法
09-07
在Linux下，模拟实现四种软件互斥算法：Dekker,Peterson,Lamport,Eisenburg-Mcguire.
lamport-distributed-lock:Lamport分布式锁的基本实现，用于学习
04-15
Lamport的分布式锁 Lamport在提出的分布式互斥锁的基本实现 设置 安装ZeroMQ： ://zeromq.org/download/ 运行： make 运行测试 ./runtest.sh
忙等待锁和无忙等待锁
暴龙兽超进化的博客
04-13 676
锁的类型 根据锁的实现不同，可以分为忙等待锁和无忙等待锁。 （1）忙等待锁 忙等待锁就是当获取不到锁资时，线程就会一直 while 循环，不做任何事情，所以就被成为忙等待锁，也被称为自旋锁。 （2）无忙等待锁 无忙等待锁就是当获取不到锁资源时，线程不用自旋，而是把当前线程放入到锁的等待队列，然后执行调度程度，把CPU让给其他线程执行。 ...
面包店算法-解决多进程同步问题
08-05 2148
它是一种实现多进程互斥的软件算法。 该算法的基本思想源于顾客在面包店中购买面包时的排队原理. 顾客在进入面包店前, 首先抓一个号, 然后按照号码由小到大的次序依次进入面包店购买面包. 这里, 面包店发放的号码是由小到大的, 但是两个或两个以上的顾客却有可能得到相同的号码(使所抓
Lamport面包店算法
等鱼煎的博客
09-28 748
Lamport面包店算法是解决多个线程并发访问一个共享的单用户资源的互斥问题的算法。 由Leslie Lamport发明[1]。 目录    [隐藏]  1 算法 1.1 类比1.2 进入临界区1.3 非临界区 2 算法实现 2.1 定义2.2 伪代码2.3 讨论 3 参见4 外部链接5 参考文献 算法[编辑] 类比[编辑]
面包店算法c语言,面包店算法
weixin_39706127的博客
05-25 677
Lamport面包店算法是解决多个线程并发访问一个共享的单用户资源的互斥问题的算法。 由[编辑]类比算法[编辑]Lamport把这个并发控制算法可以非常直观地类比为顾客去面包店采购。面包店只能接待一位顾客的采购。已知有n位顾客要进入面包店采购，安排他们按照次序在前台登记一个签到号码。该签到号码逐次加1。根据签到号码的由小到大的顺序依次入店购货。完成购买的顾客在前台把其签到号码归0. 如果完成购买的...
锁的作用，类型以及死锁
qq_34771156的博客
07-09 606
为什么需要锁 我们知道线程是可以共享进程的资源的，当多个进程同时使用同一个资源的时候，就会发生问题，下图展示了两个线程对同一个变量进行加法运算时的情况，理想状态下。A线程对i=50进行加+1后i=51，之后cpu切换线程B继续进行加1运算，此时i=52。但程序在实际运行中可能会出现错误，如下图： 当多线程相互竞争操作共享变量时，由于运气不好，即在执行过程中发生了上下文切换，我们得到了错误的结果，称之为竞争。操作共享资源的发代码成为临界区，为了解决竞争问题，我们可以让临界区互斥，也就是...
mysql no wait_MySQL 8.0新特性 -- nowait以及skip locked
weixin_36061828的博客
01-27 993
如果某行记录被事务锁住了，select ... for update、或select ... for share事务对相同的行加锁的时候必须等待，直到产生阻塞的事务释放锁。为了避免等待事务释放锁定的行，nowait和skip locked选项可以被用于select ... for update或select ... for share语句：·nowait：使用了nowait选项的锁定读操作，会立即...
操作系统__锁（Lock）的几种简单实现方式
AlexanderGan的博客
05-22 3611
操作系统__锁（Lock）的几种简单实现方式 （1）无锁访问共享资源带来的问题 阅读上面的代码可以预计，g_count的预期输出结果是2000，下面我们看看实际的结果： 实际运行结果中间出现了1057， 说明对于共享资源的并发访问会导致结果与预期不一致，这是为什么呢？ 实际上g_count = g_count + 1 这个操作并不是原子操作。 上图解释了为什么会出现这种情况，两个线程都各自执行完了一次循环，我们设想g_count的值会加2，但是实际上只加了1，所以会导致我们看到./lockTest的执
多线程互斥锁访问算法（下）------Lamport算法(面包店算法)
风筝
11-08 4162
你好！这里是风筝的博客，欢迎和我一起交流。Lamport面包店算法是解决多个线程并发访问一个共享的单用户资源的互斥问题的算法。 由Leslie Lamport发明。Lamport把这个并发控制算法可以非常直观地类比为顾客去面包店采购： 已知有n位顾客要进入面包店采购，安排他们按照次序在前台登记一个签到号码。该签到号码逐次加1。 根据签到号码的由小到大的顺序依次入店购货。 完成购买的顾客在前台把
lamport面包店算法简介
weixin_33796177的博客
09-07 441
序 Lamport面包店算法是解决多个线程并发访问一个共享的单用户资源的互斥问题的算法。由莱斯利·兰波特发明。 算法类比 Lamport把这个并发控制算法非常直观地类比为顾客去面包店采购。 面包店一次只能接待一位顾客的采购。 已知有n位顾客要进入面包店采购，按照次序安排他们在前台登记一个签到号码。该签到号码逐次增加1。 顾客根据签到号码...
lamport时钟算法
最新发布
08-03
Lamport时钟算法是一种用于分布式系统中的逻辑时钟算法，由著名计算机科学家Leslie Lamport提出。它通过引入逻辑时钟的概念，实现了对分布式系统中事件的有序性和并发性的控制。 Lamport时钟由一个全局逻辑时钟和一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值