实验报告三进程管理及进程通信
实验三进程管理及进程通信
实验环境：
Linux操作系统
实验目的：
（1）利用Linux提供的系统调用设计程序，加深对进程概念的理解。
（2）体会系统进程调度的方法和效果。
（3）了解进程之间的通信方式以及各种通信方式的使用。
实验方法：
用vi 编写c 程序（假定程序文件名为prog1.c）编
译程序
$ gcc -o prog1.o prog1.c
或 $ cc -o prog1.o prog1.c
运行
$./prog1.o
实验内容及步骤：
实验1
编写程序。显示进程的有关标识（进程标识、组标识、用户标识等）。经过5 秒钟后，执行另一个程序，最后按用户指示（如：Y/N）结束操作。
编程截图：
运行结果：
实验2
参考例程1，编写程序。实现父进程创建一个子进程。体会子进程与父进程分
别获得不同返回值，进而执行不同的程序段的方法。
例程1：利用fork()创建子进程
/* 用fork()系统调用创建子进程的例子*/
main()
{
int i;
if (fork()) /*父进程执行的程序段*/
i=wait(); /* 等待子进程结束*/{
printf("It is parent process.\n");
printf("The child process,ID number %d, is finished.\n",i);
}
else{
Printf(“It is child process.\n”);
Sleep(10);
Exit();
}
}
运行结果：
思考：
子进程是如何产生的？又是如何结束的？子进程被创建后它的运行环境是怎样建立的？
答：是由父进程用fock()函数创建形成的，通过exit()函数自我结束，子进程被创建后核心
将其分配一个进程表项和进程标识符，检查同时运行的进程数目，并且拷贝进程表项的数据，由子进程继承父进程所有文件。
实验3
参考例程2，编写程序。父进程通过循环语句创建若干子进程。探讨进程的家族树
以及子进程继承父进程的资源的关系。
例程2：循环调用fork()创建多个子进程。
/*建立进程树*/
#include
main()
{ int i;
printf(“My pid is %d, my father’s pid is %d\n”,getpid()
,getppid());
for(i=0; i<3; i++)
if(fork()==0)
printf(“%d pid=%d ppid=%d\n”, i,getpid(),getppid());
else
{ j=wait(0);
Printf(“%d:The chile %d is finished.\n”,getpid(),j);
}
}
运行结果：
思考：
①画出进程的家族树。
实验4
参考例程3 编程，使用fork( )和exec( )等系统调用创建三个子进程。子进程分别启动不同程序，并结束。反复执行该程序，观察运行结果，结束的先后，看是否有不
同次序。
例程3:创建子进程并用execlp()系统调用执行程序的实验
/*创建子进程，子进程启动其它程序*/
#include
#include
main()
{
int child_pid1,child_pid2,child_pid3;
int pid,status;
setbuf(stdout,NULL);
child_pid1=fork(); /*创建子进程1*/
if(child_pid1==0)
{ execlp("echo","echo","child process 1",(char *)0); /*子进程1 启动其它程
序*/
perror("exec1 error.\n ");
exit(1
);
}
child_pid2=fork(); /*创建子进程2*/
if(child_pid2==0)
{ execlp("date","date",(char *)0); /*子进程2 启动其它程序*/ perror("exec2 error.\n ");
exit(2);
}
child_pid3=fork(); /*创建子进程3*/
if(child_pid3==0)
{ execlp("ls","ls",(char *)0); /*子进程3 启动其它程序*/
perror("exec3 error.\n ");
exit(3);
}
puts("Parent process is waiting for chile process return!");
while((pid=wait(&status))!=-1) /*等待子进程结束*/
{ if(child_pid1==pid) /*若子进程1 结束*/
printf("child process 1 terminated with status %d\n",(status>>8));
else
{if(child_pid2==pid) /*若子进程2 结束*/
printf("child process 2 terminated with status %d\n",(status>>8));
else
{ if(child_pid3==pid) /*若子进程3 结束*/
printf("child process 3 terminated with status %d\n" ,(status>>8));
}
}
}
puts("All child processes
terminated."); puts("Parent
process terminated."); exit(0);
}
运行结果：
思考：
子进程运行其它程序后，进程运行环境怎样变化的？反复运行此程序看会有
什么情况？解释一下。
答：子进程运行其他程序后，这个进程就完全被新程序替代。由于并没有产生新进程，所以进程标识号不变，除此之外的旧进程的其他信息，代码段，数据段，栈段等均被新程序的信息所替代。新程序从自己的main()函数开始进行。反复运行此程序发现结束的先后次序是不可预知的，每次运行的结果不一样。原因是当每个子进程运行其他程序是，他们的结束随着其他程序的结束而结束，所以结束的先后次序在变化。
实验5
参考例程4 编程，验证子进程继承父进程的程序、数据等资源。如用父、子进程修改公共变量和私有变量的处理结果；父、子进程的程序区和数据区的位置。
例程4：观察父、子进程对变量处理的影响
/*创建子进程的实验。子进程继承父进程的资源，修改了公共变量globa 和私有变量vari。观察变化情况。*/
#include
#include
#include
int globa=4;
int main()
{
pid_t pid; int vari=5; printf("before fork.\n");
if ((pid=fork())<0)/*创建失败处理*/
{
printf("fork error.\n");
exit(0);
}
else
if(pid==
0)
{ /*子进程执行*/
globa++;
vari--;
printf("Child %d changed the vari and globa.\n",getpid());
}
else /*父进程执行*/
printf("Parent %d did not changed the vari and
globa.\n",getpid());
printf("pid=%d, globa=%d, vari=%d\n",getpid(),globa,vari); /*都执行
*/
exit(0);
}
运行结果：
思考：
子进程被创建后，对父进程的运行环境有影响吗？解释一下
答：父进程被创建后，对父进程的运行环境无影响，因为当子进程在运行时，他有自己的代码段和数据段，这些都可以做修改。但是父进程的代码和数据段是不会随着子进程数据段和代码段的改变而改变。
实验6
参照《实验指导》第五部分中“管道操作的系统调用”。复习管道通信概念，参考例程5，编写一个程序。父进程创建两个子进程，父子进程之间利用管道进行通信。要求能显示父进程、子进程各自的信息，体现通信效果。
例程5：管道通信的实验
/*程序建立一个管道fd*/
/*父进程创建两个子进程P1、P2 */
/*子进程P1、P2 分别向管道写入信息*/
/*父进程等待子进程结束，并读出管道中的信息*/
#include
main()
{
int i,r,j,k,l,p1,p2,fd[2];
char buf[50],s[50];
pipe(fd); /*建立一个管道fd*/
while((p1=fork())==-1); /*创建子进程1*/
if(p1==0)
lockf(fd[1],1,0); /*子进程1 执行*/
/*管道写入端加锁*/
sprintf(buf,"Child process P1 is sending messages! \n");
printf("Child process P1! \n");
write(fd[1],buf
,50);
lockf(fd[1],0,0); sleep(5);
j=getpid();
k=getppid(); /*信息写入管道*/ /*管道写入端解锁
*/
printf("P1 %d is weakup. My parent process ID is %d.\n",j,k); exit(0);
}
else
{ while((p2=fork())= =-1);
if(p2==0)
{
lockf(fd[1],1,
0);/*创建子进程2*/
/*子进程2 执行*/ /*管道写入端加锁*/
sprintf(buf,"Child process P2 is sending messages! \n"); printf("Child process P2! \n");
write(fd[1],buf
,50);
lockf(fd[1],0,0); sleep(5);
j=getpid();
k=getppid(); /*信息写入管道*/ /*管道写入端解锁*/
printf("P2 %d is weakup. My parent process ID is %d.\n",j,k);
exit(0);
}
else
{ l=getpid();
wait(0);
if(r=read(fd[0],s,50)==-1)
printf("Can't read pipe. \n");
else
printf("Parent %d: %s \n",l,s);
wait(0);
if(r=read(fd[0],s,50)==-1)
printf("Can't read pipe. \n");
Else
printf("Parent %d: %s \n",l,s);
exit(0);
}
}
}
运行结果：
思考：
①什么是管道？进程如何利用它进行通信的？解释一下实现方法。
②修改睡眠时机、睡眠长度，看看会有什么变化。请解释。
③加锁、解锁起什么作用？不用它行吗？
答：
（1）管道是指能够连接一个写进程和一个读进程，并允许他们以生产者-消费者方式进行通信的一个共享文件。由写进程从管道的入端将数据写入管道，而读进程则从管道出端读出数据来进行通信。
（2）修改睡眠时间和睡眠长度都回引起进程的被唤醒的时间不一，因为睡眠时间决定进程在合适睡眠，睡眠长度决定进程合适被唤醒。
（3）加锁、解锁是为了解决临界资源的共享问题。不用它将会引起无法有效管理数据，即数据会被修导致读错了数据。
实验7：
编程验证：实现父子进程通过管道进行通信。进一步编程，验证子进程结束，由父进程执行撤消进程的操作。测试父进程先于子进程结束时，系统如何处理“孤儿进程”的。
思考：对此作何感想，自己动手试一试？解释一下你的实现方法。
答：只要在父进程后加上wait()函数，然后打印“子进程已经结束”，一旦子进程结束，父进程撤销进程。当父进程先于子进程终止时，所有子进程的父进程改变为init进程称为由init进程领养。
实验8
编写两个程序一个是服务者程序，一个是客户程序。执行两个进程之间通过消息机制通信。消息标识MSGKEY 可用常量定义，以便双方都可以利用。客户将自己的进程标识（pid）通过消息机制发送给服务者进程。服务者进程收到消息后，将自己的进程号和父进程号发送给客户，然后返回。客户收到后显示服务者的pid 和ppid，结束。
例程6：消息通信的实验
/*客户进程向服务器进程发出信号，服务器进程接收作出应答，并再向客户返回消息。*/ ===============================
/*服务者程序*/
/*The server receives the message from client,and answer a message*/
#include
#include
#include
#define MSGKEY 75 struct msgform
{
/*定义消息结构*/
long mtype;
char mtext[256];
}msg;
int msgqid;
main()
{
int i,pid,* pint; extern cleanup(); for(i=0;i<20;i++) signal(i,cleanup); msgqid=msgget(MSGKEY,0777|IPC_CREAT);
for(;;)
{
/*设置软中断信号的处理程序*/
/*建立消息队列*/
/*等待接受消息*/
msgrcv(msgqid,&msg,256,1,0); /* 接受消息*/
pint=(int *)msg.mtext;
pid=*pint;
printf("Server :receive from pid %d\n",pid);
msg.mtype=pid;
*pint=getpid();
msgsnd(msgqid,&msg,sizeof(int),0);
}
}
/*显示消息来源*/
/*加入自己的进程标识*/
/*发送消息*/
cleanup()
{
msgctl(msgqid,IPC_RMID,0);
exit();
}
================================
/*客户程序*/
/*The client send a message to server,and receives another message from server*/ #include
#include
#include
#define MSGKEY 75
struct msgform
{
/*定义消息结构*/
long mtype;
char mtext[256];
};
main()
{
struct msgform msg; int msgqid,pid,*pint; msgqid=msgget(MSGKEY,0777); pid=getpid();
pint=(int *)msg.mtext;
*pint=pid;
msg.mtype=1;
msgsnd(msgqid,&msg,sizeof(int),0);
msgrcv(msgqid,&msg,256,pid,0);
printf("Clint : receive from pid %d\n",* pint);
}
思考：
想一下服务者程序和客户程序的通信还有什么方法可以实现？解释一下你的设想，有兴趣
试一试吗。
答：还可以用信号量机制来实现。信号量是一个整型计数器，用来控制多个进程对共享资源
的访问。或者通过消息队列信号机制，通过向消息队列发送信息、接受信息来实现进程间的
通信。
实验9
编程实现软中断信号通信。父进程设定软中断信号处理程序，向子进程发软中断信号。子
进程收到信号后执行相应处理程序。
例程7：软中断信号实验
/* 父进程向子进程发送18 号软中断信号后等待。子进程收到信号，执行指定的程序，再
将父进程唤醒。*/
main()
{
int i,j,k;
int func();
signal(18,func()); /*设置18 号信号的处理程序*/
if(i=fork())
{
j=kill(i,18);
/*创建子进程*/
/*父进程执行*/
/*向子进程发送信号*/
printf("Parent: signal 18 has been sent to child %d,returned %d.\n",i,j); k=wait(); /*父进程被唤醒*/ printf("After wait %d,Parent %d: finished.\n",k,getpid());
}
else
{ /*子进程执行*/
sleep(10);
printf("Child %d: A signal from my parent is recived.\n",getpid());
} /*子进程结束，向父进程发子进程结束信号*/
}
func() /*处理程序*/
{ int m;
m=getpid();
printf("I am Process %d: It is signal 18 processing function.\n",m);
}
实验结果：
思考：这就是软中断信号处理，有点儿明白了吧？讨论一下它与硬中断有什么区别？看来还挺管用，好好利用它。
答;硬中断是由外部硬件产生的，而软化总段是CPU根据软件的某条指令或者软件对标志寄存器的某个标志位的设置而产生的。
体会：
这次实验还是存在很多的不足，比如一些实验结果没有截图，或者是没有完全弄懂。但是结合后面的思考题部分，让我更了解了所做实验的内容。这次实验也是对课堂内容的加深理解，总的来说还是很不错的。
Linux进程间通信(2)实验报告
实验六：Linux进程间通信（2）（4课时） 实验目的： 理解进程通信原理；掌握进程中信号量、共享内存、消息队列相关的函数的使用。实验原理： Linux下进程通信相关函数除上次实验所用的几个还有： 信号量 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前一节的共享内存方式的进程间通信。要调用的第一个函数是semget，用以获得一个信号量ID。 int semget(key_t key, int nsems, int flag); key是IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。 semctl函数用来对信号量进行操作。 int semctl(int semid, int semnum, int cmd, union semun arg); 不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。 semop函数自动执行信号量集合上的操作数组。 int semop(int semid, struct sembuf semoparray[], size_t nops); semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。 ftok原型如下： key_t ftok( char * fname, int id ) fname就是指定的文件名(该文件必须是存在而且可以访问的)，id是子序号，虽然为int，但是只有8个比特被使用(0-255)。 当成功执行的时候，一个key_t值将会被返回，否则-1 被返回。 共享内存 共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。首先要用的函数是shmget，它获得一个共享存储标识符。 #include
线程实现邮箱通信-实验报告
进程通信实验报告 一、实验名称：进程通信 二、实验目的：掌握用邮箱方式进行进程通信的方法，并通过设计实现简单邮箱理解进程通信中的同步问题以及解决该问题的方法。 三、实验原理：邮箱机制类似于日常使用的信箱。对于用户而言使用起来比较方便，用户只需使用send （）向对方邮箱发邮件 receive （）从自己邮箱取邮件， send （）和 receive （）的内部操作用户无需关心。因为邮箱在内存中实现，其空间有大小限制。其实send （）和 receive （）的内部实现主要还是要解决生产者与消费者问题。 四、实验内容：进程通信的邮箱方式由操作系统提供形如send （）和receive （）的系统调用来支持，本实验要求学生首先查找资料了解所选用操作系统平台上用于进程通信的系统调用具体形式，然后使用该系统调用编写程序进行进程间的通信，要求程序运行结果可以直观地体现在界面上。在此基础上查找所选用操作系统平台上支持信号量机制的系统调用具体形式，运用生产者与消费者模型设计实现一个简单的信箱，该信箱需要有创建、发信、收信、撤销等函数，至少能够支持两个进程互相交换信息，比较自己实现的信箱与操作系统本身提供的信箱，分析两者之间存在的异同。 五、背景知识介绍： 1、sembuf 数据结构 struct sembuf { unsigned short int sem_num; //semaphore number short int sem_op; //semaphore operation short int sem_flg; //operation flag }; sem_num ：操作信号在信号集中的编号，第一个信号的编号是0。 进程A 进程B 信箱A 信箱B Send() Send() receive() receive()
实验三-进程管理
实验三进程管理 一、实验目的 1．熟悉和理解进程和进程树的概念，掌握有关进程的管理机制 2．通过进程的创建、撤销和运行加深对进程并发执行的理解 3．明确进程与程序、并行与串行执行的区别 4．掌握用C 程序实现进程控制的方法 二、实验学时 2学时 三、实验背景知识 所涉及的系统调用 1、exec( )系列（exec替换进程映像） 系统调用exec( )系列，也可用于新程序的运行。fork( )只是将父进程的用户级上下文拷贝到新进程中，而exec( )系列可以将一个可执行的二进制文件覆盖在新进程的用户级上下文的存储空间上，以更改新进程的用户级上下文。exec( )系列中的系统调用都完成相同的功能，它们把一个新程序装入内存，来改变调用进程的执行代码，从而形成新进程。如果exec( )调用成功，调用进程将被覆盖，然后从新程序的入口开始执行，这样就产生了一个新进程，新进程的进程标识符id 与调用进程相同。 exec( )没有建立一个与调用进程并发的子进程，而是用新进程取代了原来进程。所以exec( )调用成功后，没有任何数据返回，这与fork( )不同。exec( )系列系统调用在UNIX系统库unistd.h中，共有execl、execlp、execle、execv、execvp五个，其基本功能相同，只是以不同的方式来给出参数。 #include
windows进程管理实验报告
实验报告 课程名称：操作系统 实验项目：windows进程管理 姓名： 专业：计算机科学与技术 班级： 学号：
计算机科学与技术学院 计算机系 2019 年 4 月 23 日
实验项目名称： windows进程管理 一、实验目的 1. 学习windows系统提供的线程创建、线程撤销、线程同步等系统调用； 2. 利用C++实现线程创建、线程撤销、线程同步程序； 3. 完成思考、设计与练习。 二、实验用设备仪器及材料 1. Windows 7或10， VS2010及以上版本。 三、实验内容 1 线程创建与撤销 写一个windows控制台程序（需要MFC），创建子线程，显示Hello, This is a Thread. 然后撤销该线程。 相关系统调用： 线程创建： CreateThread() 线程撤销： ExitThread() 线程终止： ExitThread(0) 线程挂起： Sleep() 关闭句柄： CloseHandle() 参考代码： ; } 运行结果如图所示。 完成以下设计题目： 1. 向线程对应的函数传递参数，如字符串“hello world！”，在线程中显示。 2. 如何创建3个线程A, B, C，并建立先后序执行关系A→B→C。
实验内容2 线程同步 完成父线程和子线程的同步。父线程创建子线程后进入阻塞状态，子线程运行完毕后再唤醒。 相关系统调用： 等待对象 WaitForSingleObject(), WaitForMultipleObjects(); 信号量对象 CreateSemaphore(), OpenSemaphore(), ReleaseSemaphore(); HANDLE WINAPI CreateSemaphore( _In_opt_ LPSECURITY_ATTRIBUTES lpSemaphoreAttributes _In_ LONG lInitialCount, _In_ LONG lMaximumCount, _In_opt_ LPCTSTR lpName ); 第一个参数：安全属性，如果为NULL则是默认安全属性 第二个参数：信号量的初始值，要>=0且<=第三个参数 第三个参数：信号量的最大值 第四个参数：信号量的名称 返回值：指向信号量的句柄，如果创建的信号量和已有的信号量重名，那么返回已经存在的信号量句柄参考代码： n"); rc=ReleaseSemaphore(hHandle1,1,NULL); err=GetLastError(); printf("Release Semaphore err=%d\n",err); if(rc==0) printf("Semaphore Release Fail.\n"); else printf("Semaphore Release Success. rc=%d\n",rc); } 编译运行，结果如图所示。
进程管理实验报告文档
实验一进程管理 1．实验目的： （1）加深对进程概念的理解，明确进程和程序的区别； （2）进一步认识并发执行的实质； （3）分析进程争用资源的现象，学习解决进程互斥的方法； （4）了解Linux系统中进程通信的基本原理。 2．实验预备内容 （1）阅读Linux的源码文件，加深对进程管理概念的理解； （2）阅读Linux的fork()源码文件，分析进程的创建过程。 3．实验内容 （1）进程的创建： 编写一段程序，使用系统调用fork() 创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 源代码: #include <> #include <> #include
int p1,p2; p1=fork(); ockf()函数是将文件区域用作信号量（监视锁），或控制对锁定进程的访问（强制模式记录锁定）。试图访问已锁定资源的其他进程将返回错误或进入休态，直到资源解除锁定为止。而上面三个进程，不存在要同时进入同一组共享变量的临界区域的现象，因此输出和原来相同。 （3） a) 编写一段程序，使其实现进程的软中断通信。 要求：使用系统调用fork() 创建两个子进程，再用系统调用signal() 让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill() 向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child Process 1 is killed by Parent! Child Process 2 is killed by Parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent Process is killed!
进程管理实验报告
实验2过程管理实验报告学生号姓名班级电气工程系过程、过程控制块等基本原理过程的含义：过程是程序运行过程中对数据集的处理，以及由独立单元对系统资源的分配和调度。在不同的数据集上运行程序，甚至在同一数据集上运行多个程序，是一个不同的过程。（2）程序状态：一般来说，一个程序必须有三种基本状态：就绪、执行和阻塞。然而，在许多系统中，过程的状态变化可以更好地描述，并且增加了两种状态：新状态和终端状态。1）就绪状态，当一个进程被分配了除处理器（CPU）以外的所有必要资源时，只要获得了处理器，进程就可以立即执行。此时，进程状态称为就绪状态。在系统中，多个进程可以同时处于就绪状态。通常，这些就绪进程被安排在一个或多个队列中，这些队列称为就绪队列。2）一旦处于就绪状态的进程得到处理器，它就可以运行了。进程的状态称为执行状态。在单处理器系统中，只有一个进程在执行。在多处理器系统中，可能有多个进程在执行中。3）阻塞状态由于某些事件（如请求输入和输出、额外空间等），执行进程被挂起。这称为阻塞状态，也称为等待状态。通常，处于阻塞状态的进程被调度为-？这个队列称为阻塞队列。4）新状态当一个新进程刚刚建立并且还没有放入就绪队列中时，它被称为新状态。5）终止状态是
什么时候-？进程已正常或异常终止，操作系统已将其从系统队列中删除，但尚未取消。这就是所谓的终结状态。（3）过程控制块是过程实体的重要组成部分，是操作系统中最重要的记录数据。控制块PCB记录操作系统描述过程和控制过程操作所需的所有信息。通过PCB，一个不能独立运行的程序可以成为一个可以独立运行的基本单元，并且可以同时执行一个进程。换句话说，在进程的整个生命周期中，操作系统通过进程PCB管理和控制并发进程。过程控制块是系统用于过程控制的数据结构。系统根据进程的PCB来检测进程是否存在。因此，进程控制块是进程存在的唯一标志。当系统创建一个进程时，它需要为它创建一个PCB；当进程结束时，系统回收其PCB，进程结束。过程控制块的内容过程控制块主要包括以下四个方面的信息。过程标识信息过程标识用于对过程进行标识，通常有外部标识和内部标识。外部标识符由流程的创建者命名。通常是一串字母和数字。当用户访问进程时使用。外部标识符很容易记住。内部标识符是为了方便系统而设置的。操作系统为每个进程分配一个唯一的整数作为内部标识符。通常是进程的序列号。描述性信息（process scheduling message）描述性信息是与流程调度相关的一些有关流程状态的信息，包括以下几个方面。流程状态：表
实验一 进程管理
实验一进程管理 【实验目的】 1）加深对进程概念及进程管理各部分内容的理解。 2）熟悉进程管理中主要数据结构的设计和进程调度算法、进程控制机构、同步机构、通讯机构的实施。 【实验要求】 调试并运行一个允许n 个进程并发运行的进程管理模拟系统。了解该系统的进程控制、同步及通讯机构，每个进程如何用一个PCB 表示、其内容的设置；各进程间的同步关系；系统在运行过程中显示各进程的状态和有关参数变化情况的意义。 【实验环境】 具备Windows或MS-DOS操作系统、带有Turbo C 集成环境的PC机。 【实验重点及难点】 重点：理解进程的概念，进程管理中主要数据结构的设计和进程调度算法、进程控制机构、同步机构、通讯机构的实施。 难点：实验程序的问题描述、实现算法、数据结构。 【实验内容】 一．阅读实验程序 程序代码见【实验例程】。 二．编译实验例程 用Turbo C 编译实验例程。 三．运行程序并对照实验源程序阅读理解实验输出结果的意义。 【实验例程】 #include
init() { int j; for (j=0;j<3;j++) { pcb[j].id=j; pcb[j].status='r'; pcb[j].nextwr=NIL; printf("\n process%d priority?",j+1); scanf("%d",&i); pcb[j].priority=i; } sem[0].value=1; sem[0].firstwr=NIL; sem[1].value=1; sem[1].firstwr=NIL; for(i=1;i<3;i++) for(j=0;j<4;j++) savearea[i] [j]='0'; } float random() { int m; if (seed<0) m=-seed; else m=seed; seed=(25173*seed+13849)%65536; return(m/32767.0); } timeint(ad) char ad; { float x; x=random(); if((x<0.33)&&(exe==0))return(FALSE); if((x<0.66)&&(exe==1))return(FALSE); if((x<1.0)&&(exe==2))return(FALSE); savearea[exe][0]=i; savearea[exe][1]=ad; pcb[exe].status='t'; printf("times silce interrupt'\n process%d enter into ready.\n",exe+1); exe=NIL; return(TRUE); } scheduler()
进程管理实验报告
进程的控制 1 ．实验目的 通过进程的创建、撤消和运行加深对进程概念和进程并发执行的理解，明确进程与程序之间的区别。 【答：进程概念和程序概念最大的不同之处在于： (1)进程是动态的，而程序是静态的。 (2)进程有一定的生命期，而程序是指令的集合，本身无“运动”的含义。没有建立进程的程序不能作为1个独立单位得到操作系统的认可。 (3)1个程序可以对应多个进程，但1个进程只能对应1个程序。进程和程序的关系犹如演出和剧本的关系。 (4)进程和程序的组成不同。从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。而程序是一组有序的指令集合。】2 ．实验内容 (1) 了解系统调用fork()、execvp()和wait()的功能和实现过程。 (2) 编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。 (3) 编写一段程序，使用系统调用fork()来创建一个子进程。子进程通过系统调用execvp()更换自己的执行代码，新的代码显示“new
program.”。而父进程则调用wait()等待子进程结束，并在子进程结束后显示子进程的标识符，然后正常结束。 3 ．实验步骤 （1）gedit创建进程1.c （2）使用gcc 1.c -o 1编译并./1运行程序1.c #include
进程间通信实验报告
进程间通信实验报告 班级：10网工三班学生姓名：谢昊天学号：1215134046 实验目的和要求： Linux系统的进程通信机构 (IPC) 允许在任意进程间大批量地交换数据。本实验的目的是了解和熟悉Linux支持的消息通讯机制及信息量机制。 实验内容与分析设计： （1）消息的创建，发送和接收。 ①使用系统调用msgget (), msgsnd (), msgrev (), 及msgctl () 编制一长度为1k 的消息的发送和接收程序。 ②观察上面的程序，说明控制消息队列系统调用msgctl () 在此起什么作用？ （2）共享存储区的创建、附接和段接。 使用系统调用shmget(),shmat(),sgmdt(),shmctl(),编制一个与上述功能相同的程序。（3）比较上述（1），（2）两种消息通信机制中数据传输的时间。 实验步骤与调试过程： 1.消息的创建，发送和接收： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)在SERVER端建立一个Key为75的消息队列，等待其他进程发来的消息。当遇到类型为1的消息，则作为结束信号，取消该队列，并退出SERVER 。SERVER每接收到一个消息后显示一句“(server)received”。 (3)CLIENT端使用Key为75的消息队列，先后发送类型从10到1的消息，然后退出。最后的一个消息，既是 SERVER端需要的结束信号。CLIENT每发送一条消息后显示一句“(client)sent”。 (4)父进程在 SERVER和 CLIENT均退出后结束。 2.共享存储区的创建,附接和断接： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)SERVER端建立一个KEY为75的共享区,并将第一个字节置为-1。作为数据空的标志.等待其他进程发来的消息.当该字节的值发生变化时,表示收到了该消息,进行处理.然后再次把它的值设为-1.如果遇到的值为0,则视为结束信号,取消该队列,并退出SERVER.SERVER 每接收到一次数据后显示”(server)received”. (3)CLIENT端建立一个为75的共享区,当共享取得第一个字节为-1时, Server端空闲,可发送请求. CLIENT 随即填入9到0.期间等待Server端再次空闲.进行完这些操作后, CLIENT退出. CLIENT每发送一次数据后显示”(client)sent”. (4)父进程在SERVER和CLIENT均退出后结束。 实验结果： 1．消息的创建，发送和接收： 由 Client 发送两条消息，然后Server接收一条消息。此后Client Server交替发送和接收消息。最后一次接收两条消息。Client 和Server 分别发送和接收了10条消息。message 的传送和控制并不保证完全同步,当一个程序不再激活状态的时候,它完全可能继续睡眠,造成上面现象。在多次send message 后才 receive message.这一点有助于理解消息转送的实现机理。
Linux进程通信实验报告
Linux进程通信实验报告 一、实验目的和要求 1.进一步了解对进程控制的系统调用方法。 2.通过进程通信设计达到了解UNIX或Linux系统中进程通信的基本原理。 二、实验内容和原理 1.实验编程，编写程序实现进程的管道通信(设定程序名为pipe.c)。使 用系统调用pipe()建立一条管道线。而父进程从则从管道中读出来自 于两个子进程的信息，显示在屏幕上。要求父进程先接受子进程P1 发来的消息，然后再接受子进程P2发来的消息。 2.可选实验，编制一段程序，使其实现进程的软中断通信(设定程序名为 softint.c)。使用系统调用fork()创建两个子进程，再用系统调用 signal()让父进程捕捉键盘上来的中断信号(即按Del键)，当父进程 接受这两个软中断的其中一个后，父进程用系统调用kill()向两个子 进程分别发送整数值为16和17的软中断信号，子进程获得对应软中 断信号后分别输出相应信息后终止。 三、实验环境 一台安装了Red Hat Linux 9操作系统的计算机。 四、实验操作方法和步骤 进入Linux操作系统，利用vi编辑器将程序源代码输入并保存好，然后 打开终端对程序进行编译运行。 五、实验中遇到的问题及解决 六、实验结果及分析 基本实验 可选实验
七、源代码 Pipe.c #include"stdio.h" #include"unistd.h" main(){ int i,j,fd[2]; char S[100]; pipe(fd); if(i=fork==0){ sprintf(S,"child process 1 is sending a message \n"); write(fd[1],S,50); sleep(3); return; } if(j=fork()==0){ sprintf(S,"child process 2 is sending a message \n"); write(fd[1],S,50); sleep(3); return;
操作系统实验报告--实验一--进程管理
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类，每类数目为r1…r w。随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。 3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法：时间片轮转调度算法 本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。 三、实验环境 操作系统环境：Windows系统。 编程语言：C#。 四、实验思路和设计 1、程序流程图
2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态，W（等待）、R（运行）、B（阻塞） //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;
进程同步实验报告
实验三进程的同步 一、实验目的 1、了解进程同步和互斥的概念及实现方法； 2、更深一步的了解fork()的系统调用方式。 二、实验内容 1、预习操作系统进程同步的概念及实现方法。 2、编写一段源程序，用系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。程序的输出是什么？分析原因。 3、阅读模拟火车站售票系统和实现进程的管道通信源代码，查阅有关进程创建、进程互斥、进程同步的系统功能调用或API，简要解释例程中用到的系统功能或API的用法，并编辑、编译、运行程序，记录程序的运行结果，尝试给出合理的解释。 4、（选做）修改问题2的代码，使得父子按顺序显示字符“a”；“b”、“c”编辑、编译、运行。记录程序运行结果。 三、设计思想 1、程序框架 （1）创建两个子进程：（2）售票系统：
（3）管道通信： 先创建子进程，然后对内容加锁，将输出语句存入缓存，并让子进程自己进入睡眠，等待别的进程将其唤醒，最后解锁；第二个子进程也执行这样的过程。父进程等待子进程后读内容并输出。 （4）修改程序（1）：在子进程的输出语句前加上sleep()语句，即等待父进程执行完以后再输出。 2、用到的文件系统调用函数 （1）创建两个子进程：fork() （2）售票系统：DWORD WINAPI Fun1Proc(LPVOID lpPartameter); CreateThread(NULL,0,Fun1Proc,NULL,0,NULL); CloseHandle(hThread1); (HANDLE)CreateMutex(NULL,FALSE,NULL); Sleep(4000)（sleep调用进程进入睡眠状态(封锁), 直到被唤醒）; WaitForSingleObject(hMutex,INFINITE); ReleaseMutex(hMutex); （3）管道通信：pipe(fd)，fd: int fd[2]，其中: fd[0] 、fd[1]文件描述符（读、写）; lockf( fd，function，byte)（fd: 文件描述符；function: 1: 锁定 0:解锁；byte: 锁定的字节数，0: 从当前位置到文件尾）; write(fd，buf，byte)、read(fd，buf，byte) （fd: 文件描述符；buf : 信息传送的源（目标）地址；byte: 传送的字节数）; sleep(5); exit(0); read(fd[0]，s，50) （4）修改程序（1）：fork(); sleep(); 四、调试过程 1、测试数据设计 （1）创建两个子进程：
操作系统进程创建及通信实验报告
武汉工程大学计算机科学与工程学院 《操作系统》实验报告[Ⅰ]
一、实验目的 创建进程，实现进程消息通信和共享内存通信，了解进程的创建、退出和获取进程信。了解什么是映像文件、管道通信及其作用，掌握通过内存映像文件和管道技术实现进程通信。 二、实验内容 本例用三种方法实现进程通信，仅用于示例目的，没有进行功能优化。 1、创建进程A和B后，在进程A中输入一些字符，点“利用 SendMessage发送消息”按钮可将消息发到进程B。 2、在进程A中输入一些字符，点“写数据到内存映像文件”按钮， 然后在进程B中点“从内存映像文件读数据”按钮可收到消息。其中在点“写数据到内存映像文件”时，要求创建映像文件，B进程在印象文件中读取数据。 3、先在进程B中点“创建管道并接收数据”按钮，然后在进程A 中输入一些字符，点“写数据到管道文件”按钮可将消息发到进程B。管道是连接读/写进程使他们进行通信的一个共享文件，目的是更好地实现进程间的通信。 三、实验思想 这次试验最主要的内容和核心思想就是学会创建进程并实现进程间的简单通信、创建映像文件和创建管道文件来通信，后两者是实现进程通信的高级通信机制中的两种。. 创建一个程序A和程序B，其中程序A和B各有一个主窗体，A主窗体上要求可以实现创建进程B（即调用函数B）、结束进程B、关闭进程A、向进程B发送数据、创建映像文件、创建管道文件等功能，进程B要求有从映像文件读取数据、创建管道并接收数据、结束进程B功能。最终让A、B进程相互通信。
四、设计分析： 首先设得设计A、B两个程序的操作界面，然后编写各个功能模块。对于A 程序窗体，在“利用SendMessage发送消息”按钮的消息响应函数中，主要是利用Windows API函数CWnd::FindWindow来找到接收消息的窗体，即进程B，找到进程B后，利用这个函数返回的窗体指针的SendMessage函数来发送消息。在“写数据到内存印象文件”按钮的消息响应函数中，主要是利用函数CreateFileMapping来创建一个印象文件，这个函数返回的是这个印象文件的句柄，然后将这个句柄和要发送的消息字符串传递到函数sprintf中，就可以所要发送的消息写入印象文件，在B程序窗体中有个“从内存印象文件读数据”按钮，在这个按钮的消息响应函数中读取父进程所创建的印象文件中的数据就可以实现通信了。在B程序窗体按钮“写数据到管道文件”的消息响应函数中，不能直接将要发送的消息发送到管道文件，因为管道必须先由子进程通过函数CreateNamedPipe创建，只有待子进程创建好管道后父进程才能根据管道创建管道文件，将消息写入管道文件并及时发送给子进程。而且这个管道只能使用一次，即每次发送完消息后那个管道不能在使用了，必须再由子进程创建一个管道，A 进程才能再次创建管道文件并向其中写入消息。这个程序也不一定要MFC实现，还可以用其他的技术和语言实现，比如说Java、VB等，外表构架可以不一样，但核心技术都是一样的，只是不同的调用形式和调用方法，比如说在VB中，实现进程间的一般通信就是使用动态数据交换ＤＤＥ，实现起来就比较简单，但是要创建映像文件和管道文件就比较繁琐，可以根据不同的需求采用不同的语言。 五、程序部分源代码： 1.“利用SendMessage发送消息”按钮中的主要代码 //找到接收消息的窗口(窗口名为Receiver) CString str="进程B"; CWnd *pWnd=CWnd::FindWindow(NULL,str); if(pWnd) { COPYDATASTRUCT buf; char * s=new char[m_Msg1.GetLength()]; //m_Msg1为CString类型的变量 s=m_Msg1.GetBuffer(0);
操作系统实验二(进程管理)
操作系统进程管理实验 实验题目： （1）进程的创建编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。 （2）进程的控制修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因。 （3）编制一段程序，使其实现进程的软中断通信。要求：使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按Del键）；当捕捉到中断信号后，父进程调用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止：Parent process is killed! 在上面的程序中增加语句signal(SIGINT, SIG_IGN)和signal(SIGQUIT, SIG_IGN)，观察执行结果，并分析原因。 （4）进程的管道通信编制一段程序，实现进程的管道通信。使用系统调用pipe( )建立一条管道线；两个进程P1和P2分别向管道各写一句话：Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。 实验源程序及报告： （1）、进程的创建 #include
进程控制与进程间通信操作系统实验报告
工程大学实验报告 专业班级：姓名：学号： 课程名称：操作系统 实验成绩：指导教师：蔡敦波 实验名称：进程控制与进程间通信 一、实验目的： 1、掌握进程的概念，明确进程和程序的区别。 2、认识和了解并发执行的实质。 3、了解什么是信号。 4、熟悉LINUX系统中进程之间软中断通信的基本原理。 二、实验内容： 1、进程的创建（必做题） 编写一段程序，使用系统调用fork( )创建两个子进程，在系统中有一个父进程和两个子进程活动。让每个进程在屏幕上显示一个字符；父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 <参考程序>
运行的结果是bca. 首先创建进程p1,向子进程返回0,输出b.又创建进程p2,向子进程返回0，输出c,同时向父进程返回子进程的pid，输出a 2、修改已编写的程序，将每个进程的输出由单个字符改为一句话，再观察程序执行时屏幕上出现的现象，并分析其原因。（必做题） <参考程序> # include
运行的结果是如上图所示. 首先创建进程p1,向子进程返回0,并for语句循环输出child +i字符串.又创建进程p2,向子进程返回0，输出字符串son+i,同时向父进程返回子进程的pid，输出字符串duaghter +i ,各打印5次。
Linux 进程管理实验
Linux 进程管理实验 一、实验内容： 1. 利用bochs观测linux0.11下的PCB进程控制结构。 2. 利用bochs观测linux0.11下的fork.c源代码文件，简单分析其中的重要函数。 3. 在fork.c适当位置添加代码，以验证fork函数的工作原理。 二、Linux进程管理机制分析 Linux有两类进程：一类是普通用户进程，一类是系统进程，它既可以在用户空间运行，又可以通过系统调用进入内核空间，并在内核空间运行；另一类叫做内核进程，这种进程只能在内核空间运行。在以i386为平台的Linux系统中，进程由进程控制块，系统堆栈，用户堆栈，程序代码及数据段组成。Linux系统中的每一个用户进程有两个堆栈：一个叫做用户堆栈，它是进程运行在用户空间时使用的堆栈；另一个叫做系统堆栈，它是用户进程运行在系统空间时使用的堆栈。 1.Linux进程的状态： Linux进程用进程控制块的state域记录了进程的当前状态，一个Linux 进程在它的生存期中，可以有下面6种状态。 1.就绪状态(TASK_RUNNING)：在此状态下，进程已挂入就绪队列，进入准备运行状态。 2.运行状态(TASK_RUNNING)：当进程正在运行时，它的state域中的值不改变。但是Linux会用一个专门指针(current)指向当前运行的
任务。 3.可中断等待状态(TASK_INTERRUPTIBLE)：进程由于未获得它所申请的资源而处在等待状态。不管是资源有效或者中断唤醒信号都能使等待的进程脱离等待而进入就绪状态。即”浅睡眠状态”。 4.不可中断等待状态(TASK_UNINTERRUPTIBLE)：这个等待状态与上面等待状态的区别在于只有当它申请的资源有效时才能被唤醒，而其它信号不能。即“深睡眠状态”。 5.停止状态（TASK_STOPPED)：当进程收到一个SIGSTOP信号后就由运行状态进入停止状态，当收到一个SINCONT信号时，又会恢复运行状态。挂起状态。 6.终止状态（TASK_ZOMBIE)：进程因某种原因终止运行，但进程控制块尚未注销。即“僵死状态”。 状态图如下所示： 2.Linux进程控制块：
实验报告三进程管理及进程通信
实验三进程管理及进程通信 实验环境： Linux操作系统 实验目的： （1）利用Linux提供的系统调用设计程序，加深对进程概念的理解。 （2）体会系统进程调度的方法和效果。 （3）了解进程之间的通信方式以及各种通信方式的使用。 实验方法： 用vi 编写c 程序（假定程序文件名为prog1.c）编 译程序 $ gcc -o prog1.o prog1.c 或 $ cc -o prog1.o prog1.c 运行 $./prog1.o 实验内容及步骤： 实验1 编写程序。显示进程的有关标识（进程标识、组标识、用户标识等）。经过5 秒钟后，执行另一个程序，最后按用户指示（如：Y/N）结束操作。 编程截图：
运行结果： 实验2 参考例程1，编写程序。实现父进程创建一个子进程。体会子进程与父进程分 别获得不同返回值，进而执行不同的程序段的方法。 例程1：利用fork()创建子进程 /* 用fork()系统调用创建子进程的例子*/ main() { int i; if (fork()) /*父进程执行的程序段*/ i=wait(); /* 等待子进程结束*/{ printf("It is parent process.\n"); printf("The child process,ID number %d, is finished.\n",i); } else{
Printf(“It is child process.\n”); Sleep(10); Exit(); } } 运行结果： 思考： 子进程是如何产生的？又是如何结束的？子进程被创建后它的运行环境是怎样建立的？ 答：是由父进程用fock()函数创建形成的，通过exit()函数自我结束，子进程被创建后核心 将其分配一个进程表项和进程标识符，检查同时运行的进程数目，并且拷贝进程表项的数据，由子进程继承父进程所有文件。 实验3 参考例程2，编写程序。父进程通过循环语句创建若干子进程。探讨进程的家族树 以及子进程继承父进程的资源的关系。 例程2：循环调用fork()创建多个子进程。 /*建立进程树*/ #include