实验三 进程线程同步编程练习

于 2022-11-03 18:49:26 发布
阅读量262 收藏 5
点赞数 1
分类专栏： 操作系统 文章标签： c++ centos linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51498828/article/details/127676023
版权

1.实现多个进程之间互斥访问临界资源（进程个数不限，先写出PV操作的伪算法，然后进行算法实现）

创建信号量

semid=semget(IPC_PRIVATE,1,0666|IPC_CREAT);

信号量赋初值

semctl(semid,0,SETVAL,1);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
int room = 0;
char ch;
int main(int argc,char argv[]) {
    pid_t pid;
    pid_t pids[2];
    int i=0;
    int j=0;
    struct sembuf sem_b;
    sem_b.sem_num=0;
    sem_b.sem_flg=SEM_UNDO;//操作标志SEM_UNDO，进程意外结束恢复信号量操作
//创建控制进入房间的信号量
room=semget(IPC_PRIVATE,1,0666|IPC_CREAT);
//互斥信号量room赋初值为1
    semctl(room,0,SETVAL,1); // 设置信号集中的一个单独信号量的值     
 for (i=0;i<2;i++) {
        pid=fork();
        if (pid==0){
            while(1){
                printf("%d want to  enter room--WAIT\n",i);
                sem_b.sem_op = -1;//定义申请资源操作，操作数量为1个，负数表示P操作       ( # ) 
                semop(room,&sem_b,1);//此两句是信号量操作的申请wait           ( # )
                printf("%d is in room\n",i);            (*)
                sleep(3);                 
                sem_b.sem_op = 1;//定义释放资源操作，操作数量为1个，正数表示V操作           ( # )
                semop(room,&sem_b,1);//此两句是信号量操作的释放signal           ( # )
                printf("%d is out of room---SIGNAL OK\n",i);
            }//while
        } else{ pids[i]=pid;}
    }//for
do{
        ch=getchar();
        if (ch == 'q')
            for (i=0;i<2;i++)
                kill(pids[i],SIGTERM);//退出进程运行
    }while(ch != 'q');
} //main

 

 

如图所见，进程0,1，2在不断的进进出出，先请求，wait，0进程先进去，1,2在外面等待，等0出去之后1,2按等待顺序进入，这里的是2先等待的则2先进去了，0等待，2出去后，之前在外面等的1 再进去，最后1出，0进。

如果for（i=0;i<2；i++）则只有两个进程，0,1进程，就是0进程先申请房间，之后0进入，1在外面等待，0出1进，1出0进，两个进程之间就是简单互斥关系。

 

2.不死锁的哲学家进餐问题（课本有3种解决方法，可以选择一种或多种，先写出PV操作的伪算法，然后进行算法实现）

创建线程函数 —— pthread_create

终止线程 —— pthread_cancel、pthread_exit

线程等待 —— pthread_join

Semaphore chopstick[5]={1,1,1,1,1};//初始化信号量

Semaphore mutex=l;//设置取筷子信号量

Pi(){

while(1){

          wait(mutex);//等待提取信号量

          wait(chopstick[ i ]);//取左边筷子

          wait(chopstick[ ( i +1) %5] );//去右边筷子

          Eat;

          signal(chopstick[ i ]);//放回左边筷子

          signal(chopstick[ ( i +1) % 5] );//放回右边筷子

          signal(mutex);

          think;

      }

}

#include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   #include <sys/types.h>
   #include <sys/ipc.h>
   #include <sys/sem.h>
   #include <errno.h>
   #include <fcntl.h>
   #include <signal.h>
  int p(int sem_id)
  {
  struct sembuf sem_b;
  sem_b.sem_num = 0;
  sem_b.sem_op = -1;
  sem_b.sem_flg = SEM_UNDO;

  if(semop(sem_id,&sem_b,1) == -1)
  {
  fprintf(stderr, "P failed\n");
  return 0;
  }
  return 1;
  }

  int v(int sem_id)//将信号量操作封装到函数中，提高代码可读性
  {
  struct sembuf sem_b;
  sem_b.sem_num = 0;
  sem_b.sem_op = 1;
  sem_b.sem_flg = SEM_UNDO;

  if(semop(sem_id,&sem_b,1) == -1){
  fprintf(stderr, "v failed\n");
  return 0;
  }
  return 1;
  }

  int roomnum=0;
  char chopsticks[5];
  int main(int argc,int  *argv[])
 {pid_t pid;
  pid_t pids[5];
  int i;
  char ch;
  roomnum=semget(IPC_PRIVATE,1,0666|IPC_CREAT);
  semctl(roomnum,0,SETVAL,4);
  for(i=0;i<5;i++)
  {chopsticks[i]=semget(IPC_PRIVATE,1,0666|IPC_CREAT);//设置chopsticks信号量用于控制对筷子的资源使用
  semctl(chopsticks[i],0,SETVAL,1);}//设置信号量（筷子数量）初值为1
  for(i=0;i<5;i++){
  pid=fork();
  if(pid==0){
  while(1){
  printf("p %d is thinking,he is not hungry\n",i);
  sleep(1);

  p(roomnum);
  printf("p %d is hungry,so he enters to room\n",i);

  p( chopsticks[i]);
  printf("p %d take the left chopsticks\n",i);

  p( chopsticks[(i+1)%5]);
  printf("p %d take the right chopsticks\n",i);

  printf("p %d is eating!\n",i);
  sleep(5-i);

  printf("p %d ends to eat\n",i);

  v( chopsticks[(i+1)%5]);
  printf("p %d put off the right chopsticks\n",i);

  v( chopsticks[i]);
  printf("p %d put off the left chopsticks\n",i);

  v(roomnum);
  printf("p %d goes out the room and thinks\n",i);}}
  else
  {pids[i]=pid;}}
  do{
  ch=getchar();
  if(ch=='q'){
  for(i=0;i<5;i++){
  kill(pids[i],SIGTERM);}}}
  while(ch!='q');
}

  1. 三个进程P1、P2、P3互斥使用一个包含N个单元的缓冲区。P1每次用produe()产生一个正整数并用put()送入缓冲区某一空单元中；P2每次用getodd()从该缓冲区中取出一个奇数并用countodd()统计奇数个数；P3每次用geteven()从该缓冲区中取出一个偶数并用counteven()统计偶数个数。请用信号量机制实现这三个进程的同步和互斥活动，并说明所定义信号量的含义。（先写出PV操作的伪算法，然后进行算法实现）

PV操作伪算法:

Semaphore mutex=1;   //互斥信号量

Semaphore odd=0;    //奇数个数

Semaphore even=0;    //偶数个数

Semaphore empty=N； //N个缓冲区单元

P1()                           p2()                p3()

{while(1)                     {while(1)           {while(1)

{  p(empty);                   {p(odd);            { p(even);

 int x= Produce();             p(mutex);            p(mutex);

P(mutex);                       getodd();            geteven();

Put(x);                          countodd();          counteven();

V(mutex);                       v(mutex);            v(mutex);

 if(x%2!=0)//奇数               v(empty);             v(empty);

{v(odd);}                  }                    }

Else                      }                    }

{v(even);}//偶数

}

}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
  int p(int sem_id){

  struct sembuf sem_b;
  sem_b.sem_num = 0;
  sem_b.sem_op = -1;
  sem_b.sem_flg = SEM_UNDO;

  if(semop(sem_id,&sem_b,1) == -1)
  {
  fprintf(stderr, "P failed\n");
  return 0;
  }
  return 1;
  }
 int v(int sem_id){

  struct sembuf sem_b;
  sem_b.sem_num = 0;
  sem_b.sem_op = 1;
  sem_b.sem_flg = SEM_UNDO;

  if(semop(sem_id,&sem_b,1) == -1){
  fprintf(stderr, "v failed\n");
  return 0;
  }
  return 1;
  }

  int n;
  int odd=0;
  int even=0;
  int empty=0;
  int full=0;
  int mutex=1;
  int countodd=0;
  int counteven=0;
  int main(int argc,int argv[])
 {
  int i;
  printf("请输入个数N的大小:\n");
  scanf("%d",&n);
  pid_t pid;
  pid_t pids[3];
  char ch;
  mutex=semget(IPC_PRIVATE,1,0666|IPC_CREAT);
  semctl(mutex,0,SETVAL,1);

  empty=semget(IPC_PRIVATE,1,0666|IPC_CREAT);
  semctl(empty,0,SETVAL,n);

  full=semget(IPC_PRIVATE,1,0666|IPC_CREAT);
  semctl(full,0,SETVAL,0);

  odd=semget(IPC_PRIVATE,1,0666|IPC_CREAT);
  semctl(odd,0,SETVAL,0);

  even=semget(IPC_PRIVATE,1,0666|IPC_CREAT);
  semctl(even,0,SETVAL,0);

 for(i=0;i<3;i++)
  {
  pid=fork();
  if(pid==0&&i==0)
  {while(1)
  {p(mutex);
  p(empty);
  sleep(1);
  int m=rand();
  printf("放入随机数%d\n",m);
  if(m%2==0)
  {v(even);
  }
 if(m%2==1){
  v(odd);
  }
  v(mutex);
  v(full);
  }}

  if(pid==0&&i==1)
  {while(1)
  {p(full);
  p(mutex);
  sleep(1);
  p(odd);
  countodd+=1;
  printf("奇数个数为:%d\n",countodd);
  v(mutex);
  v(empty);
  }}

 if(pid==0&i==2)
 {while(1)
 {p(full);
 p(mutex);
 sleep(1);
 p(even);
 counteven+=1;
 printf("偶数个数为:%d \n",counteven);
 v(mutex);
 v(empty);
 }}
 else
 {pids[i]=pid;}}
 do{
  ch=getchar();
  if (ch == 'q'){
   for (i=0;i<3;i++){
     kill(pids[i],SIGTERM);}}
     }while(ch != 'q');
 }

 

 

CuSo₄·5H₂O原来是蓝矾
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程同步编程实例
02-24
C语言编写的进程同步编程实例。可以参考使用semget semctl semop等函数。
操作系统 实验三 进程线程同步编程练习
qq_55793988的博客
07-12 1206
【要求】所有练习题保留题目要求，在题目要求后面作答： 代码要求有注释，代码中适当标注关键代码为红色。 要有运行结果的截图。 每题最后应该有对程序的适当分析和总结！ 注意格式排版，内容分析注意列条目，展开清楚地阐述。 1、实现多个进程之间互斥访问临界资源（进程个数不限，先写出PV操作的伪算法，然后进行算法实现） 2、不死锁的哲学家进餐问题（课本有3种解决方法，可以选择一种或多种，先写出PV操作的伪算法，然后进行算法实现） 3、三个进程P1、P2、P3互斥使用一个包含N个单元的缓冲区。P
Java入门到精通——基础篇之多线程实现简单的PV操作的进程同步
weixin_30345055的博客
03-21 312
一、概述 PV操作是对信号量进行的操作。 进程同步是指在并发进程之间存在一种制约关系，一个进程的执行依赖另一个进程的消息，当一个进程没有得到另一个进程的消息时应等待，直到消息到达才被唤醒。举例：就像消费者与生产者的关系，说吃馒头把有一个碗能盛下6个馒头，厨师不停的生产馒头，顾客不停的吃馒头，此时厨师与顾客的关系就是同步。（如下图） ...
操作系统进程同步练习题
wjz0626的博客
03-17 2191
1.题目：桌上有一个能盛得下五个水果的空盘子。爸爸不停的向盘子中放苹果或者桔子，儿子不停的从盘子中取出桔子享用，女儿不停的从盘中取出苹果享用。规定三人不能同时使用盘子。试用信号量实现爸爸、儿子、女儿这三个循环进程之间的同步。 代码： //苹果，橘子，盘子是临界资源 semaphore mutex = 1, plate = 5, apple = 0, orange = 0; void father() { while (true) { buy fruits; ...
操作系统实验(三)线程的互斥
05-10
### 操作系统实验(三)线程的互斥 #### 实验目的 本实验旨在让学生通过实践操作深入了解和掌握在Windows系统环境下线程的创建与撤销的方法，熟悉并使用Windows系统提供的线程互斥API来解决多线程访问共享资源时产生...
vs三个进程同步模拟打印过程（源码和解析报告）
03-16
在IT领域，进程同步是一个重要的概念，特别是在多线程或多进程编程中。本文将深入探讨在Visual Studio（VS）环境下，如何通过三个进程同步协作来模拟打印过程。这个实验涉及了P1、P2和P3三个进程以及两个缓冲区L1和...
VC++多线程与多进程编程
07-14
8. 实验与案例：提供实际操作练习，帮助学生巩固理论知识，通过实验验证多线程和多进程编程的效果。 总之，这份资料为初学者提供了全面的VC++多线程与多进程编程教程，不仅涵盖了基本概念，还涉及实践应用和问题...
操作系统实验二 进程通信机制的应用
05-14
6. 通过编程练习Linux中与进程/线程创建与控制相关的系统调用，如`pipe`用于创建无名管道，`write`和`read`进行数据传输。 实验环境中，硬件为PC，软件环境为Linux操作系统。实验代码示例中，使用了`pthread`库创建...
操作系统进程实验报告
04-25
总结来说，这个实验不仅提供了实际编程练习，还加深了对操作系统中进程同步、互斥、线程控制等核心概念的理解。通过解决生产者-消费者问题，学生们能够更好地掌握并发编程中的同步与互斥策略，并能应用到实际系统...
编程实现进程（线程）同步和互斥
11-25
在Windows等操作系统下，使用的VC、VB、java或C等编程语言，采用进程（线程）同步和互斥的技术编写程序实现生产者-消费者问题或哲学家进餐问题或读者-写者问题或自己设计一个简单进程（线程）同步和互斥的实际问题。
进程同步-生产者和消费者（PV操作实现——java多线程模拟）
启人zhr的博客
12-29 9726
进程同步-生产者和消费者（PV操作实现——java多线程模拟）目录进程同步-生产者和消费者PV操作实现java多线程模拟 目录 生产者和消费者概述 PV操作解决生产者和消费者 任务要求 程序代码 运行结果 生产者和消费者概述 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的
进程同步问题经典例题(生产者消费者等)
一氧化二氢的执着
01-07 1162
文章目录0. 前言1. PV操作2. 同步与互斥模型3. 生产者-消费者问题4. 读者-写者问题5. 哲学家进餐问题 0. 前言 在 OS 中引入进程后，虽然提高了资源的利用率和系统的吞吐量，但由于进程的异步性， 也会给系统造成混乱，尤其是在他们争用临界资源时。例如，当多个进程去争用一台打印 机时，有可能使多个进程的输出结果交织在一起，难于区分；而当多个进程去争用共享变 量、表格、链表时，有可能致...
进程同步经典例题
liudongdong_jlu
04-11 8223
1.信号量机制信号量机制即利用pv操作来对信号量进行处理。什么是信号量？信号量（semaphore）的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；p(可理解占用）当它的值小于0时，其绝对值表示等待使用该资源的进程个数。v(可理解生产，释放占用资源）注意，信号量的值仅能由PV操作来改变。     一般来说...
进程同步与PV操作
qq_32534441的博客
04-28 2183
进程同步： https://blog.csdn.net/qq_32534441/article/details/88948281 PV操作简单理解： https://blog.csdn.net/qq_32534441/article/details/88949763 进程同步的经典问题：司机售票员&问题生产者消费者问题&哲学家进餐问题&读者写者问题： https://blo...
进程同步及线程同步的几种机制
热门推荐
heart威名海的博客
09-14 1万+
进程中线程同步的四种常用方式： 1. 互斥量： 采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限。因为互斥对象只有一个，所以可以保证公共资源不会被多个线程同时访问。 2. 信号量： 它允许同一时刻多个线程来访问同一资源，但是需要控制同一时刻访问此资源的最大线程数量。 3. 事件（信号）：通过通知操作的方式来保持多线程同步，还可以方便实现多线程优先级的比较作。 4.临界区：临界...
进程管理---经典进程的同步问题及练习
当当的博客
11-12 1184
一、生产者–消费者问题 生产着消费者问题即多个生产者和消费者对n个缓冲区的使用。 若不考虑互斥、同步问题会导致counter计数错误。 无论生产者、消费者使用缓冲池时应保证互斥使用（互斥信号量mutex ） 生产者和消费者间交叉有序： ①有序的控制最根源在产品数量上。 ②设置两个信号量：分别针对生产者、消费者设置不同的信号量，empty和full分别表示缓冲池中空缓冲池和满缓冲池（即产品）的数量...
用PV操作解决经典进程同步问题 C#实现
工作栈
01-12 3291
  在C#中，用于同步的主要是Mutex类与Semaphore类。位于System.Threading命名空间中。 在这两个种对象的方法中，P操作对应的是WaitOne()方法，V操作对应的是ReleaseMutex()与Release()方法。 下面是用C#解决几大PV操作经典问题及其变形的代码。 一、生产者消费者问题 1.最简单的情况：一个生产者，一个消费者，共用一
进程或线程同步互斥的控制方法
u010434655的专栏
11-05 847
四种进程或线程同步互斥的控制方法   互斥量与临界区可以跨越进程使用，但创建互斥量需要的资源更多，所以如果只为了在进程内部是用的话使用临界区会带来速度上的优势并能够减少资源占用量 。因为互斥量是跨进程的互斥量一旦被创建，就可以通过名字打开它。 互斥量（Mutex），信号量（Semaphore），事件（Event）都可以被跨越进程使用来进行同步数据操作，而其他的对象与数据同步操作无关，但对于进程
POSIX线程编程指南
"这篇文档是关于POSIX线程编程的教程，由Blaise Barney创作，来自Lawrence Livermore National Laboratory。教程涵盖了POSIX线程的基本概念、API接口、线程管理、互斥锁、条件变量以及监控调试工具等内容，旨在帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值