安全1601_沈香港_16281077_操作系统lab3

最新推荐文章于 2024-07-24 17:48:47 发布
最新推荐文章于 2024-07-24 17:48:47 发布
阅读量211 收藏
点赞数
文章标签： 操作系统作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41875626/article/details/89120732
版权

安全1601_沈香港_16281077_操作系统lab3

说明：本实验有参考孙汉武同学实验

TASK1

1.1 代码

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#include<fcntl.h>
int main()
{
	sem_t *P1_signal,*P2_signal,*P3_signal;
	P1_signal=sem_open("P1_signal",O_CREAT,0666,0);
	P2_signal=sem_open("P2_signal",O_CREAT,0666,0);
	P3_signal=sem_open("P3_signal",O_CREAT,0666,0);
        pid_t p2,p3,p4;//主函数的进程为P1
	p2=fork();//创建进程P2
	if(p2<0)	
	{
		perror("创建进程p2出错\n");
	}
	if(p2==0)//当前运行进程为p2
	{
		sem_wait(P1_signal);
		printf("I am the process P2\n");
		sem_post(P1_signal);
		sem_post(P2_signal);//p4进程条件
	}
	if(p2>0)//当前运行进程为P1
	{
		p3=fork();//创建进程p3
		if(p3<0)	
		{
			perror("创建进程p出错！");
		}
		if(p3==0)//当前运行进程为P3
		{
			sem_wait(P1_signal);
			printf("I am the process P3\n");
			sem_post(P1_signal);
			sem_post(P3_signal);//P4进程条件
		}
		if(p3>0)//当前运行进程为P1
		{
			printf("I am the process P1\n");
			sem_post(P1_signal);
			p4=fork();//创建进程P4
			if(p4<0)	
			{
				perror("创建进程p4出错\n");
			}
			if(p4==0)
			{
				sem_wait(P2_signal);
				sem_wait(P3_signal);
				printf("I am the process P4\n");
				sem_post(P2_signal);
				sem_post(P3_signal);
			}
		}
	}
	sem_close(P1_signal);
	sem_close(P2_signal);
	sem_close(P3_signal);
	sem_unlink("P1_signal");
	sem_unlink("P2_signal");
	sem_unlink("P3_signal");
	return 0;
}

1.2 原理

前趋图

在这里插入图片描述

前驱关系：
   P1-->P2、P1-->P3、P2-->P4、P3-->P4

1.3实验结果

在这里插入图片描述

1.4分析

测试的实验结果中出现两种执行顺序，由于P1是P2和P3的前驱，所以P1一定会在P2和P3之前执行，但是P2和P3是互斥关系，这两个进程谁先获得P1产生的信号量谁就先执行另一个进程等待。最后等P2和P3都执行完了再执行P4，所以会出现上面的两种执行顺序。

TASK2

2.1.1代码

q2_1.c

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<string.h>
void pthread_yield();
int ticketCount=1000;
void *SaleThread(void *arg)
{
	int num,temp,i;
	num=atoi(arg);
	for(i=0;i<num;i++)
	{
		temp=ticketCount;
		pthread_yield();//强制线程频繁切换
		temp=temp-1;
		pthread_yield();//强制线程频繁切换
		ticketCount=temp;
	}
}

void *RefundThread(void *arg)
{
	int num,temp,i;
	num=atoi(arg);
	for(i=0;i<num;i++)
	{
		temp=ticketCount;
		pthread_yield();//强制线程频繁切换
		temp=temp+1;
		pthread_yield();//强制线程频繁切换
		ticketCount=temp;
	}
}
int main(int argc,char *argv[])
{
	if(argc!=3)
	{
		printf("请正确输入参数！\n");
		exit(0);
	}
	printf("火车票余票初始值：%d\n",ticketCount);
	pthread_t p1,p2;
	pthread_create(&p1,NULL,SaleThread,argv[1]);
	pthread_create(&p2,NULL,RefundThread,argv[2]);
	pthread_join(p1,NULL);
	pthread_join(p2,NULL);
	printf("火车票余票最终值：%d\n",ticketCount);
	return 0;
}
2.1.2程序解释

1.模拟售票的线程SaleThread和模拟退票的线程RefundThread，两个进程并发执行，无任何的同步机制。
2.模拟票数变量ticketCount是全局变量
3.程序运行包括两个参数，一个是售票数量，一个是退票数量

2.1.2 运行结果

在这里插入图片描述
多次测试结果运行表明，实验现象为

当售票数量大于退票数量的时候，最终票数等于总票数减去售票数
当售票数量小于退票数量的时候，最终票数等于总票数加上退票数

2.2.1实验代码

q2_2.c

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<string.h>
void pthread_yield();
int ticketCount=1000;
sem_t *mutex=NULL;
void *SaleThread(void *arg)
{
	int num,temp,i;
	num=atoi(arg);
       for(i=0;i<num;i++){
		sem_wait(mutex);
		temp=ticketCount;
		pthread_yield();//强制线程频繁切换
		temp=temp-1;
		pthread_yield();//强制线程频繁切换
		ticketCount=temp;
		sem_post(mutex);
	}
}

void *RefundThread(void *arg)
{
	int num,temp,i;
	num=atoi(arg);
	for(i=0;i<num;i++)
	{
		sem_wait(mutex);
		temp=ticketCount;
		pthread_yield();//强制线程频繁切换
		temp=temp+1;
		pthread_yield();//强制线程频繁切换
		ticketCount=temp;
		sem_post(mutex);
        }
}
int main(int argc,char *argv[])
{
	if(argc!=3)
	{
		printf("请正确输入参数！\n");
		exit(0);
	}
	mutex=sem_open("mutex",O_CREAT,0666,1);
	printf("火车票余票初始值：%d\n",ticketCount);
	pthread_t p1,p2;
	pthread_create(&p1,NULL,SaleThread,argv[1]);
	pthread_create(&p2,NULL,RefundThread,argv[2]);
	pthread_join(p1,NULL);
	pthread_join(p2,NULL);
	printf("火车票余票最终值：%d\n",ticketCount);
	sem_close(mutex);
	sem_unlink("mutex");
	return 0;
}

2.2.2程序说明

通过信号量mutex的控制，让售票线程和退票线程一次只能执行一个，在一个没有执行完成之前另一个不能进入执行。
mutex初始值为设置为1，每次只允许一个线程操作ticketCount这个数据

2.2.3运行结果

在这里插入图片描述

2.2.4实验结果

增加了同步机制之后的多线程并发程序有效的解决了脏数据的读取问题

TASK3

3.1实验代码

q3.c

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
char buf[10];
sem_t *empty=NULL;//缓存区未写入数量
sem_t *full=NULL;//缓存区写入数量
void *producer(void *arg)
{
	
	for(int i=0;i<10;i++)
	{
		sem_wait(empty);
		scanf("%c",&buf[i]);
		sem_post(full);
		if(i==9)
		{
			i=-1;
		}
	}	
}
void *comsumer(void *arg)
{
	for(int i=0;i<10;i++)
	{
		sem_wait(full);
		printf("输出：%c\n",buf[i]);
		sem_post(empty);
		sleep(1);
		if(i==9)
		{
			i=-1;		
		}
	}	
}

int main(int argc,char *argv[])
{
	empty=sem_open("_empty",O_CREAT,0666,10);
	full=sem_open("_full",O_CREAT,0666,0);
	pthread_t p1,p2;
	pthread_create(&p1,NULL,producer,NULL);
	pthread_create(&p2,NULL,comsumer,NULL);
	pthread_join(p1,NULL);
	pthread_join(p2,NULL);
	sem_close(empty);
	sem_close(full);
	sem_unlink("_empty");
	sem_unlink("_full");
	return 0;
}

3.2程序解释

producer是输入线程调用的函数，comsumer是输出线程调用的函数
empty信号量用于保证输入线程在写入数据到缓存的时候缓存中还有空余的位置，保证写入线程后写入的数据不会把前面写入但是为输出的数据给覆盖掉，其初始值为10，表示最开始缓存中有10个空余的位置供给写入线程写入数据；full信号量是用于保证输出线程有数据输出，避免在写入线程还没有写入数据的情况下输出线程输出随机数据，其初始值为0，表示初始状态下缓存中没有数据可以输出
输入线程在写入一个数据前要等待empty信号量，进入后便消耗一个信号量；完成写入数据操作之后post一个full信号量，通知输出线程输出数据
输出线程在输出一个数据之前哟啊等待full信号量，进出输出操作后便消耗一个full信号量；完成输出操作后post一个empty信号量，通知写入线程缓存又多一个空余位置以供写入数据

3.3三种实验结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.4实验结果分析

输入数据不大于10个字符的时候，由于empty的信号量初始值为10，所以输入进程会一直连续不断的向缓存中写入数据，每写入一个数据，便post一个full信号量，输出线程便能按序输出字符。
输入数据大于10个字符的时候，由于empty的初始值为10，所以输入的字符中开始的时候只有前10个字符被写入缓存中，其他的在I/O缓冲区等待输入，当输出线程接收到输入线程post的信号量的时候便会开始输出，每输出一个字符便会post一个empty信号量，当输入线程接收到empty信号量的时候有开始从I/O缓冲区读取数据写入到缓存中。

TASK4

4.1.1内存共享

1实验代码
Sender.c

/*
 * Filename: Sender.c
 * Description: 
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>

int main(int argc, char *argv[])
{
    key_t  key;
    int shm_id;
    int sem_id;
    int value = 0;
    //1.Product the key
    key = ftok(".", 0xFF);
    //2. Creat semaphore for visit the shared memory
    sem_id = semget(key, 1, IPC_CREAT|0644);
    if(-1 == sem_id)
    {
        perror("semget");
        exit(EXIT_FAILURE);
    }
    //3. init the semaphore, sem=0
    if(-1 == (semctl(sem_id, 0, SETVAL, value)))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    //4. Creat the shared memory(1K bytes)
    shm_id = shmget(key, 1024, IPC_CREAT|0644);
    if(-1 == shm_id)
    {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    //5. attach the shm_id to this process
    char *shm_ptr;
    shm_ptr = shmat(shm_id, NULL, 0);
    if(NULL == shm_ptr)
    {
        perror("shmat");
        exit(EXIT_FAILURE);
    }
    //6. Operation procedure
    struct sembuf sem_b;
    sem_b.sem_num = 0;      //first sem(index=0)
    sem_b.sem_flg = SEM_UNDO;
    sem_b.sem_op = 1;           //Increase 1,make sem=1
    
    while(1)
    {
        if(0 == (value = semctl(sem_id, 0, GETVAL)))
        {
            printf("\nNow, snd message process running:\n");
            printf("\tInput the snd message:  ");
            scanf("%s", shm_ptr);

            if(-1 == semop(sem_id, &sem_b, 1))
            {
                perror("semop");
                exit(EXIT_FAILURE);
            }
        }
        //if enter "end", then end the process
        if(0 == (strcmp(shm_ptr ,"end")))
        {
            printf("\nExit sender process now!\n");
            break;
        }
    }
    shmdt(shm_ptr);
    return 0;
}

Receiver.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>

int main(int argc, char *argv[])
{
    key_t  key;
    int shm_id;
    int sem_id;
    int value = 0;
    //1.Product the key
    key = ftok(".", 0xFF);
    //2. Creat semaphore for visit the shared memory
    sem_id = semget(key, 1, IPC_CREAT|0644);
    if(-1 == sem_id)
    {
        perror("semget");
        exit(EXIT_FAILURE);
    }
    //3. init the semaphore, sem=0
    if(-1 == (semctl(sem_id, 0, SETVAL, value)))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    //4. Creat the shared memory(1K bytes)
    shm_id = shmget(key, 1024, IPC_CREAT|0644);
    if(-1 == shm_id)
    {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    //5. attach the shm_id to this process
    char *shm_ptr;
    shm_ptr = shmat(shm_id, NULL, 0);
    if(NULL == shm_ptr)
    {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    //6. Operation procedure
    struct sembuf sem_b;
    sem_b.sem_num = 0;      //first sem(index=0)
    sem_b.sem_flg = SEM_UNDO;
    sem_b.sem_op = -1;           //Increase 1,make sem=1
    
    while(1)
    {
        if(1 == (value = semctl(sem_id, 0, GETVAL)))
        {
            printf("\nNow, receive message process running:\n");
            printf("\tThe message is : %s\n", shm_ptr);

            if(-1 == semop(sem_id, &sem_b, 1))
            {
                perror("semop");
                exit(EXIT_FAILURE);
            }
        }
        //if enter "end", then end the process
        if(0 == (strcmp(shm_ptr ,"end")))
        {
            printf("\nExit the receiver process now!\n");
            break;
        }
    }
    shmdt(shm_ptr);
    //7. delete the shared memory
    if(-1 == shmctl(shm_id, IPC_RMID, NULL))
    {
        perror("shmctl");
        exit(EXIT_FAILURE);
    }
    //8. delete the semaphore
    if(-1 == semctl(sem_id, 0, IPC_RMID))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    return 0;
}

4.1.2执行结果

在这里插入图片描述

4.1.3删除互斥访问

Sender_2.c:

/*
 * Filename: Sender.c
 * Description: 
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>

int main(int argc, char *argv[])
{
    key_t  key;
    int shm_id;
    int sem_id;
    int value = 0;
    //1.Product the key
    key = ftok(".", 0xFF);
    //2. Creat semaphore for visit the shared memory
    sem_id = semget(key, 1, IPC_CREAT|0644);
    if(-1 == sem_id)
    {
        perror("semget");
        exit(EXIT_FAILURE);
    }
    //3. init the semaphore, sem=0
    if(-1 == (semctl(sem_id, 0, SETVAL, value)))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    //4. Creat the shared memory(1K bytes)
    shm_id = shmget(key, 1024, IPC_CREAT|0644);
    if(-1 == shm_id)
    {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    //5. attach the shm_id to this process
    char *shm_ptr;
    shm_ptr = shmat(shm_id, NULL, 0);
    if(NULL == shm_ptr)
    {
        perror("shmat");
        exit(EXIT_FAILURE);
    }
    //6. Operation procedure
    struct sembuf sem_b;
    sem_b.sem_num = 0;      //first sem(index=0)
    sem_b.sem_flg = SEM_UNDO;
    sem_b.sem_op = 1;           //Increase 1,make sem=1
    
    while(1)
    {
            printf("\nNow, snd message process running:\n");
            printf("\tInput the snd message:  ");
            scanf("%s", shm_ptr);
        //if enter "end", then end the process
        if(0 == (strcmp(shm_ptr ,"end")))
        {
            printf("\nExit sender process now!\n");
            break;
        }
    }
}

Receiver_2.c:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>

int main(int argc, char *argv[])
{
    key_t  key;
    int shm_id;
    int sem_id;
    int value = 0;
    //1.Product the key
    key = ftok(".", 0xFF);
    //2. Creat semaphore for visit the shared memory
    sem_id = semget(key, 1, IPC_CREAT|0644);
    if(-1 == sem_id)
    {
        perror("semget");
        exit(EXIT_FAILURE);
    }
    //3. init the semaphore, sem=0
    if(-1 == (semctl(sem_id, 0, SETVAL, value)))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    //4. Creat the shared memory(1K bytes)
    shm_id = shmget(key, 1024, IPC_CREAT|0644);
    if(-1 == shm_id)
    {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    //5. attach the shm_id to this process
    char *shm_ptr;
    shm_ptr = shmat(shm_id, NULL, 0);
    if(NULL == shm_ptr)
    {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    //6. Operation procedure
    struct sembuf sem_b;
    sem_b.sem_num = 0;      //first sem(index=0)
    sem_b.sem_flg = SEM_UNDO;
    sem_b.sem_op = -1;           //Increase 1,make sem=1
    
    while(1)
    {
            printf("\nNow, receive message process running:\n");
            printf("\tThe message is : %s\n", shm_ptr);
        //if enter "end", then end the process
        if(0 == (strcmp(shm_ptr ,"end")))
        {
            printf("\nExit the receiver process now!\n");
            break;
        }
        sleep(3);
    }
    shmdt(shm_ptr);
    //7. delete the shared memory
    if(-1 == shmctl(shm_id, IPC_RMID, NULL))
    {
        perror("shmctl");
        exit(EXIT_FAILURE);
    }
    //8. delete the semaphore
    if(-1 == semctl(sem_id, 0, IPC_RMID))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    return 0;
}

执行结果为
在这里插入图片描述

4.1.4打印共享内存地址

结果在这里插入图片描述
看到两个进程中共享内存地址不一样

4.2.1管道通信

（1）无名管道
1实验源码
pipe.c:

#include <stdio.h>
#include <unistd.h>     //for pipe()
#include <string.h>     //for memset()
#include <stdlib.h>     //for exit()
int main()
{
    int fd[2];
    char buf[20];
    if(-1 == pipe(fd))
    {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    write(fd[1], "hello,world", 12);
    memset(buf, '\0', sizeof(buf));
    read(fd[0], buf, 12);
    printf("The message is: %s\n", buf);
    return 0;
}

2实验结果
在这里插入图片描述
3无名管道同步机制验证
pipe_2.c:

#include <stdio.h>
#include <unistd.h>     //for pipe()
#include <string.h>     //for memset()
#include <stdlib.h>     //for exit()
int main()
{
    int fd[2];
    char buf[200]={0};
	pid_t child;
    //创建管道
	if(-1 == pipe(fd))
    {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
	//创建子进程
	child=fork();
	if(child==-1)
	{
		perror("fork");
		exit("EXIT_FAILURE");
	}
	if(child==0)
	{
		//关闭子进程中不需要的写描述符
		close(fd[1]);
		while(1)
		{
			if(read(fd[0],buf,sizeof(buf))>0)
					printf("子进程接收的消息是:%s\n",buf);
			else
					printf("子进程:管道中没有数据\n");
			sleep(2);		
			if(strcmp(buf,"end")==0)
					break;
			memset(buf,0,sizeof(buf));
		}
	}
	if(child>0)
	{
		close(fd[0]);
		while(1)
		{
			printf("父进程中-请输入消息:");
			scanf("%s",buf);
			write(fd[1],buf,strlen(buf));
			if(strcmp(buf,"end")==0)
				break;
		}	
	}
    return 0;
}

4无名管道同步机制实验现象
在这里插入图片描述
可以看到输出进程是按照输入进程输入的顺序输出数据，并且当输入进程没有数据输入，即管道中没有数据的时候，输出进程会阻塞。因此无名管道通信系统调用的时候已经实现了同步机制
（2）有名管道
1实验代码
fifo_send.c:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <fcntl.h>
#define FIFO "./my_fifo"

int main()
{
    char buf[] = "hello,world";
    //1. check the fifo file existed or not
    int ret;
    ret = access(FIFO, F_OK);
    if(ret != 0)    //file /tmp/my_fifo existed
    {
    	if(-1 == mkfifo(FIFO, 0766))
    	{
    	    perror("mkfifo");
    	    exit(EXIT_FAILURE);
    	}
    }

    //3.Open the fifo file
    int fifo_fd;
    fifo_fd = open(FIFO, O_WRONLY);
    if(-1 == fifo_fd)
    {
        perror("open");
        exit(EXIT_FAILURE);

    }
    //4. write the fifo file
    int num = 0;
    num = write(fifo_fd, buf, sizeof(buf));
    if(num < sizeof(buf))
    {
        perror("write");
        exit(EXIT_FAILURE);
    }
    printf("write the message ok!\n");

    close(fifo_fd);

    return 0;
}

fifo_rcv.c:

/*
 *File: fifo_rcv.c
 */
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <fcntl.h>


#define FIFO "./my_fifo"

int main()
{
    char buf[20] ;
    memset(buf, '\0', sizeof(buf));

    //`. check the fifo file existed or not
    int ret;
    ret = access(FIFO, F_OK);
    if(ret != 0)    //file /tmp/my_fifo existed
    {
        if(-1==mkfifo(FIFO,0766))
        {
            perror("mkfifo"); 
            exit("EXIT_FAILURE");
        }
    }

//	2.Open the fifo file
    int fifo_fd;
    fifo_fd = open(FIFO, O_RDONLY);
    if(-1 == fifo_fd)
    {
        perror("open");
        exit(EXIT_FAILURE);
    }
    //4. read the fifo file
    int num = 0;
    num = read(fifo_fd, buf, sizeof(buf));
    printf("Read %d words: %s\n", num, buf);
    close(fifo_fd);
    return 0;
}

2实验现象
在这里插入图片描述
在这里插入图片描述
在仅仅只运行fifo_send进程的时候，没有任何输出，进程一直阻塞，直到fifo_rcv进程运行，两个进程才开始输出信息。
当写进程和读进程都设置成阻塞状态的时候，不论先执行那个进程，先执行的进程都会阻塞等待，待另一个进程执行后两个进程才正常执行。

4.3.1消息队列

1实验代码
Server.c:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <signal.h>

#define BUF_SIZE 128

//Rebuild the strcut (must be)
struct msgbuf
{
    long mtype;
    char mtext[BUF_SIZE];
};
int main(int argc, char *argv[])
{
    //1. creat a mseg queue
    key_t key;
    int msgId;
    
    key = ftok(".", 0xFF);
    msgId = msgget(key, IPC_CREAT|0644);
    if(-1 == msgId)
    {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    printf("Process (%s) is started, pid=%d\n", argv[0], getpid());

    while(1)
    {
        alarm(0);
        alarm(600);     //if doesn't receive messge in 600s, timeout & exit
        struct msgbuf rcvBuf;
        memset(&rcvBuf, '\0', sizeof(struct msgbuf));
        msgrcv(msgId, &rcvBuf, BUF_SIZE, 1, 0);                
        printf("Receive msg: %s\n", rcvBuf.mtext);
        
        struct msgbuf sndBuf;
        memset(&sndBuf, '\0', sizeof(sndBuf));

        strncpy((sndBuf.mtext), (rcvBuf.mtext), strlen(rcvBuf.mtext)+1);
        sndBuf.mtype = 2;

        if(-1 == msgsnd(msgId, &sndBuf, strlen(rcvBuf.mtext)+1, 0))
        {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }
            
        //if scanf "end~", exit
        if(!strcmp("end~", rcvBuf.mtext))
             break;
    }     
    printf("THe process(%s),pid=%d exit~\n", argv[0], getpid());
    return 0;
}

Client.c:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <signal.h>

#define BUF_SIZE 128

//Rebuild the strcut (must be)
struct msgbuf
{
    long mtype;
    char mtext[BUF_SIZE];
};


int main(int argc, char *argv[])
{
    //1. creat a mseg queue
    key_t key;
    int msgId;
    
    printf("THe process(%s),pid=%d started~\n", argv[0], getpid());

    key = ftok(".", 0xFF);
    msgId = msgget(key, IPC_CREAT|0644);
    if(-1 == msgId)
    {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    //2. creat a sub process, wait the server message
    pid_t pid;
    if(-1 == (pid = fork()))
    {
        perror("vfork");
        exit(EXIT_FAILURE);
    }

    //In child process
    if(0 == pid)
    {
        while(1)
        {
            alarm(0);
            alarm(100);     //if doesn't receive messge in 100s, timeout & exit
            struct msgbuf rcvBuf;
            memset(&rcvBuf, '\0', sizeof(struct msgbuf));
            msgrcv(msgId, &rcvBuf, BUF_SIZE, 2, 0);                
            printf("Server said: %s\n", rcvBuf.mtext);
        }
        
        exit(EXIT_SUCCESS);
    }

    else    //parent process
    {
        while(1)
        {
            usleep(100);
            struct msgbuf sndBuf;
            memset(&sndBuf, '\0', sizeof(sndBuf));
            char buf[BUF_SIZE] ;
            memset(buf, '\0', sizeof(buf));
            
            printf("\nInput snd mesg: ");
            scanf("%s", buf);
            
            strncpy(sndBuf.mtext, buf, strlen(buf)+1);
            sndBuf.mtype = 1;

            if(-1 == msgsnd(msgId, &sndBuf, strlen(buf)+1, 0))
            {
                perror("msgsnd");
                exit(EXIT_FAILURE);
            }            
            //if scanf "end~", exit
            if(!strcmp("end~", buf))
                break;
        }
        
        printf("THe process(%s),pid=%d exit~\n", argv[0], getpid());
    }
    return 0;
}

2程序运行结果
在这里插入图片描述

TASK5

未完成

qq_41875626
关注
Cesium 实战 08 - 无人机斜影（倾斜摄影）数据（OSGB）转 Cesium 3dtile 数据归纳总结以及亲测可用示例
linzi19900517的博客
09-29 1万+
无人机斜影数据（OSGB）转 Cesium 3dtile 数据归纳总结以及亲测可用示例。 包括下载测试数据地址以及使用说明。 几乎把所有错都试了一遍，才找到最合适的工具进行转换。 文中有完整试错过程。
OS lab3实验报告
weixin_43612616的博客
04-08 1163
OS lab3实验报告一、实验目的二、实验过程1.4 process火车票 系统3. 生产者消费者4. 进程通信问题5. pintos操作系统三、总结与收获 一、实验目的 系统调用的进一步理解。 进程上下文切换。 同步与通信方法。 二、实验过程 1.4 process 通过fork的方式，产生4个进程P1,P2,P3,P4，每个进程打印输出自己的名字，例如P1输出“I am the proc...
操作系统实验报告 lab3
4ct10n
04-24 1万+
操作系统实验报告 lab3
操作系统lab3
OuWenZhPi的博客
04-08 1147
操作系统lab3 一、fork进程的执行控制 要求：通过fork的方式，产生4个进程P1,P2,P3,P4，每个进程打印输出自己的名字，例如P1输出“I am the process P1”。要求P1最先执行，P2、P3互斥执行，P4最后执行。通过多次测试验证实现是否正确。 添加互斥锁，使P2和P3互斥执行，等待P2和P3都完成后再执行P4进程，每个进程结束后返回。 二、对比非同...
北航OSLab3
riyuejiuzhao的博客
04-16 3693
北航osLab3笔记 对Lab2的一些修改 在Lab2中，我在page_init里插入物理页框似乎用的是LIST_INSERT_TAIL，应该修改为LIST_INSERT_HEAD，这样一来，内存地址就从高位开始分配。 不过为什么一定要从高位开始分配内存，我也不明白。 进程控制块结构 进程控制块（PCB）包含一个进程运行所需要的各种信息，与进程一一对应。我们来看看进程lab3中涉及到的进程控制块内...
串的处理
CatTalk
06-06 875
Problem Description 基本的串操作。根据输入的指令对串进行相应的处理。 指令有Ins和Rep两个。 如果指令为Ins，执行插入操作，将串t插入到串s的第i（1 如果指令为Rep，执行替换操作，在串s中，将第i（1 保证输入合法。 Input 数据的组数T。每组数据有三行。第一行为指令Ins或者指令Rep，然后是数字i。接下来的两行分别为两个字符串s、t。
操作系统lab5实验报告
qq_41875626的博客
06-15 552
安全1601_沈香港_16281077_操作系统lab5实验介绍整体组织文件描述符目录项总结：①对磁盘的操作：②对文件的操作：实验过程 实验介绍 本实验要求在假设的I/O 系统之上开发一个简单的文件系统，这样做既能让实验者对文件系统有整体了解，又避免了涉及过多细节。用户通过create, open, read 等命令与文件系统交互。文件系统把磁盘视为顺序编号的逻辑块序列，逻辑块的编号为0 至L-1...
信息安全从业者考试认证大全_信息化相关的证书
weixin_57514792的博客
07-16 1487
信息安全从业者考试认证大全_信息化相关的证书
信息安全从业者考试认证大全_信息化相关的证书_个人 信息化 相关资质
abao6690的博客
07-24 1256
信息安全从业者考试认证大全_信息化相关的证书
管理信息系统概论香港利丰集团案例分析PPT课件.pptx
10-13
在【香港利丰集团】的案例中，我们可以深入理解管理信息系统的重要性和应用。\n\n【利丰集团】是一家大型跨国商贸集团，主要业务包括出口贸易、经销批发和零售，其成功的关键在于高效地运用供应链管理理念。集团自...
CS-LAB
03-31
【CS-LAB】是一个编程相关的学习资源，特别针对EECS（Electrical and Computer Engineering, 电子与计算机工程）领域的学生和爱好者。这个项目主要是为了帮助他们提升编程技能，特别是使用C++语言。从提供的信息来看...
征集华人操作系统项目列表
热门推荐
DanceFire的专栏
05-15 3万+
也许大部分人都知道Windows，可能相当一部分人知道Linux，甚至知道Linux和Windows的纷争。但是提到华人制作的操作系统时恐怕就知之甚少了。能提起名字的，恐怕只有中科院的红旗、国防科技大学的银河麒麟。但是，华人制作的操作系统就只有这么几个商业化的或者科研计划的操作系统么？其实远不是这样。在民间，已经有大量的操作系统人才在积蓄着自己的力量，已经有优秀的作品发布了出来，这里面既包括了
华为OD模型资源22份
10-17
华为OD模型资源22份，资源列表： 组织发展与变革19页.pptx 华为BLM模型67页.ppt 华为组织变革认知和启示14页.docx 企业管理创新与组织变革110页.ppt 企业文化建设模型13页.ppt BLM模型90页.ppt 组织变革与管理38页.pptx 公司组织机构图10页.docx 如何设计出有效的组织架构29页.pptx 组织设计与发展10页.pptx 【模板】企业组织架构图PPT模板(漂亮实用)22P.ppt 公司组织机构调整方案9页.doc 丹尼森组织文化模型.xlsx 杜邦公司组织变革案例分析26页.ppt 组织文化评估工具(奎因模型)28页.pptx 公司与组织架构设计53页.ppt 【模板】企业组织架构图PPT模板15页.pptx 华为变革及流程管理框架33页.pptx 组织发展(OD)4页.pptx 组织发展评估模型48页.ppt 绩效管理(组织绩效管理)46页.ppt 组织变革的案例14页.ppt
13.jpg
10-17
13
UE4高清虚幻引擎教程全集
10-17
1、Unreal Engine 4 零基础美术流程完全教学 2、Unreal Engine 4 独立游戏制作编程教学 3、Unreal Engine 4 可视化虚拟现实全流程实战教学 4、Unreal Engine 4 高级材质系统实战教学 5、Unreal Engine 4 虚幻引擎蓝图可视化编程教学 6、Unreal Engine 4 虚幻引擎蓝图可视化编程教学进阶篇 7、Unreal Engine 4 虚幻4引擎RPG游戏与特效实战开发教程 第一部 8、Unreal Engine 4 虚幻4引擎RPG游戏与特效实战开发教程 第二部 9、Unreal Engine 4 虚幻引擎VR交互虚拟漫游完全流程教学 HTCViveTemplate-UE4-master.zip UE4.12 substance套装.zip 共114G 网站上传资料大小有限制，仅包含代码
毕业设计论文SpringBoot商务安全邮箱邮件收发系统.docx
10-17
毕业设计论文
人体姿态估计-在EdgeTPU上部署人体姿态估计算法-优质项目实战.zip
最新发布
10-17
人体姿态估计_在EdgeTPU上部署人体姿态估计算法_优质项目实战
毕业设计论文SpringBoot快递业务管理系统.docx
10-17
毕业设计论文
全球与中国200W以下便携式太阳能板市场现状及未来发展趋势（2024版）.docx
10-17
全球与中国200W以下便携式太阳能板市场现状及未来发展趋势（2024版）.docx
华中科技大学操作系统lab3_1
12-26
华中科技大学操作系统lab3_1是一个实验课程，旨在帮助学生深入理解操作系统的基本概念和原理，并提供实际操作系统的设计和实现经验。在这个lab中，学生将利用C语言和Linux环境，实现一个简单的操作系统内核。 在这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值