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

最新推荐文章于 2024-07-18 15:24:34 发布
最新推荐文章于 2024-07-18 15:24:34 发布
阅读量822 收藏
点赞数
分类专栏： 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
关注
专栏目录
面包店算法-解决多进程同步问题
08-05 2203
它是一种实现多进程互斥的软件算法。 该算法的基本思想源于顾客在面包店中购买面包时的排队原理. 顾客在进入面包店前, 首先抓一个号, 然后按照号码由小到大的次序依次进入面包店购买面包. 这里, 面包店发放的号码是由小到大的, 但是两个或两个以上的顾客却有可能得到相同的号码(使所抓
算法设计与应用1-1 互斥算法
星野时雨
09-09 986
目录Chap 11.1互斥算法进程vs线程原子操作非原子操作期间的线程交换更新丟失临界区代码 Critical Sections of Code互斥算法的软件方法互斥算法Dekker的算法：单标志法皮特森算法/Peterson Algorithm兰波特面包店算法/ Lamport's Bakery Algorithm互斥锁算法的硬件辅助线程旋转、阻塞和等待更多reference Chap 1 1.1互斥算法 进程vs线程 计算机需要能够同时执行多个任务 可以并行执行，也可以在执行过程中反复切换任务，或者两
面包店算法
不是码农
09-12 5830
转自维基百科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]。 [编辑] 类比算法 [编
Lamport Bakery算法
最新发布
weixin_44514957的博客
07-18 291
【代码】Lamport Bakery算法。
lamport面包店算法简介
weixin_33796177的博客
09-07 477
序 Lamport面包店算法是解决多个线程并发访问一个共享的单用户资源的互斥问题的算法。由莱斯利·兰波特发明。 算法类比 Lamport把这个并发控制算法非常直观地类比为顾客去面包店采购。 面包店一次只能接待一位顾客的采购。 已知有n位顾客要进入面包店采购，按照次序安排他们在前台登记一个签到号码。该签到号码逐次增加1。 顾客根据签到号码...
Lamport面包店算法
等鱼煎的博客
09-28 795
Lamport面包店算法是解决多个线程并发访问一个共享的单用户资源的互斥问题的算法。 由Leslie Lamport发明[1]。 目录    [隐藏]  1 算法 1.1 类比1.2 进入临界区1.3 非临界区 2 算法实现 2.1 定义2.2 伪代码2.3 讨论 3 参见4 外部链接5 参考文献 算法[编辑] 类比[编辑]
C语言实现的基于Lamport面包店算法的无等待互斥锁.zip
06-15
这些数据结构在C语言中都有相应的实现方式，可以应用于各种不同的场景。C语言中的各种数据结构都有其优缺点，下面列举一些常见的数据结构的优缺点： 数组： 优点：访问和修改元素的速度非常快，适用于需要频繁读取...
93-教学课件-Lamport面包房算法（N进程）1
08-04
Lamport 面包房算法的优点是可以解决 N 进程互斥问题，并且该算法满足临界区问题的解需要满足的三个条件：互斥、无饥饿、无死锁。 互斥是指在临界区中最多只能有一个进程。无饥饿是指每个进程最终都会进入临界区。...
操作系统学习笔记——第四章 互斥、同步与通讯
qq_44290978的博客
04-04 2748
文章目录并发进程前驱图程序的顺序执行顺序程序特性并发程序特性程序并发执行的条件读集与写集Bernstein条件与时间有关的错误进程互斥共享变量临界区域共享变量和临界区域的表示进程互斥的定义实现互斥的要求调度原则软件实现petersom算法Dekkel算法Lamport面包店算法Eisenberg/Mcguire算法进程互斥的硬件实现硬件提供“测试并建立”指令（test_and_set)硬件提供“交...
操作系统——临界区对信号量保护的实现
m0_56561130的博客
08-17 776
一、临界区的引出 从上一篇文章中，我们了解到了信号量的概念。信号量的数值表达的语义用来控制进程的走和停，因此，信号量的数值是非常重要的，信号量的数值吧必须和信号量的语义相一致，才能正确地决定进程的同步。比如信号量的数值为0，但此时实际上有一个进程阻塞在该信号量，那么即使对该信号量执行V操作也不会唤醒被阻塞的进程。 但是信号量是一个会被多个进程操作的共享变量，各个并发进程竞争使用CPU会导致各种各样的调度问题，部分调度顺序可能会导致信号量出现语义错误。 以生产者——消费者问题为例，初始情况empty
lamport-distributed-lock:Lamport分布式锁的基本实现，用于学习
04-15
Lamport的分布式锁 Lamport在提出的分布式互斥锁的基本实现 设置 安装ZeroMQ： ://zeromq.org/download/ 运行： make 运行测试 ./runtest.sh
lamport面包店算法详细讲解及代码实现
qq_46419229的博客
11-06 6776
lamport面包店算法详细讲解及代码实现1 算法详解1.1 一个较为直观的解释1.2 Lamport算法的时间戳原理1.3 Lamp算法的5个原则1.4 一个小栗子2 算法实现功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1
进程互斥软件算法(Lamport面包店算法和Eisenberg算法)
12-01 7678
实现进程互斥的软件的结构框架是： Framework          Repeat                    entry section                    critical section                    exit section                    remainder section          Unt
BAKERY'S ALGORITHM(面包店算法)
12-01 7223
BAKERY'S ALGORITHM所用到的数据结构有： choosing[0..n]=flase; number[0..n]=0; ---------------------------------------------- choosing =true;/*进程Pi 开始选号码*/ number =max{number[0],number[1],..number[n-1]}+1;
面包店算法c语言,面包店算法
weixin_39706127的博客
05-25 735
Lamport面包店算法是解决多个线程并发访问一个共享的单用户资源的互斥问题的算法。 由[编辑]类比算法[编辑]Lamport把这个并发控制算法可以非常直观地类比为顾客去面包店采购。面包店只能接待一位顾客的采购。已知有n位顾客要进入面包店采购，安排他们按照次序在前台登记一个签到号码。该签到号码逐次加1。根据签到号码的由小到大的顺序依次入店购货。完成购买的顾客在前台把其签到号码归0. 如果完成购买的...
Lamport面包店算法详解
等鱼煎的博客
09-28 8915
范例1： boolean  choosing[n];表示进程是否在取号 int  number[n];记录每个进程取到的号码 这些数据结构分别初始化为false和0，为了方便，定义如下符号： 若a do {     　　　　　　　　　 　 choosing[i] = true; 　 number[i] = max{number[0],number[1],…,n
面包店算法带有代码的详细讲解
somemoods的博客
03-25 2035
适合新手，或者仍不清晰的读者来看
python-面包店算法实现多线程锁
gaixm的专栏
05-17 408
#coding: UTF-8 import threading import time import random # 面包店算法实现线程锁 # 争夺的资源 incNum = 0 class BakeryLock: def __init__(self, threadCount): # 取得的号码 self.number = [0 for _ in range(threadCount)] # 是否正在取号 self.enterin.
分布式锁(逻辑时钟)原理 Leslie Lamport论文笔记
JKerving的博客
10-24 2375
分布式系统中的时间、时钟和事件顺序 论文笔记 这篇笔记主要是用于记录阅读《Time, Clocks, and the Ordering of Events in a Distributed System》论文的要点以及我自己对于分布式系统时钟的理解。之前已经阅读过这篇文章几次了，每次阅读都对自己很有帮助。因此写下这篇论文笔记可以帮助自己进一步加深理解。 1978年Lamport在这篇论文中主要讨论...
Lamport算法实现ClockSync分布式时钟同步系统
这种同步算法基于局部时钟的概念，不依赖于物理时间，而是利用事件间的因果关系来维护时钟的一致性。具体来说，Lamport时钟是通过在分布式系统中的每个节点上维护一个递增的逻辑时钟值来工作的。每当一个节点上的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值