进程通信之(一,二) 信号机制实验

摘自：http://blog.csdn.net/iamyina/archive/2008/05/13/2441089.aspx

 

UNIX/LINUX 系统的进程间通信机构（ IPC ）允许在任意进程间大批量地交换数据。本实验的目的是了解和熟悉 LINUX 支持的信号量机制、管道机制、消息通信机制及共享存储区机制。

( 一 ) 信号机制实验  

实验目的

1 、了解什么是信号

2 、熟悉 LINUX 系统中进程之间软中断通信的基本原理

实验内容

1 、编写程序：用 fork( ) 创建两个子进程，再用系统调用 signal( ) 让父进程捕捉键盘上来的中断信号（即按 ^c 键）；捕捉到中断信号后，父进程用系统调用 kill( ) 向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：

Child process1 is killed by parent!

Child process2 is killed by parent!

父进程等待两个子进程终止后，输出如下的信息后终止：

Parent process is killed!

2 、分析利用软中断通信实现进程同步的机理

实验指导

一、信号

1 、信号的基本概念

每个信号都对应一个正整数常量 ( 称为 signal number, 即信号编号。定义在系统头文件 <signal.h> 中 ) ， 代表同一用户的诸进程之间传送事先约定的信息的类型，用于通知某进程发生了某异常事件。每个进程在运行时，都要通过信号机制来检查是否有信号到达。若有， 便中断正在执行的程序，转向与该信号相对应的处理程序，以完成对该事件的处理；处理结束后再返回到原来的断点继续执行。实质上，信号机制是对中断机制的一 种模拟，故在早期的 UNIX 版本中又把它称为软中断。

信号与中断的相似点：

（ 1 ）采用了相同的异步通信方式；

（ 2 ）当检测出有信号或中断请求时，都暂停正在执行的程序而转去执行相应的处理程序；

（ 3 ）都在处理完毕后返回到原来的断点；

（ 4 ）对信号或中断都可进行屏蔽。

信号与中断的区别：

（ 1 ）中断有优先级，而信号没有优先级，所有的信号都是平等的；

（ 2 ）信号处理程序是在用户态下运行的，而中断处理程序是在核心态下运行；

（ 3 ）中断响应是及时的，而信号响应通常都有较大的时间延迟。

信号机制具有以下三方面的功能：

（ 1 ）发送信号。发送信号的程序用系统调用 kill( ) 实现；

（ 2 ）预置对信号的处理方式。接收信号的程序用 signal( ) 来实现对处理方式的预置；

（ 3 ）收受信号的进程按事先的规定完成对相应事件的处理。

2 、信号的发送

信号的发送，是指由发送进程把信号送到指定进程的信号域的某一位上。如果目标进程正在一个可被中断的优先级上睡眠，核心便将它唤醒，发送进程就此结束。一个进程可能在其信号域中有多个位被置位，代表有多种类型的信号到达，但对于一类信号，进程却只能记住其中的某一个。

进程用 kill( ) 向一个进程或一组进程发送一个信号。

3 、对信号的处理

当一个进程要进入或退出一个低优先级睡眠状态时，或一个进程即将从核心态返回用户态时，核心都要检查该进程是否已收到软中断。当进程处于核心态时，即使收到软中断也不予理睬；只有当它返回到用户态后，才处理软中断信号。对软中断信号的处理分三种情况进行：

（ 1 ）如果进程收到的软中断是一个已决定要忽略的信号（ function=1 ），进程不做任何处理便立即返回；

（ 2 ）进程收到软中断后便退出（ function=0 ）；

（ 3 ）执行用户设置的软中断处理程序。

二、所涉及的中断调用

1 、 kill( )

系统调用格式

int kill(pid,sig)

参数定义

int pid,sig;

其中， pid 是一个或一组进程的标识符，参数 sig 是要发送的软中断信号。

（ 1 ） pid>0 时，核心将信号发送给进程 pid 。

（ 2 ） pid=0 时，核心将信号发送给与发送进程同组的所有进程。

（ 3 ） pid=-1 时，核心将信号发送给所有用户标识符真正等于发送进程的有效用户标识号的进程。

2 、 signal( )

预置对信号的处理方式，允许调用进程控制软中断信号。

系统调用格式

signal(sig,function)

头文件为

　                     #include <signal.h>

参数定义

signal(sig,function)

int sig;

void (*func) ( )

其中 sig 用于指定信号的类型， sig 为 0 则表示没有收到任何信号，余者如下表：

,

值	名   字	说           明
01	SIGHUP	挂起（ hangup ）
02	SIGINT	中断，当用户从键盘按 ^c 键或 ^break 键时
03	SIGQUIT	退出，当用户从键盘按 quit 键时
04	SIGILL	非法指令
05	SIGTRAP	跟踪陷阱（ trace trap ），启动进程，跟踪代码的执行
06	SIGIOT	IOT 指令
07	SIGEMT	EMT 指令
08	SIGFPE	浮点运算溢出
09	SIGKILL	杀死、终止进程
10	SIGBUS	总线错误
11	SIGSEGV	段违例（ segmentation violation ），进程试图去访问其虚地址空间以外的位置
12	SIGSYS	系统调用中参数错，如系统调用号非法
13	SIGPIPE	向某个非读管道中写入数据
14	SIGALRM	闹钟。当某进程希望在某时间后接收信号时发此信号
15	SIGTERM	软件终止（ software termination ）
16	SIGUSR1	用户自定义信号 1
17	SIGUSR2	用户自定义信号 2
18	SIGCLD	某个子进程死
19	SIGPWR	电源故障

   

function ：在该进程中的一个函数地址，在核心返回用户态时，它以软中断信号的序号作为参数调用该函数，对除了信号 SIGKILL ， SIGTRAP 和 SIGPWR 以外的信号，核心自动地重新设置软中断信号处理程序的值为 SIG_DFL ，一个进程不能捕获 SIGKILL 信号。

function 的解释如下：

（ 1 ） function=1 时，进程对 sig 类信号不予理睬，亦即屏蔽了该类信号；

（ 2 ） function=0 时，缺省值，进程在收到 sig 信号后应终止自己；

（ 3 ） function 为非 0 ，非 1 类整数时， function 的值即作为信号处理程序的指针。

三、参考程序

#include <stdio.h>

#include <signal.h>

#include <unistd.h>

void waiting( ),stop( );

int wait_mark;

main( )

{

int p1,p2,stdout;

while((p1=fork( ))= =-1);       /* 创建子进程 p1*/

if (p1>0)

            {

while((p2=fork( ))= =-1);     /* 创建子进程 p2*/

if(p2>0)

{

                      wait_mark=1;

signal(SIGINT,stop);   /* 接收到 ^c 信号，转 stop*/

waiting( );

kill(p1,16);        /* 向 p1 发软中断信号 16*/

kill(p2,17);        /* 向 p2 发软中断信号 17*/

wait(0);           /* 同步 */

wait(0);

printf("Parent process is killed!/n");

exit(0);

}

            else

             {

                      wait_mark=1;

signal(17,stop);   /* 接收到软中断信号 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);        /* 接收到软中断信号 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;

}

四、运行结果

屏幕上无反应，按下 ^C 后，显示  Parent process is killed!

五、分析原因

上述程序中， signal( ) 都放在一段程序的前面部位，而不是在其他接收信号处。这是因为 signal( ) 的执行只是为进程指定信号值 16 或 17 的作用，以及分配相应的与 stop( ) 过程链接的指针。因而， signal( ) 函数必须在程序前面部分执行。

本方法通信效率低，当通信数据量较大时一般不用此法。

六、思考

1 、该程序段前面部分用了两个 wait(0) ，它们起什么作用？

2 、该程序段中每个进程退出时都用了语句 exit(0) ，为什么？

3 、为何预期的结果并未显示出？

4 、程序该如何修改才能得到正确结果？

5 、不修改程序如何得到期望的输出？

 

 

 

 

（二）进程的管道通信实验

实验目的

1 、了解什么是管道

2 、熟悉 UNIX/LINUX 支持的管道通信方式

实验内容

编写程序实现进程的管道通信。用系统调用 pipe( ) 建立一管道，二个子进程 P1 和 P2 分别向管道各写一句话：

    Child 1 is sending a message!

    Child 2 is sending a message!

父进程从管道中读出二个来自子进程的信息并显示（要求先接收 P1 ，后 P2 ）。

实验指导

一、什么是管道

UNIX 系统在 OS 的发展上，最重要的贡献之一便是该系统首创了管道（ pipe ）。这也是 UNIX 系统的一大特色。

所谓管道，是指能够连接一个写进程和一个读进程的、并允许它们以生产者 — 消费者方式进行通信的一个共享文件，又称为 pipe 文件。由写进程从管道的写入端（句柄 1 ）将数据写入管道，而读进程则从管道的读出端（句柄 0 ）读出数据。

句柄 fd[0]   句柄 fd[1]

读出端   写入端

二、管道的类型：

1 、有名管道

一个可以在文件系统中长期存在的、具有路径名的文件。用系统调用 mknod( ) 建立。它克服无名管道使用上的局限性，可让更多的进程也能利用管道进行通信。因而其它进程可以知道它的存在，并能利用路径名来访问该文件。对有名管道的访问方式与访问其他文件一样，需先用 open( ) 打开。

2 、无名管道

一个临时文件。利用 pipe( ) 建立起来的无名文件（无路径名）。只用该系统调用所返回的文件描述符来标识该文件，故只有调用 pipe( ) 的进程及其子孙进程才能识别此文件描述符，才能利用该文件（管道）进行通信。当这些进程不再使用此管道时，核心收回其索引结点。

二种管道的读写方式是相同的，本文只讲无名管道。

3 、 pipe 文件的建立

分配磁盘和内存索引结点、为读进程分配文件表项、为写进程分配文件表项、分配用户文件描述符

4 、读 / 写进程互斥

内核为地址设置一个读指针和一个写指针，按先进先出顺序读、写。

为使读、写进程互斥地访问 pipe 文件，需使各进程互斥地访问 pipe 文件索引结点中的直接地址项。因此，每次进程在访问 pipe 文件前，都需检查该索引文件是否已被上锁。若是，进程便睡眠等待，否则，将其上, 锁，进行读 / 写。操作结束后解锁，并唤醒因该索引结点上锁而睡眠的进程。

三、所涉及的系统调用    

1 、 pipe( )

建立一无名管道。

系统调用格式

              pipe(filedes)

参数定义

int pipe(filedes);

int  filedes[2];

其中， filedes[1] 是写入端， filedes[0] 是读出端。

该函数使用头文件如下：

#include <unistd.h>

#inlcude <signal.h>

#include <stdio.h>

   2 、 read( )

  系统调用格式

                  read(fd,buf,nbyte)

  功能：从 fd 所指示的文件中读出 nbyte 个字节的数据，并将它们送至由指针 buf 所指示的缓冲区中。如该文件被加锁，等待，直到锁打开为止。

  参数定义

                   int read(fd,buf,nbyte);

                  int fd;

                  char *buf;

                  unsigned nbyte;

 3 、 write( )

系统调用格式

                  read(fd,buf,nbyte)

功能：把 nbyte 个字节的数据，从 buf 所指向的缓冲区写到由 fd 所指向的文件中。如文件加锁，暂停写入，直至开锁。

参数定义同 read( ) 。

四、参考程序

#include <unistd.h>

#include <signal.h>

#include <stdio.h>

int pid1,pid2;

main( )

    {

int fd[2];

char outpipe[100],inpipe[100];

pipe(fd);                       /* 创建一个管道 */

while ((pid1=fork( ))= =-1);

if(pid1= =0)

 {

lockf(fd[1],1,0);

    sprintf(outpipe,"child 1 process is sending message!");

/* 把串放入数组 outpipe 中 */

    write(fd[1],outpipe,50);     /* 向管道写长为 50 字节的串 */

    sleep(5);                 /* 自我阻塞 5 秒 */

    lockf(fd[1],0,0);

    exit(0);

            }

else

           {

while((pid2=fork( ))= =-1);

    if(pid2= =0)

{    lockf(fd[1],1,0);           /* 互斥 */

   sprintf(outpipe,"child 2 process is sending message!");

                  write(fd[1],outpipe,50);

                  sleep(5);

           lockf(fd[1],0,0);

                  exit(0);

             }

                else

                 {  wait(0);              /* 同步 */

         read(fd[0],inpipe,50);   /* 从管道中读长为 50 字节的串 */

                    printf("%s/n",inpipe);

         wait(0);

         read(fd[0],inpipe,50);

         printf("%s/n",inpipe);

                    exit(0);

                }

         }

}

五、运行结果

   延迟 5 秒后显示

child 1 process is sending message!

       再延迟 5 秒

                child 2 process is sending message!

六、思考题

1 、程序中的 sleep(5) 起什么作用？

2 、子进程 1 和 2 为什么也能对管道进行操作？