《操作系统原理》实验三：线程/进程与死锁问题

最新推荐文章于 2024-08-26 22:36:51 发布
最新推荐文章于 2024-08-26 22:36:51 发布
阅读量3.7k 收藏 15
点赞数 3
分类专栏： 实验、考试与课设
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lee1hong/article/details/103276087
版权

一、实验目的

1）理解线程/进程的通信机制和编程；

2）理解线程/进程的死锁概念和如何解决死锁

二、实验内容

1）在Ubuntu 或Fedora 环境使用创建一对父子进程，使用共享内存的方式实现进程间的通信。父进程提供数据（1-100，递增），子进程读出来并显示。

2）（考虑信号通信机制）在Ubuntu 或Fedora 环境创建父子2 个进程A，B。进程A 不断获取用户从键盘输入的字符串或整数，通过信号机制传给进程B。如果输入的是字符串，进程B 将其打印出来；如果输入的是整数，进程B 将其累加起来，并输出该数和累加的和。当累加和大于100 时结束子进程，子进程输出“My work done！”后结束，然后父进程也结束。

3）在windows 环境使用创建一对父子进程，使用管道（pipe）的方式实现进程间的通信。父进程提供数据（1-100，递增），子进程读出来并显示。

4）（考虑匿名管道通信）在windows 环境下创建将CMD 控制台程序封装为标准的windows 窗口程序。

5）在windows 环境下，利用高级语言编程环境（限定为VS 环境或VC 环境）调用CreateThread 函数哲学家就餐问题的演示。要求：（1）提供死锁的解法和非死锁的解法；（2）有图形界面直观显示哲学家取筷子，吃饭，放筷子，思考等状态。（3）为增强结果的随机性，各个状态之间的维持时间采用随机时间，例如100ms-500ms 之间。

三、实验过程

1）共享内存实现进程通信

①任务环境

Ubuntu版本：16.04 64位

Linux内核版本：4.5.0-29-generic

②何为共享内存

共享内存就是允许两个不相关的进程访问同一个逻辑内存。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址

③函数

声明在头文件 sys/shm.h 中

④shmget函数：该函数用来创建共享内存

1.  int shmget(key_t key, size_t size, int shmflg);    

key_t key: 它有效地为共享内存段命名，shmget函数成功时返回一个与key相关的共享内存标识符（非负整数）。调用失败返回-1.

size_t size: size以字节为单位指定需要共享的内存容量

int shmflg: 共享内存的权限标志

⑤shmat函数: shmat函数的作用就是用来启动对该共享内存的访问，并把共享内存连接到当前进程的地址空间

1.  void *shmat(int shm_id, const void *shm_addr, int shmflg);    

shm_id: shm_id是由shmget函数返回的共享内存标识。

shm_addr: shm_addr指定共享内存连接到当前进程中的地址位置，通常为空，表示让系统来选择共享内存的地址。

shmflg: shm_flg是一组标志位，通常为0。

⑥shmdt函数: 该函数用于将共享内存从当前进程中分离，使该共享内存对当前进程不再可用。

1.  int shmdt(const void *shmaddr);    

参数shmaddr: 是shmat函数返回的地址指针，调用成功时返回0，失败时返回-1.

⑦shmctl函数: 与信号量的semctl函数一样，用来控制共享内存

1.  int shmctl(int shm_id, int command, struct shmid_ds *buf);    

shm_id: 是shmget函数返回的共享内存标识符。

command: 是要采取的操作，它可以取下面的三个值 ：

IPC_STAT： 把shmid_ds结构中的数据设置为共享内存的当前关联值，即用共享内存的当前关联值覆盖shmid_ds的值。

IPC_SET：如果进程有足够的权限，就把共享内存的当前关联值设置为shmid_ds结构中给出的值

IPC_RMID： 删除共享内存段

buf: 是一个结构指针，它指向共享内存模式和访问权限的结构。

struct shmid_ds    
{    
    uid_t shm_perm.uid;    
    uid_t shm_perm.gid;    
    mode_t shm_perm.mode;    
};

 

2）Linux父子进程管道通信

①管道的特点：

1. 管道只允许具有血缘关系的进程间通信，如父子进程间的通信。  
2. 管道只允许单向通信。  
3. 管道内部保证同步机制，从而保证访问数据的一致性。  
4. 面向字节流  
5. 管道随进程，进程在管道在，进程消失管道对应的端口也关闭，两个进程都消失管道也消失。

②注意事项：

1.  如果一个管道的写端一直在写，而读端的引⽤计数是否⼤于0决定管道是否会堵塞，引用计数大于0，只写不读再次调用write会导致管道堵塞；  

2.  如果一个管道的读端一直在读，而写端的引⽤计数是否⼤于0决定管道是否会堵塞，引用计数大于0，只读不写再次调用read会导致管道堵塞；  

3.  而当他们的引用计数等于0时，只写不读会导致写端的进程收到一个SIGPIPE信号，导致进程终止，只写不读会导致read返回0,就像读到⽂件末尾⼀样。  

 

3）哲学家问题

任务环境：Windows 10 x64 + Visual Studio 2017 Enterprise

饥饿解法：

 

1.	#define N 5   
2.	  
3.	void philosopher(int i)   
4.	{   
5.	    while (true) {   
6.	        think() ;   
7.	        take_fork(i) ;   
8.	        take_fork((i+1)%N) ;   
9.	        eat() ;   
10.	        put_fork(i) ;   
11.	        put_fork((i+1)%N) ;   
12.	    }   
13.	}

 

非死锁解法：

 

#define N 5  // 哲学家的数目   
#define LEFT (i+N-1)%N // i的左邻居编号   
#define RIGHT (i+1)%N // i的右邻居编号   
#define THINKING 0 // 哲学家在思考   
#define HUNGRY 1 // 哲学家试图拿起叉子   
#define EATING 2 // 哲学家就餐   
typedef int semaphore ; // 信号量是一种特殊的整型数据   
int state[N] ; // 数组用来跟踪记录每位哲学家的状态，全局变量初始化为0，即是说哲学家的初始化状态是THINKING ;    
semaphore mutex = 1 ; // 临界区的互斥   
semaphore s[N] ; // 每个哲学家一个信号量   
  
void philosopher(int i) { // i:哲学家编号，从0到i-1   
    while (true) {   
        think() ;   
        take_forks(i) ;   
        eat() ;   
        put_forks(i) ;   
    }                           
}     
  
void take_forks(int i) {   
    wait(mutex) ; // 进入临界区   
    state[i] = HUNGRY ; // 记录哲学家i处于饥饿的状态   
    test(i) ; // 尝试获得2把尺子   
    signal(mutex) ; // 离开临界区   
    wait(s[i]) ; // 如果得不到需要的尺子则阻塞   
}    
  
void put_forks(int i) {   
    wait(mutex) ; // 进入临界区   
    state[i] = THINKING ; // 记录哲学家i已经就餐完毕   
    test(LEFT) ; // 检查左边的邻居现在可以吃吗    
    test(RIGHT) ; // 检查右边的邻居现在可以吃吗   
    signal(mutex) ; // 离开临界区   
}   
  
void test(int i) {   
    if (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {   
        state[i] = EATING ;   
        signal(s[i]) ;          
    }   
}

 

 

四、实验结果

1）共享内存实现进程通信

#include <unistd.h>  
#include <stdlib.h>  
#include <stdio.h>  
#include <sys/shm.h>  
#include <string.h>  
#include <errno.h>    
  
#define TEXT_SZ 101  
  
struct shared_use_st  
{  
    int written;       //作为一个标志，非0：表示可读，0表示可写  
    int text[TEXT_SZ]; //记录写入和读取的文本  
};  
  
int main()  
{  
    int pRunning = 1;             //程序是否继续运行的标志(父)  
    int cRunning = 1;             //程序是否继续运行的标志(子)  
    void *shm = NULL;             //分配的共享内存的原始首地址  
    struct shared_use_st *shared; //指向shm  
    char buffer[BUFSIZ + 1];      //用于保存输入的文本  
    int shmid;                    //共享内存标识符  
    //创建共享内存  
    shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);  
    if (shmid == -1)  
    {  
        fprintf(stderr, "shmget failed\n");  
        exit(EXIT_FAILURE);  
    }  
    //将共享内存连接到当前进程的地址空间  
    shm = shmat(shmid, 0, 0);  
    if (shm == (void *)-1)  
    {  
        fprintf(stderr, "shmat failed\n");  
        exit(EXIT_FAILURE);  
    }  
    //设置共享内存  
    shared = (struct shared_use_st *)shm;  
    shared->written = 0;  
    pid_t pid = fork();  
    if (pid < 0)  
    {  
        //printf('子进程创建失败');  
        fprintf(stderr, "can't fork ,error %d\n", errno);  
        exit(1);  
    }  
    else if (pid == 0) //子进程  
    {  
        while (cRunning) //读取共享内存中的数据  
        {  
            //没有进程向共享内存定数据有数据可读取  
            if (shared->written != 0)  
            {  
                int i = 0;  
                while (i < 100)  
                {  
                    printf("child  read: %d\n", shared->text[i]);  
                    i++;  
                }  
                //读取完数据，设置written使共享内存段可写  
                shared->written = 0;  
                //退出循环（程序）  
                cRunning = 0;  
            }  
            else //有其他进程在写数据，不能读取数据  
                sleep(1);  
        }  
    }  
    else //父进程  
    {  
        int i = 1;  
        while (pRunning) //向共享内存中写数据  
        {  
            //数据还没有被读取，则等待数据被读取,不能向共享内存中写入文本  
            while (shared->written == 1)  
            {  
                sleep(1);  
            }  
            //向共享内存中写入数据  
            shared->text[i - 1] = i;  
            printf("parent write: %d\n", shared->text[i - 1]);  
            i++;  
            if (i > 100)  
            {  
                //写完数据，设置written使共享内存段可读,退出循环（程序）  
                shared->written = 1;  
                pRunning = 0;  
            }  
        }  
    }  
    //把共享内存从当前进程中分离  
    if (shmdt(shm) == -1)  
    {  
        fprintf(stderr, "shmdt failed\n");  
        exit(EXIT_FAILURE);  
    }  
    //删除共享内存  
    if (shmctl(shmid, IPC_RMID, 0) == -1)  
    {  
        fprintf(stderr, "shmctl(IPC_RMID) failed\n");  
        exit(EXIT_FAILURE);  
    }  
    exit(EXIT_SUCCESS);  
}

 

2）Linux父子进程管道通信

#include <stdio.h>  
#include <unistd.h>  
#include <string.h>  
#include <errno.h>  
  
int main()  
{  
    int fd[2];  
    int ret = pipe(fd);  
    if (ret == -1)  
    {  
        perror("pipe error \n");  
        return 1;  
    }  
    pid_t id = fork();  
    if (id > 0) //parent  
    {  
        int i = 1;  
        close(fd[0]);  
        while (i < 101)  
        {  
            write(fd[1], &i, 1);  
            //每隔 1 秒打印一次  
            sleep(1);  
            i++;  
        }  
    }  
    else if (id == 0) //child  
    {  
        close(fd[1]);  
        int msg;  
        int j = 0;  
        while (j < 100)  
        {  
            ssize_t s = read(fd[0], &msg, sizeof(msg));  
            printf("%d\n", msg);  
            j++;  
        }  
    }  
    else  
    { //error  
        perror("fork error \n");  
        return 2;  
    }  
    return 0;  
}

3）哲学家问题

饥饿解法：

#define N 5   
  
void philosopher(int i)   
{   
    while (true) {   
        think() ;   
        take_fork(i) ;   
        take_fork((i+1)%N) ;   
        eat() ;   
        put_fork(i) ;   
        put_fork((i+1)%N) ;   
    }   
}

非死锁解法：

 

#define N 5  // 哲学家的数目   
#define LEFT (i+N-1)%N // i的左邻居编号   
#define RIGHT (i+1)%N // i的右邻居编号   
#define THINKING 0 // 哲学家在思考   
#define HUNGRY 1 // 哲学家试图拿起叉子   
#define EATING 2 // 哲学家就餐   
typedef int semaphore ; // 信号量是一种特殊的整型数据   
int state[N] ; // 数组用来跟踪记录每位哲学家的状态，全局变量初始化为0，即是说哲学家的初始化状态是THINKING ;    
semaphore mutex = 1 ; // 临界区的互斥   
semaphore s[N] ; // 每个哲学家一个信号量   
  
void philosopher(int i) { // i:哲学家编号，从0到i-1   
    while (true) {   
        think() ;   
        take_forks(i) ;   
        eat() ;   
        put_forks(i) ;   
    }                           
}     
  
void take_forks(int i) {   
    wait(mutex) ; // 进入临界区   
    state[i] = HUNGRY ; // 记录哲学家i处于饥饿的状态   
    test(i) ; // 尝试获得2把尺子   
    signal(mutex) ; // 离开临界区   
    wait(s[i]) ; // 如果得不到需要的尺子则阻塞   
}    
  
void put_forks(int i) {   
    wait(mutex) ; // 进入临界区   
    state[i] = THINKING ; // 记录哲学家i已经就餐完毕   
    test(LEFT) ; // 检查左边的邻居现在可以吃吗    
    test(RIGHT) ; // 检查右边的邻居现在可以吃吗   
    signal(mutex) ; // 离开临界区   
}   
  
void test(int i) {   
    if (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {   
        state[i] = EATING ;   
        signal(s[i]) ;          
    }   
}

 

五、体会

通过本次实验，我对操作系统线程/进程的通信机制和编程、操作系统线程/进程的死锁概念有了更深刻的理解，掌握了如何解决死锁，对操作系统的功能与原理有了进一步的了解。

LkgFfdvwcjhWLoncvVfx
关注
专栏目录
《操作系统原理》实验三：线程的调度
LLOZEL的博客
04-28 4308
以下是个人总结的实验过程及经验分享。 Tips: • 优先级 –静态优先级(nice)：内核不会修改它，不随时间而变化，除非用户通过系统调用setpriority进行修改 –动态优先级(priority)：内核根据线程使用CPU的状况、静态优先级nice和系统负荷计算出来，会随时间而变化 最终的调度依据，即调度器只根据动态优先级进行调度 ...
死锁
foreveyking的博客
03-29 816
死锁的必要条件互斥：每个资源要么已经分配给了一个进程，要么就是可用的。占有和等待：已经得到了某个资源的进程可以再请求新的资源。不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显示地释放。环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在等待下一个进程所占有的资源。死锁的处理方法1.鸵鸟策略把头埋在沙子里，假装根本没发生问题。因为解决死锁问题的代价很高，...
操作系统实验三 预防进程死锁的银行家算法
02-03
操作系统实验三 预防进程死锁的银行家算法（内含源代码和详细实验报告），详细介绍：http://blog.csdn.net/xunciy/article/details/79239096
【操作系统】实验：进程死锁
最新发布
m0_73970214的博客
08-26 1023
系统性能影响：虽然死锁预防能够严格地防止死锁的出现，但它可能严重地影响系统性能，因为可能需要限制资源的并发访问，以降低死锁的风险。而死锁避免则相对灵活，它可以在满足系统性能要求的同时，动态地调整资源的分配，以减少死锁的可能性。综上所述，死锁避免和死锁预防在处理死锁问题时有着不同的策略和方法，但它们都是为了提高计算机系统的稳定性和效率，解决可能出现的死锁问题。2.本实验要求学生编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效地防止和避免死锁的发生。
操作系统实验报告三
weixin_33968104的博客
02-26 224
操作系统实验报告三 姓名：许恺 学号：2014011329 日期：2016.11.22 题目1：设计一段内存结构，能够缓存一定数量的网页，在客户端访问时，...
操作系统 | 实验三 进程死锁
猫天意的博客
05-15 4549
编制模拟银行家算法的程序，并以下面给出的例子验证所编写的程序的正确性。 某系统有A、B、C、D4类资源共5个进程（PO、P1、P2、P3、P4）共享，各进程对资源的需求和分配情况如下表所示。各进程对资源的需求和分配情况表： 现在系统中A、B、C、D4类资源分别还剩1、5、2、0个，请按银行家算法回答下列问题：变量 描述 int available[100]; 可利用资源数组 int max[50][100]; 最大需求矩阵 int allocation[50][100]; 分配矩阵 int need[50
操作系统实验报告
weixin_53495618的博客
06-22 2791
操作系统实验报告
操作系统实验报告——线程与进程同步
07-13
实验总结，通过这个线程与进程同步的实践，学生不仅可以了解到如何在实际编程中应用同步机制，还能深入理解操作系统如何协调并发执行的线程，以及如何避免和解决同步问题，这对于理解多线程编程和操作系统原理至关...
重大软院操作系统实验二：线程调度
12-31
通过这个实验，学生将有机会亲手实现和分析线程调度，加深对操作系统原理的理解，尤其是Linux内核的工作方式。这不仅锻炼了编程技能，也提升了系统级问题的解决能力。在实际工程中，良好的线程管理对于系统性能和...
操作系统原理 操作系统基础教程 OS03-进程的并发控制和死锁 共94页.pptx
08-03
OS01-操作系统概论 共52页.pptx OS02-进程管理 共68页.pptx OS03-进程的并发控制和死锁 共94页.pptx OS04-存储器管理 共117页.pptx OS05-文件系统 共75页.pptx OS06-设备管理 共34页.pptx OS07-Linux进程管理 共16页...
操作系统内存管理实验报告及源代码
12-30
随机给出一个页面执行序列，如：1,5,3,4,2,1,3,4,5,7,9,……。要求计算以下几种置换算法的缺页数、缺页率和命中率。  最佳置换算法OPT（Optimal）  先进先出算法FIFO（First In First Out）  最近最少使用算法LRU（Least Recently Used） 实验报告（含流程图及运行结果）&源代码
操作系统线程实验报告
01-03
一个简单的操作系统实验报告，很简单，。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
操作系统实验，多线程并发执行
02-27
编程实现多线程并发计算10W个浮点数，适合初学者
操作系统：死锁实验报告
10-20
操作系统实验报告：死锁 银行家算法源代码和运行结果的截图。
操作系统原理作业与实验.zip
05-16
天津大学2020年的操作系统原理课程，通过作业与实验相结合的方式，帮助学生深入理解这一复杂的主题。在这个“操作系统原理作业与实验.zip”压缩包中，包含的“yyf作业集”可能是学生完成的课后练习和实验报告。 1. ...
操作系统实践06—线程
Kint的博客
05-18 1320
NUAA南航操作系统实践课程
操作系统（线程实验）
qq_54809548的博客
03-14 1531
一：创建线程 CreateThread windows多线程（一） 创建线程 CreateThread - ay-a - 博客园 二：等待线程返回 windows多线程（二） 等待线程返回 - ay-a - 博客园 三：原子操作 windows多线程（三） 原子操作 - ay-a - 博客园 四：互斥量（Mutex） windows多线程（五） 互斥量 Mutex - ay-a - 博客园 五：信号量Semaphore windows多线程（八） 信号量Semaphore - ay-a -
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值