操作系统实验——典型同步问题模拟处理编程与实现

最新推荐文章于 2024-07-25 15:50:18 发布
最新推荐文章于 2024-07-25 15:50:18 发布
阅读量1.9k 收藏 31
点赞数 4
分类专栏： 操作系统（OS） 文章标签： linux 运维 OS 经典进程同步问题 fork
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love521314123/article/details/120906768
版权

操作系统实验——典型同步问题模拟处理编程与实现

参考文章

1.问题描述

  1. 熟悉和运用 Linux 操作系统中系统调用 fork()的功能，编写程序调用 fork()创建两个子进程。父进程显示字符串‘Parent:’；两个子进分

    别显示字符串‘Child1:’和‘Child2:’。多次运行此程序，观察屏幕显示的结果，并分析原因。

  2. 了解、熟悉和运用 Windows（或 Linux）操作系统同步机制及编程方法，针对典型的同步问题，譬如生产者‐消费者问题、读者优先

    的读者‐写者问题、写者优先的读者‐写者问题、读者数限定的读者‐写者问题、哲学家就餐问题等（任选三个即可），编程模拟实现相

    应问题的解决方案。

2. fork()
  • 代码实现
#include <stdio.h>
#include <stdlib.h>

int main(){
    int p1,p2;
    while((p1=fork())==-1);
    if (p1==0)
        printf("Child1 \n");
    else
        {
          while((p2=fork())==-1);
          if (p2==0)
            printf("Child2 \n");
          else
            printf("Parent \n"); 
        }
    return 0;  
}
  • 运行结果

image-20211016190225802

3.生产者——消费者问题
  • 思路

image-20210806135800310

  • 代码实现
# include <stdio.h>
# include <stdlib.h>
# include <time.h>
# include <sys/types.h>
# include <pthread.h>
# include <semaphore.h>
# include <string.h>
# include <unistd.h>
#define BUFFER_SIZE 5

//empty  同步信号量，表示剩余空间的数量
//full 同步信号量，表示产品的数量
//mutex 互斥信号量，实现对缓冲区的互斥访问
sem_t empty, full, mutex;

typedef int buffer_item;

//缓冲区
buffer_item buffer[BUFFER_SIZE];

int in, out;

// 记录产品的id
int id = 0;

//生产产品
int insert_item(buffer_item item) {
    buffer[out] = item;
    out = (out + 1) % BUFFER_SIZE;
    return 0;
}

//消费产品
int remove_item(buffer_item *item) {
    // 将buffer[in]移除，并将item填充进去
    *item = buffer[in];
    in = (in + 1) % BUFFER_SIZE;
    return 0;
}

//生产者
void *producer(void* param) {
    long threadid = (long)param;
    while (1){
        sem_wait(&empty);
        sem_wait(&mutex);
        //生产产品
        insert_item(id);
        sleep(6);
        printf("ThreadId %ld : Producer produce product %d \n", threadid,id);
        id++;
        sem_post(&mutex);
        sem_post(&full);
    }
}

//消费者
void *consumer(void* param) {
    long threadid = (long)param;
    while (1){
        sem_wait(&full);
        sem_wait(&mutex);
        //消费产品
        int item;
        remove_item(&item);
        sleep(3);
        printf("ThreadId %ld : Consumer consume product %d \n", threadid ,item);
        sem_post(&mutex);
        sem_post(&empty);
    }
}

int main() {
    //线程id
    pthread_t tid[4];
    //对mutex进行初始化
    //第二个参数 不为０时此信号量在进程间共享，否则只能为当前进程的所有线程共享
    //第三个参数 给出了信号量的初始值。　　
    sem_init(&mutex, 0, 1);
    sem_init(&empty, 0, BUFFER_SIZE);
    sem_init(&full, 0, 0);
    in = out = 0;
    //两个生产者，两个消费者
    pthread_create(&tid[0], NULL ,consumer, (void*)0);
    pthread_create(&tid[1], NULL ,producer, (void*)1);
    pthread_create(&tid[2], NULL ,consumer, (void*)2);
    pthread_create(&tid[3], NULL, producer, (void*)3);
    //用户输入q，结束进程
    int c=0;
    while (1){
        c = getchar();
        if (c=='q' || c=='Q'){
            for (int i = 0; i < 4; ++i) {
                pthread_cancel(tid[i]);
            }
            break;
        }
    }
    //释放信号量
    sem_destroy(&mutex);
    sem_destroy(&empty);
    sem_destroy(&full);
    return 0;
}

  • 实验结果

    image-20211020155958008

4.读者优先的读者-写者问题
  • 代码实现
# include <stdio.h>
# include <stdlib.h>
# include <time.h>
# include <sys/types.h>
# include <pthread.h>
# include <semaphore.h>
# include <string.h>
# include <unistd.h>

// wrt(记录型信号量) 用于实现对文件的互斥访问
// mutex 用于对count变量的互斥访问
sem_t wrt, mutex;
//记录当前有几个读进程在访问文件
int readCount;

//读者
void* Reader(void* param) {
    long threadid = (long)param;
    while (1){
        // P操作，各进程互斥地访问 mutex
        sem_wait(&mutex);
        readCount++;
        if(readCount == 1)
            sem_wait(&wrt);
        //  V操作
        sem_post(&mutex);
        printf("Thread %ld: is reading\n", threadid);
        sleep(3);
        sem_wait(&mutex);
        readCount--;
        if(readCount == 0)
            sem_post(&wrt);
        sem_post(&mutex);
    }
}

//写者
void* Writer(void* param) {
    long threadid = (long)param;
    while (1){
        sem_wait(&wrt);
        printf("Thread %ld: is writing\n", threadid);
        sleep(5);
        sem_post(&wrt);
    }
}

int main() {
    sem_init(&mutex, 0, 1);
    sem_init(&wrt, 0, 1);
    readCount = 0;
    pthread_t tid[4];
    //两个写者、两个读者
    pthread_create(&tid[0], NULL ,Writer, (void*)0);
    pthread_create(&tid[1], NULL, Writer, (void*)1);
    pthread_create(&tid[2], NULL ,Reader, (void*)2);
    pthread_create(&tid[3], NULL ,Reader, (void*)3);
    int c=0;
    while (1){
        c = getchar();
        if (c=='q' || c=='Q'){
            for (int i = 0; i < 4; ++i) {
                pthread_cancel(tid[i]);
            }
            break;
        }
    }
    //信号量销毁
    sem_destroy(&mutex);
    sem_destroy(&wrt);
    return 0;
}

  • 运行结果

    • 写者线程先到达，开始运行，之后读者线程到达，对文件资源进行P操作，写者线程进入阻塞状态，读者线程开始运行。

    image-20211020164016333

5.写者优先的读者-写者问题
  • 代码实现
/*
* 	写者优先
*/

# include <stdio.h>
# include <stdlib.h>
# include <time.h>
# include <sys/types.h>
# include <pthread.h>
# include <semaphore.h>
# include <string.h>
# include <unistd.h>


// RWMutex 读写互斥
// mutex1 readCount互斥
// mutex2 writeCount互斥
// wrt 写者互斥
// mutex3的主要用处就是避免写者同时与多个读者进行竞争，读者中信号量RWMutex比mutex3先释放，则一旦有写者，写者可马上获得资源。
sem_t RWMutex, mutex1, mutex2, mutex3, wrt;
//用于记录正在等待的写者的数目
int writeCount, readCount;


//读者
void* Reader(void* param) {
    long threadid = (long)param;
    while (1){
        //p操作
        sem_wait(&mutex3);
        sem_wait(&RWMutex);
        sem_wait(&mutex2);
        readCount++;
        if(readCount == 1)
            sem_wait(&wrt);
        //v操作
        sem_post(&mutex2);
        sem_post(&RWMutex);
        sem_post(&mutex3);
        sleep(3);
        printf("Thread %ld: is reading\n", threadid);
        sem_wait(&mutex2);
        readCount--;
        if(readCount == 0)
            sem_post(&wrt);
        sem_post(&mutex2);
    }
}

//写者
void* Writer(void* param) {
    long threadid = (long)param;
    while (1){
        sem_wait(&mutex1);
        writeCount++;
        if(writeCount == 1){
            sem_wait(&RWMutex);
        }
        sem_post(&mutex1);
        sem_wait(&wrt);
        sleep(5);
        printf("Thread %ld: is writing\n", threadid );
        sem_post(&wrt);
        sem_wait(&mutex1);
        writeCount--;
        if(writeCount == 0) {
            sem_post(&RWMutex);
        }
        sem_post(&mutex1);
    }
}

int main() {
	//初始化信号量
    sem_init(&mutex1, 0, 1);
    sem_init(&mutex2, 0, 1);
    sem_init(&mutex3, 0, 1);
    sem_init(&wrt, 0, 1);
    sem_init(&RWMutex, 0, 1);

    readCount = writeCount = 0;
    pthread_t tid[4];
	//两个读者，两个写者
    pthread_create(&tid[0], NULL ,Reader, (void*)0);
    pthread_create(&tid[1], NULL ,Reader, (void*)1);
    pthread_create(&tid[2], NULL ,Writer, (void*)2);
    pthread_create(&tid[3], NULL, Writer, (void*)3);
    int c=0;
    while (1){
        c = getchar();
        if (c=='q' || c=='Q'){
            for (int i = 0; i < 4; ++i) {
                pthread_cancel(tid[i]);
            }
            break;
        }
    }
	//信号量销毁
    sem_destroy(&mutex1);
    sem_destroy(&mutex2);
    sem_destroy(&mutex3);
    sem_destroy(&RWMutex);
    sem_destroy(&wrt);
    return 0;
}

  • 实验结果

    image-20211020164142857

6.读者数量有限的读者-写者问题
  • 思路

添加一个信号量，初始化为5，当读者进入时，进行P操作。退出时，进行V操作。

  • 代码实现

    # include <stdio.h>
# include <stdlib.h>
# include <time.h>
# include <sys/types.h>
# include <pthread.h>
# include <semaphore.h>
# include <string.h>
# include <unistd.h>

// wrt(记录型信号量) 用于实现对文件的互斥访问
// mutex 用于对count变量的互斥访问
sem_t wrt, mutex, readerNum;

//记录当前有几个读进程在访问文件
int readCount;

//读者
void* Reader(void* param) {
    long threadid = (long)param;
    while (1){
        //p操作
        sem_wait(&readerNum);
        sem_wait(&mutex);
        readCount++;
        if(readCount == 1)
            sem_wait(&wrt);
        //V操作
        sem_post(&mutex);
        printf("Thread %ld: is reading\n", threadid);
        sleep(3);
        sem_wait(&mutex);
        readCount--;
        if(readCount == 0)
            sem_post(&wrt);
        sem_post(&mutex);
        sem_post(&readerNum);
    }
}

//写者
void* Writer(void* param) {
    long threadid = (long)param;
    while (1){
        sem_wait(&wrt);
        printf("Thread %ld: is writing\n", threadid);
        sleep(5);
        sem_post(&wrt);
    }
}


int main() {
    //初始化信号量
    //读者数量限定为5
    sem_init(&readerNum,0,5);
    sem_init(&mutex, 0, 1);
    sem_init(&wrt, 0, 1);
    readCount = 0;
    pthread_t tid[10];
    //创建6个读者线程，观察第六个读者能否运行
    for (int i = 0; i < 6; ++i) {
        pthread_create(&tid[i], NULL ,Reader, (void*)i);
    }
    pthread_create(&tid[7], NULL, Writer, (void*)6);
    pthread_create(&tid[8], NULL, Writer, (void*)7);
    int c=0;
    while (1){
        c = getchar();
        if (c=='q' || c=='Q'){
            for (int i = 0; i < 8; ++i) {
                pthread_cancel(tid[i]);
            }
            break;
        }
    }
    //信号量销毁
    sem_destroy(&mutex);
    sem_destroy(&wrt);
    return 0;
}

  • 实验结果

    • 读者数量限制为5，因此只有5个读者线程可以运行，其余的读者线程和写者线程进入阻塞状态。

    image-20211022151726705

7.哲学家就餐问题

  • 思路：假如五位哲学家同时饥饿而各自拿起左边的筷子时，就会使五个信号量chopstick均为0，当他们再试图去拿右边的筷子时，都将因无筷子可拿而无限等待。进入死锁状态。因此我们限定仅当一个哲学家左右两支筷子都可用时才允许他抓起筷子。

  • 代码实现

# include <stdio.h>
# include <stdlib.h>
# include <time.h>
# include <sys/types.h>
# include <pthread.h>
# include <semaphore.h>
# include <string.h>
# include <unistd.h>

//mutex互斥的取筷子
sem_t chopstick[5],mutex;
void *eat_think(void *arg)
{
    int phi = (int)arg;
    while (1){
        sem_wait(&mutex);
        sem_wait(&chopstick[phi]);       //拿左
        sem_wait(&chopstick[(phi+1)%5]); //拿右
        printf("Philosopher %d fetches chopstick %d\n",phi,phi);
        printf("Philosopher %d fetches chopstick %d\n",phi,phi+1);
        sem_post(&mutex);
        sleep(5); //吃饭
        printf("Philosopher %d is eating \n",phi);
        sem_post(&chopstick[phi]);
        sem_post(&chopstick[phi+1]);
        printf("Philosopher %d release chopstick %d\n", phi, phi);
        printf("Philosopher %d release chopstick %d\n", phi, phi+1);
        //思考
        sleep(3);
    }
}
int main() {
    //线程id
    pthread_t tid[5];

    sem_init(&mutex,0,1);
    for (int i = 0; i < 5; ++i) {
        sem_init(&chopstick[i],0,1);
    }
    //    sem_init(&mutex, 0, 1);
    for (int i = 0; i < 5; ++i) {
        pthread_create(&tid[i] ,NULL, eat_think,(void *)i);
    }
    int c=0;
    while (1){
        c = getchar();
        if (c=='q' || c=='Q'){
            for (int i = 0; i < 4; ++i) {
                pthread_cancel(tid[i]);
            }
            break;
        }
    }
    return 0;
}
  • 实验结果

image-20211022152004671

一只不吃老鼠的猫
关注
  • 4
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OS实验二【典型同步问题模拟处理编程设计与实现】
书启鸿蒙知秋枫
03-25 2244
一、实验目的 1、加深对进程概念的理解，明确进程和程序的区别。 2、探索、理解并掌握操作系统同步机制的应用编程方法，针对典型的同步问题，构建基于Windows（或 Linux）操作系统同步机制的解决方案。 二、实验内容 1、熟悉和运用 Linux操作系统中系统调用fork()的功能，编写程序调用fork()创建两个子进程。父进程显示字符串‘Parent:’；两个子进程分别显示字符串‘Child1:’和‘Child2:’。多次运行此程序，观察屏幕显示的结果，并分析原因。 2、了解、熟悉和运用
操作系统实验（3）—— 典型同步问题模拟处理编程设计与实现
zyw2002的博客
05-09 1237
📖 操作系统实验—— 典型同步问题模拟处理编程设计与实现 文章目录Lab6: 典型同步问题模拟处理编程设计与实现1. 实验目的2. 实验要求3. 实验内容3.1 生产者-消费者问题3.1.1 问题描述3.1.2 编程实现3.1.3 结果分析3.2 读者写者问题（读者优先、写者优先）3.2.1 问题描述3.2.2 编程实现3.2.2.1 读者优先3.2.2.2 写者优先3.2.3 结果分析3.3 哲学家就餐3.3.1 问题描述3.3.2 编程实现3.3.2.1 解法13.3.2.2 解法23.3.2.2.
操作系统实验——进程同步（读者写者）C++代码实现
Carmelo_7的博客
11-03 7333
一、实验目的 现代操作系统的核心是多道程序设计、多处理器和分布式处理器，这些方案和操作系统设计技术的基础都是并发。当多个进程并发执行时，不论是在多处理器系统的情况下，还是在单处理器多道程序系统中，都会出现冲突和合作的问题。 理解操作系统中用互斥和同步解决问题。用信号量机制分别实现读者优先和写者优先的读者-写者问题从而掌握互斥与同步的基本理念。 二、实验内容 在Windows 环境下，创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件（后面有介绍）的要求进行读
操作系统实验四、进程同步实验——抽烟者问题
碎片
10-01 5693
抽烟者问题 问题描述 假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。 请用以上介绍的 IP...
操作系统实验报告：进程同步问题——模拟生产者消费者问题（java实现）
XihuDacuyu的博客
12-08 912
将curNum（缓冲区中的现有数据量），maxNum（缓冲区中最大数据量），lock（互斥锁）封装在静态mutex类中。生产者在缓冲区满后，进入休眠。直到消费者在缓冲区中消耗数据后，生产者才会被唤醒。消费者在缓冲区空后，进入休眠。直到生产者向缓冲区中添加数据后，消费者才会被唤醒。64 位操作系统, 基于 x64 的处理器 / SublimeText3。每次生产者生产一次或者消费者消费一次，唤醒其他所有线程。模拟生产者消费者问题。
实验报告linux进程同步与互斥,操作系统实验报告——进程同步与互斥
weixin_39850787的博客
05-05 1827
..页脚 《进程同步与互斥》实验报告实验序号：01 实验项目名称：进程同步与互斥 学 号姓 名 专业、班 实验地点指导教师 时间 一、实验目的1、掌握基本的进程同步与互斥算法，理解生产者-消费者问题。2、学习使用Windows 2000/XP 中基本的同步对象，掌握相关API 的使用方法。3、了解Windows 2000/XP 中多线程的并发执行机制...
操作系统实验——哲学家进餐问题
m0_64847413的博客
01-23 2750
哲学家进餐问题
【操作系统原理】—— 信号量与PV操作实现
ZShiJ的博客
11-15 594
信号量是一个计数器，表示可用资源的数量。信号量的值可以是任意非负整数。在多线程或多进程环境中，信号量用于控制对共享资源的访问。 PV 操作： P（Produce）操作： 也称为 Wait 操作。执行 P 操作时，信号量的值减一，表示占用了一个资源。如果信号量的值为负数，表示资源不足，执行 P 操作的线程或进程将被阻塞，直到有足够的资源。 V（Vaporize）操作： 也称为 Signal 操作。执行 V 操作时，信号量的值加一，表示释放了一个资源。如果有其他线程或进程正在等待资源，
操作系统实验——进程调度
taylorswift的博客
03-07 6914
进程调度算法实现 摘要： 实现了进程调度算法，包括FCFS(先进先出)，SPF(短进程优先)，HRRF（最高响应比优先法），HPF（优先级法）算法，设计了一个允许 n 个进程并发运行的进程管理模拟系统。该系统包括有简单的进程控制、同步，其进程调度算法可任意选择。 初始值： 进程名 到达时间 服务时间 优先级 a 0 4 0 b 1 3 1 c 2 5 2 d 3 2 3 e 4 4 4 算法描述 FCFS(先进先出)：每次从就绪队列选择最先进入队列的进程，然后一直运行，直到进程退出或被阻塞，才会继续从队列中
操作系统实验——进程的同步与互斥（读者写者问题）
03-21
以生产者消费者模型为基础，在Windows环境下创建一个控制台进程，在该进程中创建读者写者线程模拟生产者和消费者。写者线程写入数据，然后将数据放置在一个空缓冲区中供读者线程读取。读者线程从缓冲区中获得数据，...
操作系统实验报告——进程同步与互斥.doc
07-13
本实验报告的主要目的是研究进程同步与互斥的机制，通过使用 Windows 2000/XP 操作系统和 Visual C++ 6.0 开发环境，设计并实现生产者-消费者模型，以实现进程的同步与互斥。 实验目的 1. 掌握基本的进程同步与...
进程间同步互斥问题——银行柜员服务问题1
08-03
在操作系统中，进程间的同步和互斥是多线程编程中的核心概念。在银行柜员服务问题中，这些概念得到了实际的应用。该问题模拟了一个银行环境，其中n个柜员为顾客提供服务。为了解决这个问题，我们需要用到P、V操作...
操作系统实验作业——linux系统调用学习，重定向、管道、多进程、多线程编程技术实现.zip
04-21
在本实验作业中，我们将深入学习Linux操作系统中的系统调用，并通过实践掌握重定向、管道、多进程以及多线程编程技术。下面将详细阐述这些知识点。 1. Linux系统调用： Linux系统调用是用户程序与操作系统内核交互...
进程同步实验——生产者与消费者问题算法实现
12-11
在这个实验“进程同步实验——生产者与消费者问题算法实现”中，我们探讨了一个经典的并发问题：生产者-消费者问题。 生产者-消费者问题是多线程编程中的一种典型应用场景，模拟了实际生产流水线的过程。在这个问题...
Linux玩转指南
qq_43535970的博客
07-25 843
Linux是一个类Unix操作系统，最初由Linus Torvalds于1991年发布。它是基于开源的内核，并结合了大量的开源软件，形成了完整的操作系统。Linux的设计理念强调开源和自由，使得它在全球范围内得到广泛应用，从个人电脑到服务器、嵌入式系统，甚至超级计算机。
【linux】Shell脚本三剑客之grep和egrep命令的详细用法攻略
景天科技苑
07-25 4430
在Linux和Unix系统中，grep（Global Regular Expression Print）是一个非常强大的文本搜索工具，能够根据用户指定的模式（由正则表达式和文本字符组合而成）对目标文件进行逐行搜索，并显示匹配到的行。而egrep（Extended Grep）则是`grep`的扩展版本，支持更多的正则表达式语法。尽管egrep在较新的系统中被`grep -E`选项所取代，但了解其用法对于理解和使用正则表达式仍然具有重要意义。
Linux初学基本命令
最新发布
yuan20010401的博客
07-25 628
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
Linux 常用命令分类及示例
简介
07-25 926
【代码】Linux 常用命令分类及示例。
生产者消费者算法实验：互斥与同步的模拟实现
这个实验对于理解操作系统中的并发控制、线程同步以及互斥量（mutex）等概念具有重要意义，是实践中理解和应用多线程编程的基础之一。通过实际编写和调试代码，学生能够掌握如何在多任务环境下协调线程的行为，避免...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值