Linux进程通信实验报告

一、实验目的：

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

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

二、实验环境：

一台至少具有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文件名”就可以运行该程序了。

#include<algorithm>

#include<iomanip>

#include<conio.h>

using namespace std

struct PCB

{

string p_name//程序名

int super//优先级

double ndtime//需要时间

double runtime//运行时间

string state//状态

bool operator<(const PCB&nd)

{

return super>nd.super

}

}

int main()

{

int n,i,j,nn=0

cout<<"\n请输入进程总个数？"

cin>>n

PCB *PB=new PCB[n]

for(i=0i<ni++)

{

cout<<"\n\n进程号No."<<i<<":"<<endl

cout<<"\n输入进程名:"

cin>>PB[i].p_name

cout<<"\n输入进程优先级数<0~99>:"

cin>>PB[i].super

cout<<"\n输入进程运行时间:"

cin>>PB[i].ndtime

nn +=PB[i].ndtime

PB[i].runtime =0PB[i].state ="W"

}

sort(PB,PB+n)

int k=PB[0].super

queue<PCB>*que=new queue<PCB>[k+1]

for(i=0i<ni++)

que[PB[i].super ].push (PB[i])

cout<<setfill(' ')

cout<<setiosflags(ios::left)

for(i=0i<nni++)

{

PCB PP=que[k].front()

int kk

for(kk=0kk<nkk++)

if(PP.p_name ==PB[kk].p_name) break

PB[kk].state ="R"

cout<<"\n\n按任意键继续......"

getch()

cout<<"\n\n*-*-*-*-*-*-*-* The excute number:"<<i+1<<" *-*-*-*-*-*-*-*"

cout<<"\n\n*-*-*-*-*-*-* 当前正在运行的进程是: "<<PP.p_name <<" *-*-*-*-*-*-*"

cout<<"\n\np_name state super ndtime runtime"

cout<<"\n |"<<setw(10)<<PP.p_name <<" |"<<setw(6)<<PB[kk].state <<" |"<<setw(6)

<<PP.super <<" |"<<setw(11)<<PP.ndtime <<" |"<<PP.runtime

PP.runtime +=1PB[kk].runtime +=1

if(PB[kk].super >0) PB[kk].super -=1

que[k].pop ()

cout<<"\n\n*-*-*-*-*-*-* 当前就绪队列状态为: *-*-*-*-*-*-*"

for(j=0j<nj++)

if(PB[j].state =="W")

{

cout<<"\n\np_name state super ndtime runtime"

cout<<"\n |"<<setw(10)<<PB[j].p_name <<" |"<<setw(6)<<PB[j].state <<" |"<<setw(6)

<<PB[j].super <<" |"<<setw(11)<<PB[j].ndtime <<" |"<<PB[j].runtime

}

if(PP.runtime ==PP.ndtime )

{

PB[kk].state ="F"

cout<<"\n\n时间片到期，此时进程["<<PB[kk].p_name <<"]已完成."

if(que[k].empty ()&&k>0) k--

}

else

{

PB[kk].state ="W"

if(k>0) que[k-1].push (PB[kk])

else que[k].push (PB[kk])

if(que[k].empty ()&&k>0) k--

}

}

cout<<"\n\n进程已全部完成."<<endl<<endl

return 0

}

整个程序都是模拟“最高优先级”进程调度算法的程序啊

我是用C++写的 你用编译器编译下 然后运行下 就知道怎么回事了

轮转法很简单，，，就不写了

不给我分数我觉得很冤枉 因为为了这个程序我写了1个多小时

没有功劳也会苦劳啊

这一篇记录一下共享内存实验，需要linux的共享内存机制有一定的了解，同时也需要了解POSIX信号量来实现进程间的同步。可以参考以下两篇博客: https://blog.csdn.net/sicofield/article/details/10897091

https://blog.csdn.net/ljianhui/article/details/10253345

实验要求：编写sender和receiver程序，sender创建一个共享内存并等待用户输入，然后把输入通过共享内存发送给receiver并等待，receiver收到后把消息显示在屏幕上并用同样方式向sender发送一个over，然后两个程序结束运行。

这个实验的难点主要在于共享内存的创建和撤销（涉及到的步骤比较多，需要理解各步骤的功能），以及实现两个进程间的相互等待（使用信号量来实现，这里使用了有名信号量）

实验心得：学习理解了linux的共享内存机制以及POSIX信号量机制。

两个实验虽然加强了对linux一些机制的理解，但是感觉对linux的学习还不够，需要继续学习。

---