操作系统实验报告三-16281028

最新推荐文章于 2023-10-30 22:04:18 发布

可能是个不会码代码的码农

最新推荐文章于 2023-10-30 22:04:18 发布

阅读量258

点赞数

分类专栏：操作系统实验报告文章标签： daima

本文链接：https://blog.csdn.net/qq_41894686/article/details/89105866

版权

操作系统实验报告专栏收录该内容

5 篇文章 0 订阅

订阅专栏

实验三同步与通信

实验目的

系统调用的进一步理解。
进程上下文切换。
同步与通信方法。

实验题目

通过fork的方式，产生4个进程P1,P2,P3,P4，每个进程打印输出自己的名字，例如P1输出“I am the process P1”。要求P1最先执行，P2、P3互斥执行，P4最后执行。通过多次测试验证实现是否正确。

实验结果

在P2和P3之间加互斥锁，P2和P3互斥访问临界资源并执行，随后当P2或P3至少一个进程完成时，执行fork产生P4进程。

代码：

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

int main(void){
pthread_mutex_t mutex;
pthread_mutex_init(&mutex,NULL)；

pid_t pid1 = fork()；
if(pid1 == 0){
	printf("I am the process P1\n");
	return 0;
}

waitpid(pid1, NULL, 0);	
pid_t pid2 = fork();
if(pid2 == 0){
	pthread_mutex_lock(&mutex)；
	printf("I am the process P2\n");
	pthread_mutex_unlock(&mutex);
	return 0;
}
waitpid(pid1, NULL, 0);
pid_t pid3 = fork();
if(pid3 == 0){
	pthread_mutex_lock(&mutex);
	printf("I am the process P3\n");
	pthread_mutex_unlock(&mutex);
	return 0;
}
waitpid(pid2, NULL, 0);
waitpid(pid3, NULL, 0);
pid_t pid4 = fork();
if(pid4 == 0){
	printf("I am the process P4\n");
	return 0;
}
else if(pid1 != -1){
	waitpid(pid1, NULL, 0);
	waitpid(pid2, NULL, 0);
	waitpid(pid3, NULL, 0);
	waitpid(pid4, NULL, 0);	
}
pthread_mutex_destroy(&mutex);
return 0;
}

运行结果

2. 火车票余票数ticketCount 初始值为1000，有一个售票线程，一个退票线程，各循环执行多次。添加同步机制，使得结果始终正确。要求多次测试添加同步机制前后的实验效果。(说明：为了更容易产生并发错误，可以在适当的位置增加一些pthread_yield()，放弃CPU，并强制线程频繁切换，例如售票线程的关键代码：

temp=ticketCount;

pthread_yield();

temp=temp-1;

pthread_yield();

ticketCount=temp;

退票线程的关键代码：

temp=ticketCount;

pthread_yield();

temp=temp+1;

pthread_yield();

ticketCount=temp;

）

实验结果

代码

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <unistd.h>
#include <assert.h>

int ticketcount = 1000;
int temp = 0;
sem_t blanks;
sem_t datas;

void *worker1(void *arg){
	while(1){
	sem_wait(&blanks);
	temp = ticketcount;
	pthread_yield();
	temp = temp - 1;
	pthread_yield();
	ticketcount = temp;
	printf("Sale:ticketCount now is: %d\n",ticketcount);
	usleep(500);
	sem_post(&datas);
	}
	return NULL;
}

void *worker2(void *arg){
	while(1){
	sem_wait(&datas);
	temp = ticketcount;
	pthread_yield();
	temp = temp + 1;
	pthread_yield();
	ticketcount = temp;
	printf("Refund:ticketCount now is: %d\n",ticketcount);
	usleep(500);
	sem_post(&blanks);
	}
	return NULL;
}

int main(int argc, char *argv[]){	
	sem_init(&blanks, 0, 1000);
	sem_init(&datas, 0, 0);

	pthread_t p1, p2;
	pthread_create(&p1, NULL, worker1, NULL);
	pthread_create(&p2, NULL, worker2, NULL);

	pthread_join(p1, NULL);
	pthread_join(p2, NULL);

	sem_destroy(&blanks);
	sem_destroy(&datas);
	return 0;
}

运行结果：售票量+退票量始终为1000

3.一个生产者一个消费者线程同步。设置一个线程共享的缓冲区， char buf[10]。一个线程不断从键盘输入字符到buf,一个线程不断的把buf的内容输出到显示器。要求输出的和输入的字符和顺序完全一致。（在输出线程中，每次输出睡眠一秒钟，然后以不同的速度输入测试输出是否正确）。要求多次测试添加同步机制前后的实验效果。

实验结果

代码

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

char buf[10] = {0};
sem_t product;  
sem_t consume;
void *worker1(void *arg) {
	for (int i = 0; i < 10;) {
	sem_wait(&consume);
	scanf("%c",&buf[i]);
	getchar();
	i++;
	i = i%10;
	sem_post(&product);
	}
	return NULL;
}

void *worker2(void *arg) {
	for (int i = 0; i < 10;) {
	sem_wait(&product);
	printf("%c\n",buf[i]);
	sleep(1);
	i++;
	i = i%10;
	sem_post(&consume);
	}
	return NULL;
}
 

int main(int argc, char *argv[])
{	
	sem_init(&consume, 0, 10);
	sem_init(&product, 0, 0);
	pthread_t p1, p2;
	pthread_create(&p1, NULL, worker1, NULL);
	pthread_create(&p2, NULL, worker2, NULL);
	pthread_join(p1, NULL);
	pthread_join(p2, NULL);
	sem_destroy(&consume);
	sem_destroy(&product);
	return 0;
}

运行结果

4.(下面两个题目，选做一个）

1）在Pinto操作系统中，增加一个系统调用，系统调用名为test_system_call()。无输入参数，输出为在显示器中打印输出：Hello. This is my test system call.

2）进程通信问题。阅读并运行共享内存、管道、消息队列三种机制的代码

（参见

https://www.cnblogs.com/Jimmy1988/p/7706980.html

https://www.cnblogs.com/Jimmy1988/p/7699351.html

https://www.cnblogs.com/Jimmy1988/p/7553069.html ）

实验测试

a）通过实验测试，验证共享内存的代码中，receiver能否正确读出sender发送的字符串？如果把其中互斥的代码删除，观察实验结果有何不同？如果在发送和接收进程中打印输出共享内存地址，他们是否相同，为什么？

结果：receiver能正确读出sender发送的字符串

将互斥的代码删除，接送端将不会接收到消息

b)有名管道和无名管道通信系统调用是否已经实现了同步机制？通过实验验证，发送者和接收者如何同步的。比如，在什么情况下，发送者会阻塞，什么情况下，接收者会阻塞？

结果：

有名管道和无名管道通信系统调用实现了同步机制。

无名管道：

有名管道实验验证如下：

如果发送者发送了消息，而接收者未接受，则发送者将被阻塞

如果发送者未发送消息，此时接收者被阻塞，持续等待。

除此之外，在写管道时可能变满，这种情况发生时，之后的写操作（发送者）将会被阻塞，等待某些数据已被读取，以便腾出足够空间供write()调用写；当读取进程比写进程快时，当前所有进程数据已经被读取，管道变空，这时随后的读操作（接收者）将被阻塞，等待某些数据写入。

c）消息通信系统调用是否已经实现了同步机制？通过实验验证，发送者和接收者如何同步的。比如，在什么情况下，发送者会阻塞，什么情况下，接收者会阻塞？

结果：

消息通信系统调用实现了同步机制。造成msgrcv()阻塞的情况主要是，没有消息被写入队列时，接收方发生阻塞，等待消息发送方发送消息，直到超出规定时间结束。

5.阅读Pintos操作系统，找到并阅读进程上下文切换的代码，说明实现的保存和恢复的上下文内容以及进程切换的工作流程。

现代操作系统，并发是基本特征。当有多个线程在系统中运行时，一般是通过排队的方式采用RR（时间片轮转法）策略轮流占用CPU的，其中最简单，看似最公平的调度策略是FCFS，但是这种方法不能够区分线程执行的轻重缓急，看似公平实则不公平，容易造成系统性能低下。因此，操作系统设计者通常会赋予线程优先级，并采用高优先级者先调用的策略，兼顾公平与效率。在原始的Pintos系统中关于优先级调度没有考虑优先级问题，本实现的内容是为pintos建立优先级调度机制，并确保在任何时刻在CPU上运行的都是最高优先级线程。
thread_create(); //thread.c

分析：
在thread_creat()中，创建新线程的过程是：
init_thread()(设置线程的状态是THREAD_BLOCKED，设置线程的初始优先级,将此线程放入all_list队列中))--->设置线程的上下文环境---> thread_unblock()（解阻塞该线程，放入ready_list队列中）
状态转换是block->ready->running或者block->ready
属于上述中A类中（1）的新生线程（新优先级线程的第一种情况，系统创建新线程）
理论修改：
当新线程解阻塞之后放入reday_list中时，应该先比较该新线程的优先级与当前CPU正在运行的线程的优先级，是否发生CPU抢占。对于结果需要分情况处理。
pintos参考：http://www.cnblogs.com/laiy/p/pintos_project1_thread.html

GitHub源代码：https://github.com/Tergerly/16281028/tree/master/实验三