山东大学操作系统实验四——进程同步实验

最新推荐文章于 2023-03-08 23:05:13 发布
最新推荐文章于 2023-03-08 23:05:13 发布
阅读量6.8k 收藏 97
点赞数 29
分类专栏： 操作系统实验 文章标签： 操作系统 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43671574/article/details/105704079
版权

实验四、进程同步实验 独立实验——抽烟者问题

实验题目：

抽烟者问题。假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。 请用以上介绍的 IPC 同步机制编程，实现该问题要求的功能。

题目分析：

  • 题中有五个角色：三个抽烟者，两个生产者
  • 生产者循环供应a b c中的两种：ab、bc、ac、ab……
  • 某个消费者无限拥有a b c中的一个，而一直在等另外两个产品
  1. 因此生产者之间必要一个信号量用来同步生产者的生产（即不允许同时访问缓存区）
  2. 缓存区需要控制满和空，因此需要一个信号量同步缓存区，防止满了依然生产或者空了消费者依然获取。为了简单起见，缓存区的大小设置为1个即可，由于循环访问缓存区，缓存区的大小对实验的正确性没有影响。
  3. 三个消费者之间需要的东西不同，所以各自独立编写文件，并各自拥有一个信号量
  • 总之，本题需要五个信号量，命名和作用如下：
    all：缓存区的空或满。
    producer：生产者生产同步信号量。
    ab、ac、bc：分别是三个消费者的独立信号量。

生产者和消费者的伪代码

生产者:
while(1){
	P(all);
	P(producer);
	生产产品
	V(producer);
	if(生产的产品)
		V(对应的消费者);
}
消费者:
while(1){
	P(自己的信号量);
	抽烟
	V(all);
}

实验完整代码

头文件ipc.h：
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#define BUFSZ 256
//建立或获取 ipc 的一组函数的原型说明
int get_ipc_id(char *proc_file,key_t key);
char *set_shm(key_t shm_key,int shm_num,int shm_flag);
int set_msq(key_t msq_key,int msq_flag);
int set_sem(key_t sem_key,int sem_val,int sem_flag);
int down(int sem_id);
int up(int sem_id);
/*信号灯控制用的共同体*/
typedef union semuns
{
    int val;
} Sem_uns;
/* 消息结构体*/
typedef struct msgbuf
{
    long mtype;
    char mtext[1];
} Msg_buf;
//生产消费者共享缓冲区即其有关的变量
key_t buff_key;
int buff_num;
char *buff_ptr;
//生产者放产品位置的共享指针
key_t pput_key;
int pput_num;
int *pput_ptr;
//消费者取产品位置的共享指针
key_t cget_key;
int cget_num;
int *cget_ptr;
//生产者和消费者有关的信号量
key_t ab_key;
key_t ac_key;
key_t bc_key;
key_t all_key;
key_t produce_key;
int ab_int;
int ac_int;
int bc_int;
int all_int;
int produce_int;

int sem_val;
int sem_flg;
int shm_flg;
各种轮子ipc.c：
#include "ipc.h"
/*
 * get_ipc_id() 从/proc/sysvipc/文件系统中获取 IPC 的 id 号
 * pfile: 对应/proc/sysvipc/目录中的 IPC 文件分别为
 * msg-消息队列,sem-信号量,shm-共享内存
 * key: 对应要获取的 IPC 的 id 号的键值
*/
int get_ipc_id(char *proc_file,key_t key)
{
    FILE *pf;
    int i,j;
    char line[BUFSZ],colum[BUFSZ];
    if((pf = fopen(proc_file,"r")) == NULL)
    {
        perror("Proc file not open");
        exit(EXIT_FAILURE);
    }
    fgets(line, BUFSZ,pf);
    while(!feof(pf))
    {
        i = j = 0;
        fgets(line, BUFSZ,pf);
        while(line[i] == ' ')
            i++;
        while(line[i] !=' ')
            colum[j++] = line[i++];
        colum[j] = '\0';
        if(atoi(colum) != key)
            continue;
        j=0;
        while(line[i] == ' ')
            i++;
        while(line[i] !=' ')
            colum[j++] = line[i++];
        colum[j] = '\0';
        i = atoi(colum);
        fclose(pf);
        return i;
    }
    fclose(pf);
    return -1;
}
/*
* 信号灯上的 down/up 操作
* semid:信号灯数组标识符
* semnum:信号灯数组下标
* buf:操作信号灯的结构
*/
int down(int sem_id)
{
    struct sembuf buf;
    buf.sem_op = -1;
    buf.sem_num = 0;
    buf.sem_flg = SEM_UNDO;
    if((semop(sem_id,&buf,1)) <0)
    {
        perror("down error ");
        exit(EXIT_FAILURE);
    }
    return EXIT_SUCCESS;
}
int up(int sem_id)
{
    struct sembuf buf;
    buf.sem_op = 1;
    buf.sem_num = 0;
    buf.sem_flg = SEM_UNDO;
    if((semop(sem_id,&buf,1)) <0)
    {
        perror("up error ");
        exit(EXIT_FAILURE);
    }
    return EXIT_SUCCESS;
}
/*
* set_sem 函数建立一个具有 n 个信号灯的信号量
* 如果建立成功，返回 一个信号灯数组的标识符 sem_id
* 输入参数：
* sem_key 信号灯数组的键值
* sem_val 信号灯数组中信号灯的个数
* sem_flag 信号等数组的存取权限
*/
int set_sem(key_t sem_key,int sem_val,int sem_flg)
{
    int sem_id;
    Sem_uns sem_arg;
//测试由 sem_key 标识的信号灯数组是否已经建立
    if((sem_id = get_ipc_id("/proc/sysvipc/sem",sem_key)) < 0 )
    {
//semget 新建一个信号灯,其标号返回到 sem_id
        if((sem_id = semget(sem_key,1,sem_flg)) < 0)
        {
            perror("semaphore create error");
            exit(EXIT_FAILURE);
        }
//设置信号灯的初值
        sem_arg.val = sem_val;
        if(semctl(sem_id,0,SETVAL,sem_arg) <0)
        {
            perror("semaphore set error");
            exit(EXIT_FAILURE);
        }
    }
    return sem_id;
}
/*
* set_shm 函数建立一个具有 n 个字节 的共享内存区
* 如果建立成功，返回 一个指向该内存区首地址的指针 shm_buf
* 输入参数：
* shm_key 共享内存的键值
* shm_val 共享内存字节的长度
* shm_flag 共享内存的存取权限
*/
char* set_shm(key_t shm_key,int shm_num,int shm_flg)
{
    int i,shm_id;
    char* shm_buf;
//测试由 shm_key 标识的共享内存区是否已经建立
    if((shm_id = get_ipc_id("/proc/sysvipc/shm",shm_key)) < 0 )
    {
//shmget 新建 一个长度为 shm_num 字节的共享内存,其标号返回到 shm_id
        if((shm_id = shmget(shm_key,shm_num,shm_flg)) <0)
        {
            perror("shareMemory set error");
            exit(EXIT_FAILURE);
        }
//shmat 将由 shm_id 标识的共享内存附加给指针 shm_buf
        if((shm_buf = (char *)shmat(shm_id,0,0)) < (char *)0)
        {
            perror("get shareMemory error");
            exit(EXIT_FAILURE);
        }
        for(i=0; i<shm_num; i++)
            shm_buf[i] = 0; //初始为 0
    }
//shm_key 标识的共享内存区已经建立,将由 shm_id 标识的共享内存附加给指针 shm_buf
    if((shm_buf = (char *)shmat(shm_id,0,0)) < (char *)0)
    {
        perror("get shareMemory error");
        exit(EXIT_FAILURE);
    }
    return shm_buf;
}
/*
* set_msq 函数建立一个消息队列
* 如果建立成功，返回 一个消息队列的标识符 msq_id
* 输入参数：
* msq_key 消息队列的键值
* msq_flag 消息队列的存取权限
*/
int set_msq(key_t msq_key,int msq_flg)
{
    int msq_id;
//测试由 msq_key 标识的消息队列是否已经建立
    if((msq_id = get_ipc_id("/proc/sysvipc/msg",msq_key)) < 0 )
    {
//msgget 新建一个消息队列,其标号返回到 msq_id
        if((msq_id = msgget(msq_key,msq_flg)) < 0)
        {
            perror("messageQueue set error");
            exit(EXIT_FAILURE);
        }
    }
    return msq_id;
}
生产者 producer.c：
#include "ipc.h"
int main(int argc,char *argv[])
{
    int rate;
//可在在命令行第一参数指定一个进程睡眠秒数，以调解进程执行速度
    if(argv[1] != NULL)
        rate = atoi(argv[1]);
    else
        rate = 1; //不指定为 1 秒
//共享内存使用的变量
    buff_key = 101;//缓冲区任给的键值
    buff_num = 1;//缓冲区任给的长度
    pput_key = 102;//生产者放产品指针的键值
    pput_num = 1; //指针数
    shm_flg = IPC_CREAT | 0644;//共享内存读写权限

//获取缓冲区使用的共享内存，buff_ptr 指向缓冲区首地址
    buff_ptr = (char *)set_shm(buff_key,buff_num,shm_flg);
//获取生产者放产品位置指针 pput_ptr
    pput_ptr = (int *)set_shm(pput_key,pput_num,shm_flg);
//信号量使用的变量

    ab_key = 201;//有C的消费者控制键值
    ac_key = 202;//有B的消费者控制键值
    bc_key = 203;//有A的消费者控制键值
    all_key = 204;//对一个缓冲区的控制键值
    produce_key = 205;//对两个生产者的同步键值
    sem_flg = IPC_CREAT | 0644;
//生产者同步信号灯初值设为缓冲区最大可用量
    sem_val = buff_num;
//获取生产者同步信号灯，引用标识存 all_int
    all_int = set_sem(all_key,sem_val,sem_flg);
//消费者初始无产品可取，同步信号灯初值设为 0
    sem_val = 0;
    ab_int = set_sem(ab_key,sem_val,sem_flg);
    ac_int = set_sem(ac_key,sem_val,sem_flg);
    bc_int = set_sem(bc_key,sem_val,sem_flg);
//生产者互斥信号灯初值为 1
    sem_val = 1;
//获取生产者互斥信号灯，引用标识存 produce_int
    produce_int = set_sem(produce_key,sem_val,sem_flg);
    int i = 0;
    
    while(1){
        int d = (i++)%3;
        down(all_int);
        down(produce_int);
        buff_ptr[*pput_ptr] = 'A'+ d;
        sleep(rate);
	if(d==0)
            printf("%d把烟草和纸放入[%d]缓存区\n",getpid(),*pput_ptr);
        else if(d==1)
            printf("%d把胶水和纸放入[%d]缓存区\n",getpid(),*pput_ptr);
        else
            printf("%d把烟草和胶水放入[%d]缓存区\n",getpid(),*pput_ptr);
	*pput_ptr = (*pput_ptr+1) % buff_num;
        up(produce_int);
        if(d==0)
            up(bc_int);
        else if(d==1)
            up(ac_int);
        else
            up(ab_int);
    }
    return EXIT_SUCCESS;
}
抽烟者A haveA.c：
#include "ipc.h"
int main(int argc,char *argv[])
{
    int rate;
//可在在命令行第一参数指定一个进程睡眠秒数，以调解进程执行速度
    if(argv[1] != NULL)
        rate = atoi(argv[1]);
    else
        rate = 1; //不指定为 1 秒
//共享内存 使用的变量
    buff_key = 101; //缓冲区任给的键值
    buff_num = 1; //缓冲区任给的长度
    cget_key = 103; //消费者取产品指针的键值
    cget_num = 1; //指针数
    shm_flg = IPC_CREAT | 0644; //共享内存读写权限
//获取缓冲区使用的共享内存，buff_ptr 指向缓冲区首地址
    buff_ptr = (char *)set_shm(buff_key,buff_num,shm_flg);
//获取消费者取产品指针，cget_ptr 指向索引地址
    cget_ptr = (int *)set_shm(cget_key,cget_num,shm_flg);
//信号量使用的变量
    ab_key = 201;//有C的消费者控制键值
    ac_key = 202;//有B的消费者控制键值
    bc_key = 203;//有A的消费者控制键值
    all_key = 204;//对一个缓冲区的控制键值
    produce_key = 205;//对两个生产者的同步键值
    sem_flg = IPC_CREAT | 0644;
//生产者同步信号灯初值设为缓冲区最大可用量
    sem_val = buff_num;
//获取生产者同步信号灯，引用标识存 all_int
    all_int = set_sem(all_key,sem_val,sem_flg);
//消费者初始无产品可取，同步信号灯初值设为 0
    sem_val = 0;
//    ab_int = set_sem(ab_key,sem_val,sem_flg);
//    ac_int = set_sem(ac_key,sem_val,sem_flg);
    bc_int = set_sem(bc_key,sem_val,sem_flg);
生产者互斥信号灯初值为 1
//    sem_val = 1;
获取生产者互斥信号灯，引用标识存 produce_int
//    produce_int = set_sem(produce_key,sem_val,sem_flg);
    while(1)
    {
        down(bc_int);
        sleep(rate);
        printf("%d  1号吸烟者得到了:烟草和纸[%d]%c\n",getpid(),*cget_ptr ,buff_ptr[*cget_ptr]);
        *cget_ptr = (*cget_ptr+1) % buff_num;
        up(all_int);
    }
    return EXIT_SUCCESS;
}
抽烟者B haveB.c：
#include "ipc.h"
int main(int argc,char *argv[])
{
    int rate;
//可在在命令行第一参数指定一个进程睡眠秒数，以调解进程执行速度
    if(argv[1] != NULL)
        rate = atoi(argv[1]);
    else
        rate = 1; //不指定为 1 秒
//共享内存 使用的变量
    buff_key = 101; //缓冲区任给的键值
    buff_num = 1; //缓冲区任给的长度
    cget_key = 103; //消费者取产品指针的键值
    cget_num = 1; //指针数
    shm_flg = IPC_CREAT | 0644; //共享内存读写权限
//获取缓冲区使用的共享内存，buff_ptr 指向缓冲区首地址
    buff_ptr = (char *)set_shm(buff_key,buff_num,shm_flg);
//获取消费者取产品指针，cget_ptr 指向索引地址
    cget_ptr = (int *)set_shm(cget_key,cget_num,shm_flg);
//信号量使用的变量
    ab_key = 201;//有C的消费者控制键值
    ac_key = 202;//有B的消费者控制键值
    bc_key = 203;//有A的消费者控制键值
    all_key = 204;//对一个缓冲区的控制键值
    produce_key = 205;//对两个生产者的同步键值
    sem_flg = IPC_CREAT | 0644;
//生产者同步信号灯初值设为缓冲区最大可用量
    sem_val = buff_num;
//获取生产者同步信号灯，引用标识存 all_int
    all_int = set_sem(all_key,sem_val,sem_flg);
//消费者初始无产品可取，同步信号灯初值设为 0
    sem_val = 0;
//    ab_int = set_sem(ab_key,sem_val,sem_flg);
    ac_int = set_sem(ac_key,sem_val,sem_flg);
//    bc_int = set_sem(ab_key,sem_val,sem_flg);
生产者互斥信号灯初值为 1
//    sem_val = 1;
获取生产者互斥信号灯，引用标识存 produce_int
//    produce_int = set_sem(produce_key,sem_val,sem_flg);
    while(1)
    {
        down(ac_int);
        sleep(rate);
        printf("%d  2号吸烟者得到了:胶水和纸 [%d]%c\n",getpid(),*cget_ptr ,buff_ptr[*cget_ptr]);
        *cget_ptr = (*cget_ptr+1) % buff_num;
        up(all_int);
    }
    return EXIT_SUCCESS;
}
抽烟者C haveC.c：
#include "ipc.h"
int main(int argc,char *argv[])
{
    int rate;
//可在在命令行第一参数指定一个进程睡眠秒数，以调解进程执行速度
    if(argv[1] != NULL)
        rate = atoi(argv[1]);
    else
        rate = 1; //不指定为 1 秒
//共享内存 使用的变量
    buff_key = 101; //缓冲区任给的键值
    buff_num = 1; //缓冲区任给的长度
    cget_key = 103; //消费者取产品指针的键值
    cget_num = 1; //指针数
    shm_flg = IPC_CREAT | 0644; //共享内存读写权限
//获取缓冲区使用的共享内存，buff_ptr 指向缓冲区首地址
    buff_ptr = (char *)set_shm(buff_key,buff_num,shm_flg);
//获取消费者取产品指针，cget_ptr 指向索引地址
    cget_ptr = (int *)set_shm(cget_key,cget_num,shm_flg);
//信号量使用的变量
    ab_key = 201;//有C的消费者控制键值
    ac_key = 202;//有B的消费者控制键值
    bc_key = 203;//有A的消费者控制键值
    all_key = 204;//对一个缓冲区的控制键值
    produce_key = 205;//对两个生产者的同步键值
    sem_flg = IPC_CREAT | 0644;
//生产者同步信号灯初值设为缓冲区最大可用量
    sem_val = buff_num;
//获取生产者同步信号灯，引用标识存 all_int
    all_int = set_sem(all_key,sem_val,sem_flg);
//消费者初始无产品可取，同步信号灯初值设为 0
    sem_val = 0;
    ab_int = set_sem(ab_key,sem_val,sem_flg);
//    ac_int = set_sem(ac_key,sem_val,sem_flg);
//    bc_int = set_sem(ab_key,sem_val,sem_flg);
//生产者互斥信号灯初值为 1
//    sem_val = 1;
//获取生产者互斥信号灯，引用标识存 produce_int
//    produce_int = set_sem(produce_key,sem_val,sem_flg);
    while(1)
    {
        down(ab_int);
        sleep(rate);
        printf("%d  3号吸烟者得到了:胶水和烟草 [%d]%c\n",getpid(),*cget_ptr ,buff_ptr[*cget_ptr]);
        *cget_ptr = (*cget_ptr+1) % buff_num;
        up(all_int);
    }
    return EXIT_SUCCESS;
}
makefile:
hdrs = ipc.h
opts = -g -c
p_src = producer.c ipc.c
p_obj = producer.o ipc.o
a_src = haveA.c ipc.c
a_obj = haveA.o ipc.o
b_src = haveB.c ipc.c
b_obj = haveB.o ipc.o
c_src = haveC.c ipc.c
c_obj = haveC.c ipc.o
all:	haveA	haveB	haveC producer
haveA:		$(a_obj)
	gcc $(a_obj) -o haveA
haveA.o: 	$(a_src) $(hdrs)
	gcc $(opts) $(a_src) -lrt
haveB:		$(b_obj)
	gcc $(b_obj) -o haveB
haveB.o: 	$(b_src) $(hdrs)
	gcc $(opts) $(b_src) -lrt
haveC:		$(c_obj)
	gcc $(c_obj) -o haveC
haveC.o: 	$(c_src) $(hdrs)
	gcc $(opts) $(c_src) -lrt
producer: 	$(p_obj)
	gcc $(p_obj) -o producer
producer.o: 	$(p_src) $(hdrs)
	gcc $(opts) $(p_src) -lrt
clean:
	rm haveA haveB haveC producer *.o

程序运行效果：

在这里插入图片描述

注意！

信号量的key似乎是运行一次结束后并不会删除，导致成功运行一次之后关闭terminal，再次开启时就没有正确的阻塞出现了（生产者无法被阻塞而疯狂生产）。
目前还不太知道 ipc.c 这个文件的具体实现原理，所以现在只能被迫通过重启虚拟机来重现实验的成功情景。

凡是出现问题，重启一下说不定就好了呢？

之后是更难的实验五和实验六，心态出现了一丝变化。

co1oratura
关注
  • 29
    点赞
  • 踩
  • 97
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
山东大学操作系统实验 实验4 进程的同步
m0_73802120的博客
04-09 924
然后，它检查共享内存中的资源是否足够进行消费。在实验调试的过程中创建的进程通常由于直接按下ctrl+c而导致后台进程并为终止(孤儿进程)，所以可以使用此脚本终止对应的程序的进程。然后，它向共享内存中的指定位置增加一个资源，并更新索引。函数来操作信号量，将信号量的值减一，表示占用资源。这些函数一起实现了生产者-消费者问题的解决方案，确保了生产者和消费者之间的正确协作。函数释放对共享资源的访问权限，并唤醒生产者。函数来操作信号量，将信号量的值加一，表示释放资源。函数释放对共享资源的访问权限，并进行短暂的睡眠。
Linux 进程控制-----抽烟者问题
05-17
假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有 三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。
计算机操作系统学习之吸烟者问题
xhy123_的博客
11-29 1834
一.问题描述 系统中有三个吸烟者进程和一个供应者进程 每个吸烟者不停的卷烟并吸掉它，而卷烟需要三种材料：烟草、纸和胶水 三个抽烟者中，第一个拥有烟草，第二个拥有纸，第三个拥有胶水 而供应者每次将两种材料放在桌子上，拥有剩下的那种材料的吸烟者拿走桌子上的材料卷一根烟并吸掉它，并且发出完成信号告诉供应者进程自己完成了 然后供应者就会放另外两种材料在桌子上，这个过程一直重复 也就是可生产多种类型产品的单生产者-多消费者问题 ...
（二十四）操作系统-吸烟者问题
m0_56517198的博客
03-08 504
吸烟者问题可以为我们解决“可以生产多个产品的单生产者”问题提供一个思路。值得吸取的精华是:“轮流让各个吸烟者吸烟”必然需要“轮流的在桌上放上组合一、二、三”，注意体会我们是如何用一个整型变量i 实现这个“轮流”过程的。若一个生产者要生产多种产品（或者说会引发多种前驱事件），那么各个V操作应该放在各自对应的“事件”发生之后的位置。假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽掉一支烟，抽烟者需要有三种材料:烟草、纸和胶水。三个抽烟者中，第一个拥有烟草、第二个拥有纸、
山东大学操作系统实验四
欧阳和小白的技术博客
05-07 4597
一.实验内容： 抽烟者问题。假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。 请用以上介绍
山东大学操作系统实验
热门推荐
ALTLI的博客
05-10 1万+
课程为山东大学软件学院人工智能专业2020年大二下学期“操作系统”课程 我会根据课程进度更新，一直到2020年6月10日前更新结束 文章目录一. 配置问题二. 实验报告第一部分 操作系统命令实验第二部分 操作系统算法实验三. 推荐博客和教程 “推荐博客和教程”虽然放到了最后面，是为了前面的简洁。实际上，我认为这个对于学习有很大的帮助 一. 配置问题 我的系统是Ubuntu18.04 在做实验时需要打开Windows中的docx文档 关于Ubuntu安装WPS教程 https://blog.csdn.n
进程同步实验（山东大学操作系统实验）
04-09
山东大学操作系统实验第六个，进程同步的源代码
山东大学linux实验四CSDN,山东大学操作系统实验报告材料4进程同步实验
weixin_39831705的博客
05-16 358
《山东大学操作系统实验报告材料4进程同步实验》由会员分享，可在线阅读，更多相关《山东大学操作系统实验报告材料4进程同步实验(15页珍藏版)》请在人人文库网上搜索。1、实用标准文案计算机科学与技术学院实验报告实验题目：实验四、进程同步实验学号：日期：20120409班级：计基地12姓名：实验目的：加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥 操作的效果，分析与研究经典进程同步...
操作系统实验四、进程同步实验——抽烟者问题
碎片
10-01 5688
抽烟者问题 问题描述 假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。 请用以上介绍的 IP...
山东大学 操作系统 实验四 进程同步实验
05-12
在山东大学的操作系统实验四中，学生们将深入探索这一主题，通过实践加深对进程同步的理解和应用。实验的目标是让学生掌握如何在多线程或多进程环境中实现同步机制，以避免竞态条件和死锁等问题，确保系统的稳定和...
实验四同步机构
11-21
实验四课程设计实验报告 #include #include #include using namespace std; const int num=5; const int sales=10;
操作系统同步机构实验
11-16
操作系统实验4同步机构，能够运行的，而且有完整的实验报告形式
操作系统实验四 进程同步实验
05-14
操作系统实验报告四 进程同步实验报告。加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥操作的效果，分析与研究经典进程同步与互斥问题的实际解决方案。了解Linux系统中IPC进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。
同步机构 模拟实现同步机构 操作系统实验
12-30
实验四 同步机构 一. 实验内容 模拟实现同步机构避免并发进程执行时可能出现的与时间有关的错误。 二. 实验目的 进程是程序在一个数据集合上运行的过程。进程是并发执行的，也即系统中的多个进程轮流的占用处理器运行。 我们把若干个进程都能进行访问和修改的那些变量称为公共变量。由于进程是并发执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后，所得到的结果与访问公共变量的时间有关。为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。一般说，同步机构是由若干条原语——同步原语——所组成。本实验要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。 三. 实验题目 模拟PV操作同步机构，且用PV操作解决生产者—消费者问题。 运行环境：Microsoft Visual Studio 2005
操作系统 实验五、进程互斥实验
05-30
理发店问题：假设理发店的理发室中有3个理发椅子和3个理发师，有一个可容纳4个顾客坐等理发的沙发。此外还有一间等候室，可容纳13位顾客等候进入理发室。顾客如果发现理发店中顾客已满（超过20人），就不进入理发店。 在理发店内，理发师一旦有空就为坐在沙发上等待时间最长的顾客理发，同时空出的沙发让在等候室中等待时间最长的的顾客就坐。顾客理完发后，可向任何一位理发师付款。但理发店只有一本现金登记册，在任一时刻只能记录一个顾客的付款。理发师在没有顾客的时候就坐在理发椅子上睡眠。理发师的时间就用在理发、收款、睡眠上。 请利用linux系统提供的IPC进程通信机制实验并实现理发店问题的一个解法。
操作系统实验——进程创建与进程间通信
06-05
操作系统实验——进程创建与进程间通信 实验内容： 一、创建进程树 二、vfork以及execl的使用 三、创建进程以及进程间通信（管道）的综合运用
山东大学操作系统实验四 进程同步
最新发布
05-15
操作系统实验四的内容是进程同步，包括了进程间的互斥、同步和通信，常用的同步机制有信号量和管程。在实验中，你需要掌握进程同步的概念及其实现方法，学会使用信号量和管程来实现进程同步，理解进程同步的原理和过程，以及如何解决进程同步中可能出现的问题，比如死锁和饥饿。 具体实验内容可以参考山东大学操作系统实验四的实验指导书，按照指导书的要求完成实验，掌握实验中涉及的技术和知识点，加深对操作系统中进程同步机制的理解和应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值