Linux进程死锁等相关实验汇总

最新推荐文章于 2021-12-04 12:43:53 发布
最新推荐文章于 2021-12-04 12:43:53 发布
阅读量551 收藏 7
点赞数 1
分类专栏： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46161993/article/details/114547109
版权

1. 在Linux下创建一对父子进程，实现wait等待

  创建子进程的fork()函数位于unistd.h头文件中，等待进程运行结束的waitpid()函数位于sys/wait.h头文件中。当成功创建子进程时，fork()函数对父进程返回该子进程的进程号，对子进程返回0；若创建失败则会返回-1。编写程序如下：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(){
    int status;
    pid_t child = fork();
    if(child < 0){
        printf("Sorry, Generate child fail!\n");
        exit(0);
    }
    else if(child == 0) printf("Hi, YigeLIU! This is the child process!\n");
    else{
        printf("Hi, YigeLIU! This is the father process!\n");
        waitpid(child, &status, 0);
        printf("END WAIT\n");
    }
    return 0;
}

  对该程序进行测试运行，结果如下：
在这里插入图片描述

2. 在 Linux下利用信号机制实现进程间通信

  子进程主体结构为一个死循环，当父进程发出kill信号时杀死子进程，同时需要注意的是，此时父进程不能直接结束，而应等待子进程被回收，以避免僵尸进程的产生。父进程杀死子进程时，子进程打印退出的信息。两者的通讯通过函数“kill()”与函数“signal()”实现。程序中使用sleep()来放缓程序执行，使得过程展现得更清晰。具体代码实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <wait.h>

void exit_output(){
    printf("Bye, father!\n");
    exit(0);
}

int main(){
    pid_t child = fork();
    if(child < 0){
        printf("Generate child process failed!\n");
        exit(0);
    }
    else if(child == 0){
        signal(SIGUSR1, exit_output);
        while(1){
            printf("This is the child process!\n");
            sleep(1);
        }
    }
    else{
        sleep(5);
        kill(child, SIGUSR1);
        printf("Father : Child process has killed!\n");
        wait(NULL);  //等待子进程资源回收，防止僵尸进程出现
    }
    return 0;
}

  对程序进行测试，结果如下：
在这里插入图片描述

3. 在 Linux下创建2个线程A和B并循环输出数据或字符串

  笔者选取1~5进行输出，线程A在屏幕上用while循环顺序递增地输出1~5的自然数；线程B在屏幕上用while循环顺序递减地输出5~1之间的自然数。为避免输出太快，每隔1秒输出一个数。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

void *myprint_a(){
    for(int i = 1; i <= 5; ++i){
        printf("A : %d\n", i);
        sleep(1);
    }
    return ;
}

void *myprint_b(){
    for(int i = 5; i > 0; --i){
        printf("B : %d\n", i);
        sleep(1);
    }
    return ;
}

int main(){
    pthread_t tid_a;
    int status_a = pthread_create(&tid_a, NULL, myprint_a, NULL);
    if(status_a != 0){
        printf("Generate thread A failed!\n");
        exit(0);
    }
    pthread_t tid_b;
    int status_b = pthread_create(&tid_b, NULL, myprint_b, NULL);
    if(status_b != 0){
        printf("Generate thread B failed!\n");
        exit(0);
    }

    pthread_join(tid_a, NULL);
    pthread_join(tid_b, NULL);

    return 0;
}

  编译（需要添加pthread链接库，因此需要加上编译选项-lpthread）并运行该程序，如下：
在这里插入图片描述

4. 在 Linux下利用线程实现“生产者-消费者”同步控制

  首先创建一个共享的存储区，其类型为int型，大小为32。创建两个信号灯“s_blank”和“s_full”分别用来表示该存储区是否为空和是否为满，两者的初始值分别为32和0。分别创建3个生产者和消费者进程。

  接着完成生产者Consumer()与消费者Producer()两个函数。对于生产者函数，首先对信号灯s_blank进行p操作占用一个存储区资源，接着拿到对资源区写的权限，得到后更新存储区中内容，释放该权限，然后对信号灯s_full进行v操作，使得消费者可以访问该资源。对于消费者函数，首先对信号灯s_full进行p操作以获取访问存储区资源的权限，接着拿到对资源区读的权限，得到后读取存储区内容，释放该权限，然后对信号灯s_blank进行v操作，使得生产者可以再度占用该存储区资源以便数据的写入。

  利用cnt来记录每个生产者的生产量和每个消费者的消费量，主进程等待1秒钟让生产者和消费者队列进行操作，之后修改flag值使得所有生产者和消费者退出线程。此时输出相关生产量和消费量。代码中在cnt[i]值自增前注释掉了一样输出对应线程对应操作数的代码，在测试时，可以清除展示每个线程的工作信息。这里为了防止信息输出过多而将其注释掉。

  具体代码实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

int shared_block[32];
sem_t s_blank, s_full;  //信号灯声明
int step_p = 0, step_c = 0;  //访问的数据区位置
pthread_mutex_t mutex;  //资源区是否被占用的锁
int cnt_p[3], cnt_c[3];  //记录各生产者和消费者的生产量和消费量
int flag = 1;  //进程退出条件

void *Producer(int id){
    while(flag){
        sem_wait(&s_blank);  //p操作
        if(pthread_mutex_trylock(&mutex) != 0){  //当无法占用资源区时
            sem_post(&s_blank);
            continue;
        }
        int data = rand() % 369;        
        shared_block[step_p] = data;
        step_p = (step_p + 1) % 32;
        //printf("Producer %d : %d\n", id, data);
        //sleep(1);
        cnt_p[id]++;
        pthread_mutex_unlock(&mutex);
        sem_post(&s_full);  //v操作
    }
    pthread_exit(0);
}

void *Consumer(int id){
    while(flag){
        sem_wait(&s_full);
        if(pthread_mutex_trylock(&mutex) != 0){  //当无法占用资源区时
            sem_post(&s_full);
            continue;
        }
        int data = shared_block[step_c];
        step_c = (step_c + 1) % 32;
        //printf("Consumer %d : %d\n", id, data);
        //sleep(1);
        cnt_c[id]++;
        pthread_mutex_unlock(&mutex);
        sem_post(&s_blank);
    }
    pthread_exit(0);
}

int main(){
    //初始化信号灯
    sem_init(&s_blank, 0, 32);  //0表明空间被进程内的线程所共享；空间大小为32
    sem_init(&s_full, 0, 0);
    
    //创建线程
    printf("HAVE STATED, PLEASE WAIT\n");
    pthread_t producer[3], consumer[3];
    for(int i = 0; i < 3; ++i){
        pthread_create(&producer[i], NULL, Producer, i);
        pthread_create(&consumer[i], NULL, Consumer, i); 
    } 

    sleep(1); flag = 0;
    printf("------THE RESULT------\n");
    for(int i = 0; i < 3; ++i){
        printf("Producer %d produce %d products\n", i, cnt_p[i]);
        printf("Consumer %d consume %d products\n", i, cnt_c[i]);
    }

    //销毁信号灯
    sem_destroy(&s_blank);
    sem_destroy(&s_full);
    pthread_mutex_destroy(&mutex);

    return 0;
}

  编译并运行该程序，观察到生产者与消费者形成同步，如下：
在这里插入图片描述

5. 在Linux下利用线程模拟哲学家就餐问题并提供死锁和非死锁解法

非死锁

  给5根筷子分别申请一个锁，用来表示该筷子是否被占用。给5位哲学家每人创建一个线程，用来模拟其取筷子的过程。这5个线程进行进行等待操作，以模拟实际情况。

  利用函数deal()来处理每个哲学家遇到的情况。首先根据哲学家所坐位置来确定其左手边和右手边筷子的编号；然后进入循环，哲学家先拿起左手边的筷子，然后尝试拿起右手边的筷子，若成功拿起，则开始吃饭；若右手边没有筷子，则放下左手刚拿起的筷子并进入下一次循环。

  具体代码实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

pthread_mutex_t chopsticks[6];  //5个筷子的互斥锁，0不用，使用1~5号

void deal(char ch){
    int left, right;  //左右筷子的编号，i号筷子在i号哲学家左侧；哲学家逆时针坐
    if(ch == 'A') { left = 1; right = 5; }
    else if(ch == 'B') { left = 2; right = 1; }
    else if(ch == 'C') { left = 3; right = 2; }
    else if(ch == 'D') { left = 4; right = 3; }
    else { left = 5; right = 4; }

    while(1){
        sleep(1);  //思考
        pthread_mutex_lock(&chopsticks[left]);  //拿起左手的筷子
        printf("Left chopstick(pick) : %d\n", left);
        if(pthread_mutex_trylock(&chopsticks[right]) != 0){  //若右手边没有筷子
            pthread_mutex_unlock(&chopsticks[left]);  //放下左手的筷子
            printf("Left chopstick(put) : %d\n", left);
            continue;
        }
        //若右手边有筷子
        printf("Right chopstick(pick) : %d\n", right);

        //吃饭
        printf("---EATING TIME FOR : %c---\n", ch);
        sleep(1);

        //吃完饭
        pthread_mutex_unlock(&chopsticks[left]);  //放下左手的筷子
        printf("Left chopstick(put) : %d\n", left);
        pthread_mutex_unlock(&chopsticks[right]);  //放下右手的筷子
        printf("Right chopstick(put) : %d\n", right);
    }
}

int main(){
    //初始化锁
    for(int i = 0; i < 6; ++i) pthread_mutex_init(&chopsticks[i], NULL);

    //创建5个哲学家线程
    pthread_t A, B, C, D, E;
    pthread_create(&A, NULL, deal, 'A');
    pthread_create(&B, NULL, deal, 'B');
    pthread_create(&C, NULL, deal, 'C');
    pthread_create(&D, NULL, deal, 'D');
    pthread_create(&E, NULL, deal, 'E');

    //线程同步
    pthread_join(A, NULL);
    pthread_join(B, NULL);
    pthread_join(C, NULL);
    pthread_join(D, NULL);
    pthread_join(E, NULL);

    return 0;
}

  编译并运行该程序，得到哲学家吃饭的结果，如下：
在这里插入图片描述

死锁

  仅需对非死锁情况进行一定的修改即可。当哲学家拿起左手边的筷子时，对右手边的筷子不尝试拿起，而是直接进行资源的申请；同时，当右手边没有筷子可拿时也不放下左手的筷子而是持续等待；这样便会导致死锁的产生。

  具体代码实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

pthread_mutex_t chopsticks[6];  //5个筷子的互斥锁，0不用，使用1~5号

void deal(char ch){
    int left, right;  //左右筷子的编号，i号筷子在i号哲学家左侧；哲学家逆时针坐
    if(ch == 'A') { left = 1; right = 5; }
    else if(ch == 'B') { left = 2; right = 1; }
    else if(ch == 'C') { left = 3; right = 2; }
    else if(ch == 'D') { left = 4; right = 3; }
    else { left = 5; right = 4; }

    while(1){
        sleep(1);  //思考
        pthread_mutex_lock(&chopsticks[left]);  //拿起左手的筷子
        printf("Left chopstick(pick) : %d\n", left);
        pthread_mutex_lock(&chopsticks[right]);  //拿起右手边有筷子
        printf("Right chopstick(pick) : %d\n", right);

        //吃饭
        printf("---EATING TIME FOR : %c---\n", ch);
        sleep(1);

        //吃完饭
        pthread_mutex_unlock(&chopsticks[left]);  //放下左手的筷子
        printf("Left chopstick(put) : %d\n", left);
        pthread_mutex_unlock(&chopsticks[right]);  //放下右手的筷子
        printf("Right chopstick(put) : %d\n", right);
    }
}

int main(){
    //初始化锁
    for(int i = 0; i < 6; ++i) pthread_mutex_init(&chopsticks[i], NULL);

    //创建5个哲学家线程
    pthread_t A, B, C, D, E;
    pthread_create(&A, NULL, deal, 'A');
    pthread_create(&B, NULL, deal, 'B');
    pthread_create(&C, NULL, deal, 'C');
    pthread_create(&D, NULL, deal, 'D');
    pthread_create(&E, NULL, deal, 'E');

    //线程同步
    pthread_join(A, NULL);
    pthread_join(B, NULL);
    pthread_join(C, NULL);
    pthread_join(D, NULL);
    pthread_join(E, NULL);

    return 0;
}

在这里插入图片描述

D-A-X
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
死锁，进程和线程实验报告
03-02
死锁，进程和线程的实验报告，都是在red hat 9下实际运行过可行的代码，这份是完成以后写的实验报告，里面还有截图
linux进程与线程汇总.ppt
最新发布
10-20
Linux中的进程和线程是操作系统中的核心概念，它们在多任务环境中的运行和管理对于系统的高效运作至关重要。这里我们将深入探讨这两个概念以及相关的知识点。 **进程的概念与特性** 进程是操作系统中正在执行的一个...
linux死锁检测的一种思路
weixin_33881140的博客
03-26 247
前言: 　　上一篇博文讲述了pstack的使用和原理. 和jstack一样, pstack能获取进程的线程堆栈快照, 方便检验和性能评估. 但jstack功能更加的强大, 它能对潜在的死锁予以提示, 而pstack只提供了线索, 需要gdb进一步的确定. 　　那Linux下, 如何去检测死锁, 如何让死锁的检测能够更加的智能和方便? 这是本文的核心主旨, 让我们一同分享下思路. 常规做法: ...
进程死锁
rongwenbin的专栏
06-14 743
进程死锁     所谓死锁：是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。   虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件： 　　（1）
防止Linux线程死锁实验
m0_46965984的博客
12-04 692
实验目的： 理解死锁，理解死锁的预防，理解Linux线程控制。 实验环境： Ubuntu 8.0 或以上，Eclipse集成开发环境 实验内容： Linux的线程有两种，一种内核线程，一种用户线程。通常使用pthread线程库管理用户线程。线程管理库专门为每一个进程构造一个管理线程，负责处理线程相关的管理工作。当进程第一次调用pthread_create()创建一个线程时，就会创建并启动管理线程。 下面实例可能会发生死锁。要求修改实例，防止死锁发生。注意，不能修改汽车行走路线。 本程序模拟
嵌入式软件笔试面试题目大汇总.zip
06-03
理解它们的区别和联系至关重要，例如，进程间通信（IPC）机制、线程同步与互斥、死锁等概念，这些都是面试常考知识点。 其次是C/C++题目，作为嵌入式开发的基础语言，C和C++的掌握程度直接影响到开发者的能力。面试...
在Linux下基于gtk制作的音乐播放器_分段汇总.zip
07-30
总之，这个基于GTK的Linux音乐播放器项目是一个很好的实践平台，它涵盖了GUI编程、进程通信和多线程等关键技能。通过这个项目，你不仅可以提升编程技巧，还能深入理解Linux系统下的软件开发流程。
嵌入式linux vxworks面试题整理.docx
09-14
本文档汇总了嵌入式Linux VxWorks面试题，涵盖了嵌入式系统、Linux内核、VxWorks实时操作系统、进程管理、线程同步、互斥锁、消息队列、管道、信号量、共享内存、文件系统、网络管理、DHCP、RIP协议、Samba服务器、...
Linux平台PThreads库多线程编程笔记汇总
01-08
在传统的进程模型中，每个进程都有自己的独立内存空间，通过进程间通信（IPC）如管道、消息队列、共享内存等进行交互，这不仅增加了通信的复杂性，还可能导致性能下降。相比之下，线程则可以在同一地址空间内直接...
操作系统实验六 死锁问题实验
05-14
操作系统实验六：死锁问题实验报告。通过本实验观察死锁产生的现象，考虑解决死锁问题的方法。从而进一步加深对于死锁问题的理解。掌握解决死锁问题的几种算法的编程和调试技术。练习怎样构造管程和条件变量，利用管程机制来避免死锁和饥俄问题的发生。
操作系统原理学习笔记（十五）-死锁概述
asd123pwj的博客
12-19 205
文章首发及后续更新：https://mwhls.top/1156.html 新的更新内容请到mwhls.top查看。 无图/无目录/格式错误/更多相关请到上方的文章首发页面查看。 操作系统原理学习笔记目录 资源问题 可重用性资源：每个资源仅能分配给一个进程使用，不允许共享。使用资源时，先请求资源，再使用资源，最后释放资源。系统中该资源数目固定，进程运行时不能创建与删除。可消耗性资源：在进程运行时可变化。进程运行时可创建。进程运行时可消耗。资源一般由生产者创建，消费者消耗，典型的是进程间通信的消息。
Linux内核死锁检测：Lockdep详解与实战
Lockdep是一个内建的调试工具，用于跟踪和分析内核中锁的使用，特别是针对spinlock、mutex等类型的锁，以防止出现递归死锁和AB-BA死锁等常见问题。" Linux内核的死锁检测机制Lockdep是一个强大的工具，它通过记录和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

D-A-X

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值