《操作系统真象还原》第十章（一） —— 同步机制之互斥锁的实现

news/2024/12/26 3:54:48/

本章节所有代码托管在miniOS_32

章节任务介绍

问题复现

在上一节中，我们实现了线程轮转调度，并分别实现了三个线程并发的在终端进行输出打印

  • 主线程

  • thread_work_a

  • thread_work_b

#include "print.h"
#include "init.h"
#include "thread.h"
#include "interrupt.h"
void thread_work_a(void *arg);
void thread_work_b(void *arg);int main(void)
{put_str("I am kernel\n");init_all();thread_start("thread_work_a", 31, thread_work_a, "pthread_create_A\n");thread_start("thread_work_b", 8, thread_work_b, "pthread_create_B\n");/*打开中断，主要是打开时钟中断，以让时间片轮转调度生效*/intr_enable();while (1){put_str("Main");}return 0;
}/* 线程执行函数 */
void thread_work_a(void *arg)
{char *para = (char *)arg;while (1)put_str(para);
}
/* 线程执行函数 */
void thread_work_b(void *arg)
{char *para = (char *)arg;while (1)put_str(para);
}

但如果持续输出会发现终端会爆出一个GP异常

其原因在于，代码中三个线程对put_str函数的异步访问造成了数据混乱，因为put_str函数内部是通过对显存操作输出字符的，因此在这里三个线程对显存的并发访问造成了显存段的越界，从而爆出了GP异常

其解决办法也简单，就是对put_str函数的访问上锁，其中最原始的上锁原理就是在访问公共资源前关中断，这样其余线程就无法通过中断切换上处理器访问显存这段公共资源，然后在访问资源结束后开中断，允许其余线程被调度上处理器访问显存

int main(void)
{put_str("I am kernel\n");init_all();thread_start("thread_work_a", 31, thread_work_a, "pthread_create_A\n");thread_start("thread_work_b", 8, thread_work_b, "pthread_create_B\n");/*打开中断，主要是打开时钟中断，以让时间片轮转调度生效*/intr_enable();while (1){intr_disable();put_str("Main");intr_disable();}return 0;
}/* 线程执行函数 */
void thread_work_a(void *arg)
{char *para = (char *)arg;while (1){intr_disable();put_str(para);intr_enable();}
}
/* 线程执行函数 */
void thread_work_b(void *arg)
{char *para = (char *)arg;while (1){intr_disable();put_str(para);intr_enable();}
}

但这种通过开关中断的方式实现互斥锁的弊端是很明显的

  • 禁用中断意味着当前代码段执行期间，系统无法响应中断。这不仅会影响进程或线程的切换，还可能使得系统无法及时响应硬件中断（如 I/O 操作），降低系统的实时性和响应性。

  • 使用禁用中断实现互斥可能使代码变得难以理解和维护，尤其是在多线程环境中。因为禁用中断的作用是全局性的，可能会影响整个系统的稳定性和响应性。

  • 在多核或多处理器系统中，禁用中断虽然能够阻止当前线程的中断，但它并不能防止其他核心/处理器上的线程执行。如果某个核心禁用了中断并进入临界区，但其他核心依然可以执行，导致多核系统中可能出现不同步的问题。

任务简介

综上，本节我们将在多线程轮转调度的基础上介绍操作系统的同步机制——锁，同时实现一个互斥锁

本节的主要任务有：

  1. 实现操作系统的同步机制——锁

  2. 实现一个终端

信号量简介及其实现

信号量简介

信号量（Semaphore） 是一种用于控制对共享资源访问的同步机制，常用于并发编程中。它可以有效地解决多个线程或进程同时访问共享资源时可能发生的冲突或竞争条件。信号量通常用于协调线程或进程之间的执行顺序，确保并发程序能够正确地进行同步。

同步机制的实现方式不止一种，我们在这里给出信号量与其余同步机制的区别和联系

  • 互斥锁（Mutex）：

    • 互斥锁用于确保同一时刻只有一个线程可以访问某个资源，通常只有两种状态（锁定和解锁）。而信号量可以表示更复杂的情况（比如多个线程可以同时访问一个资源）。事实上，互斥锁是一种二元信号量

  • 条件变量（Condition Variable）：

    • 条件变量通常用于线程间的通知机制，允许一个线程等待某个条件的成立**，而信号量则是通过计数来控制资源访问的。

  • 事件（Event）：

    • 事件通常用于线程间的通知机制，允许一个线程等待另一个线程的某个事件发生。而信号量不仅仅用于通知，还能用来管理资源的数量。

信号量的基本操作

信号量可以看作是一个整型变量，用来表示资源的数量或许可以访问的共享资源的“可用”数量。信号量提供了两种基本操作：

  • P操作（Proberen，通常叫做Wait或Down）：

    • 这个操作会检查信号量的值。如果信号量的值大于0，信号量的值会减1，执行线程或进程可以继续执行。

    • 如果信号量的值等于0，表示没有可用的资源，当前线程或进程会被阻塞，直到有资源可用。

  • V操作（Verhogen，通常叫做Signal或Up）：

    • 这个操作会将信号量的值加1，并且如果有线程或进程因信号量值为0而被阻塞，则唤醒其中一个阻塞的线程。

信号量实现

基于上述我们对信号量基本操作的介绍，要实现信号量，首先要实现线程的阻塞过程和解除阻塞过程

/thread/thread.h

/*将线程阻塞*/
void thread_block(enum task_status status);
/*解除线程的阻塞状态*/
void thread_unblock(struct task_struct *pthread);

/thread/thread.c

线程的阻塞是一种主动行为，因此要阻塞自己的线程首先需要将自己插入阻塞队列（通常由第三方维护）中，然后调用阻塞函数将自己的PCB状态设置阻塞态，再调用调度函数从就绪队列中摘出一块准备好的线程切换到处理器执行，如下所示是阻塞函数的实现

void thread_block(enum task_status status)
{ASSERT(((status == TASK_BLOCKED) || (status == TASK_HANGING) || (status == TASK_WAITING)));enum intr_status old_status = intr_get_status();/*修改当前线程状态为阻塞态然后调用调度器从就绪队列摘取一块新线程执行*/struct task_struct *cur_pthread = running_thread();cur_pthread->status = status;schedule();intr_set_status(old_status);
}

解除阻塞的行为由处理器完成，主要过程就是阻塞线程或进程的PCB状态设置为就绪态，然后将其插入就绪队列的头部，优先调用

void thread_unblock(struct task_struct *pthread)
{enum intr_status old_status = intr_get_status();/*修改PCB状态为就绪态，同时插入就绪队列头部，优先调用*/enum task_status status = pthread->status;ASSERT(((status == TASK_BLOCKED) || (status == TASK_HANGING) || (status == TASK_WAITING)));if (status != TASK_READY){if (elem_find(&thread_ready_list, &pthread->general_tag))PANIC("thread_unblock: blocked thread in ready_list\n");list_append(&thread_ready_list, &pthread->general_tag);pthread->status = TASK_READY;}intr_set_status(old_status);
}

接下来就是信号量的实现

/thread/sync.h

以下是信号量结构体的组成及其相关操作定义

/*信号量结构体*/
struct semaphore
{// 信号量值uint8_t value;// 阻塞在当前信号量上的线程的阻塞队列struct list waiters;
};
void sema_init(struct semaphore *psema, uint8_t value);
void sema_down(struct semaphore *psema);
void sema_up(struct semaphore *psema);

/thread/sync.c

以下是信号量操作的具体实现

// 用于初始化信号量，传入参数就是指向信号量的指针与初值
void sema_init(struct semaphore *psema, uint8_t value)
{psema->value = value;       // 为信号量赋初值list_init(&psema->waiters); // 初始化信号量的等待队列
}/*信号量的P操作*/
void sema_down(struct semaphore *psema)
{// 对阻塞队列公共资源的访问需要关中断以避免访问过程中被打断enum intr_status old_status = intr_disable();// 如果当前可用资源（信号量的值）为0，则应当阻塞当前线程while (psema->value == 0){if (elem_find(&psema->waiters, &running_thread()->general_tag))PANIC("sema_down: thread blocked has been in waiters_list\n");list_append(&psema->waiters, &running_thread()->general_tag);thread_block(TASK_BLOCKED);}// 可以让当前线程访问公共资源，同时让可访问的资源数减去一psema->value--;ASSERT(psema->value == 0);// 恢复中断之前的状态intr_set_status(old_status);
}// 信号量的up操作，也就是+1操作，传入参数是指向要操作的信号量的指针。且释放信号量时，应唤醒阻塞在该信号量阻塞队列上的一个进程
void sema_up(struct semaphore *psema)
{/* 关中断,保证原子操作 */enum intr_status old_status = intr_disable();ASSERT(psema->value == 0);if (!list_empty(&psema->waiters)){ // 判断信号量阻塞队列应为非空，这样才能执行唤醒操作struct task_struct *thread_blocked = elem2entry(struct task_struct, general_tag, list_pop(&psema->waiters));thread_unblock(thread_blocked);}psema->value++;ASSERT(psema->value == 1);/* 恢复之前的中断状态 */intr_set_status(old_status);
}

同步机制——锁的实现

互斥锁的实现

/thread/sync.h

互斥锁是一种二元信号量，因此基于信号量我们可以实现互斥锁

/*锁结构*/
struct lock
{// 锁的持有者struct task_struct *holder;// 锁上的信号量struct semaphore semaphore;// 加锁者加锁的次数，也就是加锁者访问公共资源的次数uint32_t holder_repeat_nr;
};
void lock_init(struct lock *plock);
void lock_acquire(struct lock *plock);
void lock_release(struct lock *plock);

/thread/sync.c

同理以下是互斥锁的具体操作实现

/*初始化锁*/
void lock_init(struct lock *plock)
{plock->holder = NULL;sema_init(&plock->semaphore, 1);plock->holder_repeat_nr = 0;
}// 获取锁的函数,传入参数是指向锁的指针
void lock_acquire(struct lock *plock)
{// 这是为了排除掉线程自己已经拿到了锁，但是还没有释放就重新申请的情况if (plock->holder != running_thread()){sema_down(&plock->semaphore); // 对信号量进行down操作plock->holder = running_thread();ASSERT(plock->holder_repeat_nr == 0);plock->holder_repeat_nr = 1; // 申请了一次锁}else{plock->holder_repeat_nr++;}
}// 释放锁的函数，参数是指向锁的指针
void lock_release(struct lock *plock)
{ASSERT(plock->holder == running_thread());// 如果>1，说明自己多次申请了该锁，现在还不能立即释放锁if (plock->holder_repeat_nr > 1){plock->holder_repeat_nr--;return;}ASSERT(plock->holder_repeat_nr == 1); // 判断现在lock的重复持有数是不是1只有为1，才能释放plock->holder = NULL; // 这句必须放在up操作前，因为现在并不在关中断下运行，有可能会被切换出去，如果在up后面，就可能出现还没有置空，// 就切换出去，此时有了信号量，下个进程申请到了，将holder改成下个进程，这个进程切换回来就把holder改成空，就错了plock->holder_repeat_nr = 0;sema_up(&plock->semaphore); // 信号量的V操作,也是原子操作
}

输出终端实现

基于互斥锁我们重新定义一个终端，以实现多线程的字符串打印

代码逻辑其实很简单，就是在原来的字符打印、字符串打印和整数打印函数加上一层我们实现的互斥锁

/device/console.h

#ifndef __DEVICE_CONSOLE_H
#define __DEVICE_CONSOLE_H
#include "stdint.h"
void console_init(void);
void console_acquire(void);
void console_release(void);
void console_put_str(char *str);
void console_put_char(uint8_t char_asci);
void console_put_int(uint32_t num);
#endif

/device/console.c

#include "console.h"
#include "print.h"
#include "stdint.h"
#include "sync.h"
#include "thread.h"
static struct lock console_lock; // 控制台锁/* 初始化终端 */
void console_init()
{lock_init(&console_lock);
}/* 获取终端 */
void console_acquire()
{lock_acquire(&console_lock);
}/* 释放终端 */
void console_release()
{lock_release(&console_lock);
}/* 终端中输出字符串 */
void console_put_str(char *str)
{console_acquire();put_str(str);console_release();
}/* 终端中输出字符 */
void console_put_char(uint8_t char_asci)
{console_acquire();put_char(char_asci);console_release();
}/* 终端中输出16进制整数 */
void console_put_int(uint32_t num)
{console_acquire();put_int(num);console_release();
}

然后我们重新在main函数中进行测试

int main(void)
{put_str("I am kernel\n");init_all();thread_start("thread_work_a", 31, thread_work_a, "pthread_A ");thread_start("thread_work_b", 8, thread_work_b, "pthread_B ");/*打开中断，主要是打开时钟中断，以让时间片轮转调度生效*/intr_enable();while (1){console_put_str("Main ");}return 0;
}/* 线程执行函数 */
void thread_work_a(void *arg)
{char *para = (char *)arg;while (1){console_put_str(para);}
}
/* 线程执行函数 */
void thread_work_b(void *arg)
{char *para = (char *)arg;while (1){console_put_str(para);}
}

编译运行

mkdir -p bin
#编译mbr
nasm -o $(pwd)/bin/mbr -I $(pwd)/boot/include/ $(pwd)/boot/mbr.S
dd if=$(pwd)/bin/mbr of=~/bochs/hd60M.img bs=512 count=1 conv=notrunc#编译loader
nasm -o $(pwd)/bin/loader -I $(pwd)/boot/include/ $(pwd)/boot/loader.S
dd if=$(pwd)/bin/loader of=~/bochs/hd60M.img bs=512 count=4 seek=2 conv=notrunc#编译print函数
nasm -f elf32 -o $(pwd)/bin/print.o $(pwd)/lib/kernel/print.S
# 编译kernel
nasm -f elf32 -o $(pwd)/bin/kernel.o $(pwd)/kernel/kernel.S
# 编译switch
nasm -f elf32 -o $(pwd)/bin/switch.o $(pwd)/thread/switch.S#编译main文件
gcc-4.4 -o $(pwd)/bin/main.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ -I $(pwd)/device/ -I $(pwd)/thread/ $(pwd)/kernel/main.c
#编译interrupt文件
gcc-4.4 -o $(pwd)/bin/interrupt.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ $(pwd)/kernel/interrupt.c
#编译init文件
gcc-4.4 -o $(pwd)/bin/init.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ -I $(pwd)/thread/ -I $(pwd)/device/ $(pwd)/kernel/init.c
# 编译debug文件
gcc-4.4 -o $(pwd)/bin/debug.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ $(pwd)/kernel/debug.c
# 编译string文件
gcc-4.4 -o $(pwd)/bin/string.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ $(pwd)/lib/string.c
# 编译bitmap文件
gcc-4.4 -o $(pwd)/bin/bitmap.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ $(pwd)/lib/kernel/bitmap.c
# 编译memory文件
gcc-4.4 -o $(pwd)/bin/memory.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ $(pwd)/kernel/memory.c
# 编译thread文件
gcc-4.4 -o $(pwd)/bin/thread.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ -I $(pwd)/thread/ $(pwd)/thread/thread.c
# 编译list文件
gcc-4.4 -o $(pwd)/bin/list.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ $(pwd)/lib/kernel/list.c
# 编译timer文件
gcc-4.4 -o $(pwd)/bin/timer.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ -I $(pwd)/thread/ $(pwd)/device/timer.c
# 编译sync文件
gcc-4.4 -o $(pwd)/bin/sync.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ -I $(pwd)/thread/ $(pwd)/thread/sync.c
# 编译console文件
gcc-4.4 -o $(pwd)/bin/console.o -c -fno-builtin -m32 -I $(pwd)/lib/kernel/ -I $(pwd)/lib/ -I $(pwd)/kernel/ -I $(pwd)/thread/ $(pwd)/device/console.c#将main函数与print函数进行链接
ld -m elf_i386 -Ttext 0xc0001500 -e main -o $(pwd)/bin/kernel.bin $(pwd)/bin/main.o $(pwd)/bin/kernel.o  $(pwd)/bin/init.o  $(pwd)/bin/thread.o $(pwd)/bin/switch.o $(pwd)/bin/list.o $(pwd)/bin/sync.o $(pwd)/bin/console.o $(pwd)/bin/timer.o $(pwd)/bin/interrupt.o $(pwd)/bin/memory.o $(pwd)/bin/bitmap.o  $(pwd)/bin/print.o  $(pwd)/bin/string.o $(pwd)/bin/debug.o#将内核文件写入磁盘，loader程序会将其加载到内存运行
dd if=$(pwd)/bin/kernel.bin of=~/bochs/hd60M.img bs=512 count=200 conv=notrunc seek=9#rm -rf bin/*

运行结果如下所示


http://www.ppmy.cn/news/1557796.html

相关文章

Android Studio版本升级那些事

Android Studio版本升级那些事

Android Studio版本升级那些事 文章目录 Android Studio版本升级那些事一、前言二、Android Studio版本相关知识1、Android13 签名应用无法在Android Studio 编译运行解决（1）无法编译运行前的尝试 2、Android Studio 的历史版本介绍4、Android Studio Gr…
阅读更多...
Day27 - 大模型微调，LLaMA搭建

Day27 - 大模型微调，LLaMA搭建

指令微调 SFT：Supervised Fine - Tuning 自我认知 self-cognitionidentity私有知识 / 具体任务公共知识 LLaMA-Factory 搭建过程 1. 下载 LLaMA-Factory 源代码 ​git clone https://github.com/hiyouga/LLaMA-Factory.git 2. 安装 LLaMA-Factory 依赖包 cd L…
阅读更多...
Strip Map和Wafer Map的一些小科普

Strip Map和Wafer Map的一些小科普

一、Strip Map和Wafer Map Strip Map和Wafer Map在半导体行业中都是重要的工具，它们各自有不同的应用和特点： 1. Strip Map： - Strip Map主要应用于半导体后道基板上的每个芯片的良率实时追溯。它从Die Bond贴芯片到Wire Bond、Marking为止的过程中实时处理及管理设备上传…
阅读更多...
springboot+logback学习文档

springboot+logback学习文档

目录 1、前提说明2、引入依赖、将logback配置文件打到classes下2.1、引入依赖2.2、将logback配置文件打到classes下 3、使用说明3.1、配置文件名称和位置3.2、常规用法3.2.1、property标签（普通变量）3.2.2、springProperty标签（spring变量&am…
阅读更多...
vue3中的ref与reactive

vue3中的ref与reactive

摘要 在vue3直接定义变量不是响应式数据 在vue3中定义变量更改变量页面是显示不出来的 在按钮中绑定一个函数，当我点击它的时候发生改变str值 点击前 点击后 点击后控制台显示更改数据，而页面中不显示数据，这就是vue3没触发响应式 使用re…
阅读更多...
全志H618 Android12修改doucmentsui鼠标单击图片、文件夹选中区域

全志H618 Android12修改doucmentsui鼠标单击图片、文件夹选中区域

背景： 由于当前的文件管理器在我们的产品定义当中，某些界面有改动的需求，所以需要在Android12 rom中进行定制以符合当前产品定义。 需求： 在进入File文件管理器后，鼠标左击整个图片、整个文件夹可以选中该类型，进行操作，故代码分析以及客制化如下： 主要涉及的代码：…
阅读更多...
观察者模式（sigslot in C++）

观察者模式（sigslot in C++）

大家，我是东风，今天抽点时间整理一下我很久前关注的一个不错的库，可以支持我们在使用标准C的时候使用信号槽机制进行观察者模式设计，sigslot 官网： http://sigslot.sourceforge.net/ 本文较为详尽探讨了一种观察者模…
阅读更多...
第二节：GLM-4v-9B数据加载源码解读

第二节：GLM-4v-9B数据加载源码解读

文章目录 前言一、GLM-4v-9B模型数据格式二、GLM-4v-9B数据处理源码1、训练数据加工源码(process_batch)2、评估与预测数据加工源码 三、GLM-4v-9B训练数据加工源码解读（process_batch）1、batched_conv原始数据获取源码解读2、数据batch循环初始化源码解…
阅读更多...
最新文章

Copyright @ 2022~2023