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

news/2024/12/28 23:05:59/

本章节所有代码托管在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_push(&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/1558913.html

相关文章

深度解析：电商平台API接口的安全挑战与应对策略

深度解析：电商平台API接口的安全挑战与应对策略

随着电子商务的蓬勃发展，电商平台与外部服务、内部系统之间的数据交换和通信变得日益频繁。API（应用程序编程接口）接口作为这一过程中的关键枢纽，其安全性显得尤为重要。API接口不仅承载着商品管理、订单处理、支付结算、用户管理…
阅读更多...
dolphinscheduler服务RPC心跳机制之实现原理与源码解析

dolphinscheduler服务RPC心跳机制之实现原理与源码解析

RPC心跳机制设计 1.概述2.设计2.1.心跳机制流程设计2.1.1.常规RPC心跳机制设计2.1.2.Dolphinscheduler的RPC心跳机制设计2.2.心跳机制数据模型设计2.3.心跳机制动态配置3.实现3.1.心跳机制数据模型3.1.1.HeartBeat接口3.1.2.基础实现类BaseHeartBeat3.1.3.Master服务中的心跳消…
阅读更多...
Python 端口访问邮件提醒工具

Python 端口访问邮件提醒工具

Python 端口访问邮件提醒工具 1.简介： 该脚本主要实现的功能是获取指定端口连接的远程 IP 地址，并将其发送给指定的邮箱,可用于一些远程工具的登录通知，或者其他你需要检测的程序。 特点： 可在配置文件内自定义需要检测的端口…
阅读更多...
基于Sentinel的服务保护方案的三种方式（请求限流、线程隔离、服务熔断）超详细讲解

基于Sentinel的服务保护方案的三种方式（请求限流、线程隔离、服务熔断）超详细讲解

目录 1、三种方式介绍 1.1请求限流 1.2 线程隔离方案 1.3 服务熔断 2、基于sentinel实现 2.1 启动sentinel 2.2 基于springboot整合sentinel 2.2.1请求限流 2.2.2请求隔离 2.2.2.1 OpenFeign整合Sentinel 2.2.3 服务熔断 2.2.3.1 编写降级代码 2.2.3.2 服务熔断 1、…
阅读更多...
嵌入式学习-QT-Day06

嵌入式学习-QT-Day06

嵌入式学习-QT-Day06 六、多窗口编程 1、QMessageBox 消息对话框 2、QWidget类 3、parent参数 4、堆栈窗口（QStackedWidget） 5、新建自定义窗口类 6、对象传值 6.1 父对象 → 子对象 6.2 子对象 → 父对象 7、事件机制 8、QMainWindow主窗口类 8.1 QMenu…
阅读更多...
机器学习之scikit-learn（简称 sklearn）

机器学习之scikit-learn（简称 sklearn）

scikit-learn（简称 sklearn）是 Python 生态中一个非常流行且强大的机器学习库，支持各种机器学习算法和工具。 核心模块和功能 监督学习 (Supervised Learning)： 分类 (Classification): 支持的算法：KNN、SVM、决策树、…
阅读更多...
Scala_【2】变量和数据类型

Scala_【2】变量和数据类型

第二章 注释标识符的命名规范命名规则关键字 变量字符串输出数据类型关系变量和数据类型整数类型（Byte、Short、Int、Long）浮点类型（Float、Double）字符类型（Char）布尔类型（Boolean）…
阅读更多...
leetcode hot 100 二叉搜索

leetcode hot 100 二叉搜索

35. 搜索插入位置 已解答 简单 相关标签 相关企业 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的算法。 class Solut…
阅读更多...
最新文章

Copyright @ 2022~2023