进程同步与互斥实验报告 进程同步与互斥流程图

总线系统实验报告

if number%2==0 v(n); //

计算机的总线结构

进程同步与互斥实验报告 进程同步与互斥流程图

进程同步与互斥实验报告 进程同步与互斥流程图

Bub(总线) Intece（接口） Socket（插座） Slot（插槽） Port（端口）

总线——是一组能为多个部件服务的公共信息传送线路，是计算机各部件之间的传送数据、地址和控制信息的公共通路，它能分时地发送与接收各部件的信息。

采用结构在系统设计、生产、使用和维护上有很多优越性：

（1）采用结构设计方法，简化了系统设计。

（2）便于生产与之兼容的硬件板卡和软件。

（3）便于系统的扩充和升级。

（4）便于故障诊断和维护，也降低了成本。

总线的主要参数

总线分类：

数据总线（Data Bus)－用于传输数据的。

地址总线（Address Bus)-用于传输地址信息的。

控制总线（Contron Bus)－用于传输控制信号、时钟信号的状态信息的。

1、总线的带宽(MB/s)

——指的是单位时间内总线上可传送的数据量，即每秒传送多少MB字节的稳态数据传输率。

2、总线的位宽（bit)

——指的是总线一次能同时传送的数据位数，即常说的32位、64位等总线宽度。总线位宽越大传输率越大。

3、总线的工作时钟频率

——总线分为：CPU内部使用的内部总线和CPU对外联系的外部总线//生产一个产品作。

控制总线的时钟信号频率称为总线的工作时钟频率。内部总线频率就是常说的内频，而外部总线频率就是外频。

注：(总线带宽、总线位宽、总线工作时钟频率的关系，就像速公路上的车流量、公路车道数目、车辆行驶速度的关系）

实验1 进程管理1. 实验目的（1） 加深对进程概念的理解，明确进程和程序的区别。（2） 进一步认识并发执行的实质。（3） 分析进程争用资源的现象，学习解决进程互斥的方法。（4） 了解Linux系统中进行通信的基本原理。2. 实验预备内容（1） 阅读Linux的sched.d源码文件，加深对进程管理的理解。（2） 阅读Linux的fork.c源码文件，分析进程的创建过程。3. 实验内容（1） 进程的创建编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符；父进程显示字符"a"，子进程分别显示"b"和"c"。试观察记录屏幕上的显示结果，并分析原因。〈程序〉#include〈stdio.h〉Main(){int p1,p2;while((p1 == fork()) == -1); /创建子进程p1/if (p1 == 0) /子进程创建成功/putchar('b');else{while((p2 == fork())) == -1); /创建子进程p2/if (p2 == 0) /子进程创建成功/putchar('c'); /父进程执行/else putchar('a');}}〈运行结果〉bca(有时出现bac等)分析：从进程并发执行来看，输出bac，acb等情况都有可能。原因：fork（）创建进程所需的时间要多于输出一个字符的时间，因此在主进程创建进程2的同时，进程1就输出了'b'，而进程2和主程序的输出次序是有随机性的,所以会出现上述结果。（2） 进程的控制修改已编写的程序，将每个进程的输出有单个字符改为一句话，在观察程序执行时屏幕上出现的现象，并分析其原因。如果在程序中使用系统调用lockf()来给每个进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。〈程序1〉#include〈stdio.h〉main(){int p1,p2,i;while((p1 == fork()) == -1); /创建子进程p1/if (p1 == 0) /子进程创建成功/for(i=0;iprintf("sun %d/n",i);else{while((p2 == fork())) == -1); /创建子进程p2/if (p2 == 0) /子进程创建成功/for(i=0;iprintf("earth %d/n",i);elsefor(i=0;iprintf("moon %d/n",i);}}〈运行结果〉sun...earth...moon...moon...或sun...earth...sun...earth...moon...等分析：由于函数printf()输出的字符串之间不会被中断，因此，字符串内部的字符顺序输出时不变。但是，由于进程并发执行时的调度顺序和父子进程的抢占处理机问题，输出字符串的顺序和先后随着执行的不同而发生变化。这类似打印单字符的结果。〈程序2〉#include〈stdio.h〉main(){int p1,p2,i;while((p1 == fork()) == -1); /创建子进程p1/if (p1 == 0){lockf(1,1,0);for(i=0;iprintf("sun %d/n",i);lockf(1,0,0);}else{while((p2 == fork())) == -1);if (p2 == 0){lockf(1,1,0);for(i=0;iprintf("earth %d/n",i);lockf(1,0,0);}else{lockf(1,1,0);for(i=0;iprintf("moon %d/n",i);lockf(1,1,,0);}}}〈运行结果〉sun...earth...moon...moon...或sun...earth...sun...earth...moon...等与未上锁的情况大致相同，也是随着执行时间的不同，输出结果的顺序有所不同。分析：因为上述程序执行时，不同进程之间不存在共享临界资源问题，所以，加锁与不加锁效果相同。（3） 软中断通信编制一段程序，使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程扑捉键盘上来的中断信号（即按Del键），当扑捉到中断信号后，父进程用系统调用kill()向两个子进程发出信号，子进程扑捉到信号后，分别输出下列信息后终止：child process 1 is killed by parent!child process 2 is killed by parent!父进程等待两个子进程终止后，输出以下信息后终止：parent process is killed!〈程序〉#include〈stdio.h〉#include〈signal.h〉#include〈unistd.h〉void waiting(),stop();int wait_mark;main(){int p1,p2,i;while((p1 == fork()) == -1); /创建子进程p1/if (p1 > 0){while((p1 == fork == -1);if(p2 > 0){wait_mark = -1;signal(SIGINT,stop); /接收'Del'信号，并转stop/waiting(0);kill(p1,16); /向p1发中断信号16/kill(p2,17); /向p1发中断信号17/wait(0); /同步/wait(0);printf("parent process is killed! n");exit(0);}else{wait_mark = -1;signal(17,stop);waiting();lockf(stdout,1,0);printf("child process 2 is killed by parent! n");lockf(stdout,0,0);exit(0);}}else{wait_mark = -1;signal(16,stop);waiting();lockf(stdout,1,0);printf("child process 1 is killed by parent! n");lockf(stdout,0,0);exit(0);}}void waiting(){while (wait_mark != 0);}void stop(){wait_mark = 0;}〈运行结果〉child process 1 is killed by parent!child process 2 is killed by parent!parent process is killed!分析：上述程序中，使用函数signal()都放在一段程序的前面部位，而不是在其他接收信号处。只是因为signal()的执行只是为进程指定信号量16或17的作用，以及分配相应的与stop()过程链接的指针。从而，signal()函数必须在程序前面部分执行。

分析怎样实现的对共享存储区的互斥和同步？

p(producer()n);

你说的这个是远程和备份，需要在PC1上登录客户端软件通过花生壳或其他域名域名解析出去，然后你在PC2上面通过解析出来的域名登录上去进行和存储即可。不过远程效果很一般，图像也不连续，除非你是光线上网这样才会好一点。

管道通信中如何实现对管道的互斥使用?父子进程的同步又是如何实现的? 消息通信的工作原理是什么？

UNTIL FALSE UNTIL FALSE

我们迪哥的：

while(true){

当进程要与其它进程通讯时，可利用msgsnd()系统调用来发送消息。对于msgsnd()系统调用，核心检查消息队列描述符合许可权是否合法，消息长度是否超过系统规定的长度。通过检查后，核心为消息分配消息数据区，并将消息从用户消息缓冲区拷贝到消息数据区。分配消息首部，将它链入消息队列的末尾；在消息首部中填写消息的类型、大小以及指向消息数据区的指针等；还要修改消息队列头标中的数据(如消息队列中的消息数、字节数等)。然后，唤醒等待消息到来的睡眠进程。 消息的接收： 进程可利用msgrcv()系统调用，从指定消息队列中读一个消息。对于msgrcv()系统调用，先由核心检查消息队列标识符合许可权，继而根据用户指定的消息类型做相应的处理。消息类型msgtyp的参数可能有三种情况：当msgtyp=0时髦核心寻找消息队列中的个消息，并将它返回给调用进程；当msgtyp为正整数时，核心返回指定类型的个消息；当msgtyp为负整数时，核心应在其类型值小于或等于msgtyp的所有消息中，选出类型值的个消息返回。如果所返回消息的大小等于或小于用户的要求，核心便将消息正文拷贝到用户区，再从队列中删除该消息，并唤醒睡眠的发送进程；如果消息长度比用户要求的大，则系统返回出错信息。用户也可以忽略对消息大小的限制，此时，核心无需理会消息的大小而一概把消息内容拷贝到用户区。

用C语言编写程序：生产者和消费者之间实现同步与互斥问题

//程序中有注释部分和需要他自己完善的部分，我给的是框架

//老师只是要求用C程序模拟这个机制来实现，就是通过你所学的知识模拟一个效果即可

//如果两者同时对存储区作，即同时取和生产的话，必定会有一个等待，当另一个完成作后自己才会被唤醒。

//生产者在存储区满时不能再生产，进入等待，消费者同理

//完成同步互斥效果

/----以下为代码部分-----/

//定义全局变量

int

empty

=1;//信号量表示存储单元while(true){空，可以生产产品

int

full

=0;//信号量表示存储单元空，不可以消费产品

//P作

void

P(int

&mutex)

{mutex--;

if(mutex<0)

{//当前进程挂起的程序实现

//V作

void

V(int

&mutex)

{mutex++;

if(mutex

<=0)

{//唤醒等待中的进程程序实现

//生产者程序

void

{P(&

empty);//若此时存储区空，则可以生产，否则程序挂起等待

V(&full);//通知消费者进程，可以取产品

}//消费者程序

void

consumer(){

P(&full);//若此时存储区不空，则可以取产品，否则消费者程序挂起等待

//取走一个产品作

V(&

empty);//通知生产者进程可以生产

}//主函数

void

main()

{////希望对你朋友有启发分别调用生产者，消费者程序，顺序不限，因为已经完成信号量的同步，若发生同步问题就会等待

producer()；

producer()；

………………

//程序中有注释部分和需要他自己完善的部分，我给的是框架

//老师只是要求用C程序模拟这个机制来实现，就是通过你所学的知识模拟一个效果即可

//如果两者同时对存储区作，即同时取和生产的话，必定会有一个等待，当另一个完成作后自己才会被唤醒。

//生产者在存储区满时不能再生产，进入等待，消费者同理

//完成同步互斥效果

/----以下为代码部分-----/

//定义全局变量

int

empty

=1;//信号量表示存储单元空，可以生产产品

int

full

=0;//信号量表示存储单元空，不可以消费产品

//P作

void

P(int

&mutex)

{mutex--;

if(mutex<0)

{//当前进程挂起的程序实现

//V作

void

V(int

&mutex)

{mutex++;

if(mutex

<=0)

{//唤醒等待中的进程程序实现

//生产者程序

void

{P(&

empty);//若此时存储区空，则可以生产，否则程序挂起等待

V(&full);//通知消费者进程，可以取产品

}//消费者程序

void

consumer(){

P(&full);//若此时存储区不空，则可以取产品，否则消费者程序挂起等待

//取走一个产品作

V(&

empty);//通知生产者进程可以生产

}//主函数

void

main()

{//分别调用生产者，消费者程序，顺序不限，因为已经完成信号量的同步，若发生同步问题就会等待

producer()；

producer()；

………………

//程序中有注释部分和需要他自己完善的部分，我给的是框架

//老师只是要求用C程序模拟这个机制来实现，就是通过你所学的知识模拟一个效果即可

//如果两者同时对存储区作，即同时取和生产的话，必定会有一个等待，当另一个完成作后自己才会被唤醒。

//生产者在存储区满时不能再生产，进入等待，消费者同理

//完成同步互斥效果

/----以下为代码部分-----/

//定义全局变量

int

empty

=1;//信号量表示存储单元空，可以生产产品

int

full

=0;//信号量表示存储单元空，不可以消费产品

//P作

void

P(int

&mutex)

{mutex--;

if(mutex<0)

{//当前进程挂起的程序实现

//V作

void

V(int

&mutex)

{mutex++;

if(mutex

<=0)

{//唤醒等待中的进程程序实现

//生产者程序

void

{P(&

empty);//若此时存储区空，则可以生产，否则程序挂起等待

V(&full);//通知消费者进程，可以取产品

}//消费者程序

void

consumer(){

P(&full);//若此时存储区不空，则可以取产品，否则消费者程序挂起等待

//取走一个产品作

V(&

empty);//通知生产者进程可以生产

}//主函数

void

main()

{//分别调用生产者，消费者程序，顺序不限，因为已经完成信号量的同步，若发生同步问题就会等待

producer()；

producer()；

………………

//程序中有注释部分和需要他自己完善的部分，我给的是框架

//老师只是要求用C程序模拟这个机制来实现，就是通过你所学的知识模拟一个效果即可

//如果两者同时对存储区作，即同时取和生产的话，必定会有一个等待，当另一个完成作后自己才会被唤醒。

//生产者在存储区满时不能再生产，进入等待，消费者同理

//完成同步互斥效果

/----以下为代码部分-----/

//定义全局变量

intempty=1;//信号量表示存储单元空，可以生产产品

intfull=0;//信号量表示存储单元空，不可以消费产品

//P作

voidP(int&mutex)

{mutex--;

if(mutex<0)

{//当前进程挂起的程序实现

//V作

voidV(int&mutex)

{mutex++;

if(mutex<=0)

{//唤醒等待中的进程程序实现

//生产者程序

voidproducer()

{P(&empty);//若此时存储区空，则可以生产，否则程序挂起等待

V(&full);//通知消费者进程，可以取产品

}//消费者程序

voidconsumer(){

P(&full);//若此时存储区不空，则可以取产品，否则消费者程序挂起等待

//取走一个产品作

V(&empty);//通知生产者进程可以生产

}//主函数

voidmain()

{//分别调用生产者，消费者程序，顺序不限，因为已经完成信号量的同步，若发生同步问题就会等待

producer()；

producer()；

………………

为什么说互斥也是一种同步

//生产一个产品作

互斥指的是某种资源一次只允许一个进程使用，即你在使用的时候我不能使用；我在使用的时候你不能使用。这就是一种协调，一种步伐上的一致，因而也就是一种同步。但是，为了求解实际问题，将同步与互斥加以区别是有好处的，因为这两种问题的求解方法是不同的。

：随机试验E的样本空间 的子集(或某些样本点的子集），称为E的随机，简称。

包含关系：一般地，对于A与B，如果A发生，则B一定发生，这时称B包含A（或称A包含于B）。

并（和）：若某发生当且仅当A发生或B发生，则称此为A和Bconsumer()；的并（或和）。

互斥，数学名词，A与B在任何一次试验中都不会同时发生，则称A与B互斥。

作系统进程同步的基本概念?

{while(TRUE){

我们把异步环境下的一组并发进程因直接制约而互相发送消息而进行互相合作、互相等待，使得各进程按一定的速度执行的过程称为进程间的同步。具有同步关系的一组并发进程称为合作进程，合作进程间互相发送的信号称为消息或。 如果我们对一个消息或赋以的消息名，则我们可用过程wait (消息名)表示进程等待合作进程发来的消息，而用过程signal (消息名) 表示向合作进程发送消息。

外部总线又称为系统总线。众多的功能部件要正常的动作，必须有一个统一的指挥，这个就是时钟信号。

在单机条件下，诸进程运行于同一个处理机和内存环境中，进程通信十分简单。进程之间可以借助于“共享存储器”进行直接通信。而在多机条件下，相互合作的进程可能在不同的处理机上运行，进程间的通信涉及处理机的通信问题。在松散耦合系统中，进程间通信还可能要通过较长的通信信道，甚至网络。因此，在多机条件下，广泛采用间接通信方式，即进程间是通过消息进行通信的。 在分布式作系统中，为了实现进程的同步，首先要对系统中发生的进行排序，还要有良好的分布式同步算法。

请用信号量机制实现这三个进程的同步与互斥活动，并说明所定义的信号量的含义。要求用伪代码描述。

总线带宽＝总线位宽总线工作频率/8

解：缓冲区是一互斥信号量，因此设互斥信号量

mutex

P1、P2

因为奇数的设置与取用而同步，设同步信号量odd

P1、P3因为偶数的设置与取用而同步，设同步信号量n；

P1、P2、P3因为共享缓冲区，设同步信号量empty。

semaphore

mutex=1;

//

缓冲区互斥信号量

semaphore

odd=0, n=0 //

奇数、偶数进程的同步信号量

semaphore

empty=N //

空缓冲区单元个数信号量

main( )

cobegin{

process P1

number=produce();

p(empty); //

递减空缓冲区的单元个数

p(mutex); //

互斥访问缓冲区

put(

);

v(mutex); //

恢复访问缓理由是：页面大小为4096字节，4096等于2的12次方。故页内地址为12位。又逻辑地址长度为16位。故高4位表示页号。则逻辑地址2F6AH在第2页。根据页表可知，第2页存于第14块中。14的十六进制为EH，与低12位F6AH拼接得物理地址为EF6AH冲区

为偶数允许取偶数

else v(odd); //

为奇数允许取奇数

}process P2

process P3

p(odd); //

互斥奇数

p(mutex); //

互斥访问缓冲区

getodd(

);

getnd(

);

v(mutex); //

恢复访问缓冲区

v(mutex);

v(empty); //

递增空缓冲区的单元个数

v(empty);

countodd(); }

countn();}

}coend

Linux进程通信实验报告

while(true){

一、实验}}目的：

进一步认识并发（并行）执行的概念，区别顺序执行和并发（并行）执行。

分析进程争用临界资源的现象，学习解决进程排斥的方法。

二、实验环境：

一台至少具有256MB内存的计算机，并安装Red Hat Linux 9的Linux作系统。

三、实验内容：

1. 预备知识

fork函数调用：创建一个新进程。

getpid函数调用：获得一个进程的pid。

lockf系统的调用：在进程同步控制中为进程加锁。

2. 编写一段程序（程序名为fork1.c），使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。

（1）进入Linux作系统。

（2）打开终端。进入vi编译器。

（3）输入源程序代码。

（4）按Esc键，进入命令模式后，输入“： wq文件名”就可以运行该程序了。

作系统“进程同步”的基本概念是什么?

：由A出现而B不出现所组成的称为 A 与 B 的。

1、概念：进程同步是一个作系统级别的概念,是在多道程序的环境下，存在着不同的制约关系，为了协调这种互相制约的关系，实现资源共享和进程协作，从而避免进程之间的冲突，引入了进程同步。

2、进程的同步与互斥

（1）进程的同步与互斥是指进程在推进时的相互制约关系。在多道程序系统中，由于资源共享与进程合作，这种进程间的制约称为可能。为了保证进程的正确运行以及相互合作的进程之间交换信息，需要进程之间的通信。进程之间的制约关系体现为：进程的同步和互斥。

（2）进程同步：它主要源于进程合作，是进程间共同完成一项任务时直接发生相互作用的关系。为进程之间的直接制约关系。在多道环境下，这种进程间在执行次序上的协调是必不可少的。

（3）进程互斥：它主要源于资源共享，是进程之间的间接制是EF6AH。约关系。在多道系统中，每次只允许一个进程访问的资源称为临界资源，进程互斥就是保证每次只有一个进程使用临界资源。

3、临界资源和临界区：

一次只允许一个进程使用的共享资源称为临界资源，如打印机、公共变量等；而在并发进程中与共享变量有关的程序段称为临界区。对临界区的访问必须是互斥进行。进程进入临界区要满足一定的条件，以保证临界资源的安全使用，系统的正常运行，即对临界区的管理就遵循以下三个原则：

（1）当有若干进程要求进入它们的临界区时，应在有限时间内使一进程进入临界区。换句话说，它们不应该相互等待而致使谁都不能进入。

（2）每次最多有一个进程处于临界区内。

（3）进程在临界区内逗留应在有限时间范围内。

求经典同步互斥问题-"司机和售票员“问题

相等关系：一般地，对A与B，若 且 ，那么称A与B相等，记作A=B 。

司机 P1 售票员 P2

//整个程序以伪代码形式给出，当做一个提示吧，这样你同学就应该有思路了

REPEAT REPEAT

启动 ① 关门 ②

正常运行 售票 关门－启动－行驶－停－开门

到站停 ③ 开门 ④

为了安全起见：

(1)关车门后才能启辆 －启动在关门之后

(2)到站停车后，才能开车门 －开车门在到站停车之后

在计算机系统中可以将司机和售票员分别看作P1、P2两个进程，当它们并发地向前推进时，计算机系统所接受到的实际上是司机活动与售票员活动的许多交叉中的任意一个交叉，这些交叉有些满足上述要求，有些则不满足，而作系统必须保证不发生不满足上述要求的交叉，即：

如P2尚未推进到②处时，而P1已推进到①处，则P1应等待直到P2推进到②处为止；

如P1尚未推进到③时，P2已到④，则P2应等待直到P1推进到③处为止。

P1在①处发生了等待，则P2执行到②处时应将P1唤醒；

P2在④处发生了等待，P1到③处应将P2唤醒。

一组相互合作的并发进程，为了协调其推进速度，有时需要相互等待与相互唤醒，进程之间这种相互制约的关系称作进程同步，虽然进程同步仅发生在相互有逻辑关系的进程之间，这种相互制约的关系称作进程同步，进程同步现象仅发生在相互有逻辑关系的进程之间，这点与进程互斥不同，进程互斥现象发生在任意两个进程之间。

与进程同步相关的另一概念是进程合作，一组进程如果它们单独执行不能正常进行，但并发执行可以正常进行，这种现象称为进程合作，参与进程合作的进程称为合作进程，如司机与售票员的例子，二者单独执行都不能正常进行，但二者并发反可以正常进行，成为合作进程，这种进程合作的现象在作系统中经常发生。

解法一：

struct semaphore s1,s2=0,0;

cobegin

void driver(void)

p(s2);

启辆;

正常行车;

到站停车;

V(s1);}

}void conductor(void)

上、下乘客；关车门；

V(s2);

售票；

P(s1);

开车门;上、下乘客;}

}coend

解法二：

struct semaphore s1,s2=1,0;

cobegin

void driver(void)

P(s2);

启辆;

正常行车;

到站停车;

V(s1);}

}void conductor(void)

P(s1);

开车门;

关车门;

}coend