Linux 操作系统设计实践报告二

《Linux 操作系统设计实践》实验二：进程通信

实验目的：

进一步了解和熟悉Linux支持的多种IPC机制，包括信号，管道，消息队列，信号量，共享内存。

实验环境：Red Hat Enterprise Linux 5

实验内容：

（1）进程间命名管道通信机制的使用

使用命名管道机制编写程序实现两个进程间的发送接收信息。可参见参考教材例6-12.

===================================================

/* ex12 server.c */

#include

#include

#include

#include

#include

#define FIFO_FILE "MYFIFO"

int main()

{

FILE *fp;

char readbuf[80];

if((fp=fopen(FIFO_FILE,"r"))==NULL)

{

umask(0);

mknod(FIFO_FILE,S_IFIFO|0666,0);

}

else

fclose(fp);

while(1)

{

if((fp=fopen(FIFO_FILE,"r"))==NULL)

{

printf("open fifo failed. \n");

exit(1);

}

if(fgets(readbuf,80,fp)!=NULL)

{

printf("Received string :%s \n", readbuf);

fclose(fp);

}

else

{

if(ferror(fp))

{

printf("read fifo failed.\n");

exit(1);

}

}

}

return 0;

}

============================================== /* ex12 client.c */

#include

#include

#define FIFO_FILE "MYFIFO"

int main(int argc, char *argv[])

{

FILE *fp;

int i;

if(argc<=1)

{

printf("usage: %s \n",argv[0]);

exit(1);

}

if((fp=fopen(FIFO_FILE,"w"))==NULL)

{

printf("open fifo failed. \n");

exit(1);

}

for(i=1;i

{

if(fputs(argv[i],fp)==EOF)

{

printf("write fifo error. \n");

exit(1);

}

if(fputs(" ",fp)==EOF)

{

printf("write fifo error. \n");

exit(1);

}

}

fclose(fp);

return 0;

}

显示结果：

首先在一个终端窗口中运行server程序，运行成功后，程序就停留在等待接收状态，然后新建一个终端窗口，运行client程序:（我在此窗口输入You are right!）

这时在server 窗口中会显示：Received string:You are right!

结果分析：

该结果表明server程序没有出错，基本上一直运行下去，等待接受客户进程的输入。它首先创建一个命名管道MYFIFO，然后不停重复下面的操作：打开，接受一行信息，输出在屏幕上，关闭。client程序只运行一段时间就停止了，它打开命名管道，向其中写入一行信息，关闭命名管道，退出运行状态。

在文件中有这样一条解释：

#define S_IFIFO 0010000 type = named pipe

S_IFIFO 值就是为了使MODE 第5位置1，表示的类型是命名管道后面跟着的0666表示设置的权限不能漏，因为权限由10个位标记。

函数分析：umask该命令用来设置限制新文件权限的掩码。当新文件被创建时，其最初的权限由文件创建掩码决定。用户每次注册进入系统时，umask命令都被执行，并自动设置掩码改变默认值，新的权限将会把旧的覆盖

Mknod用来创建特殊文件，只能由root用户或系统组成员运行，创建FIFO(已命名管道)。

==============================================

（2）进程间消息队列通信机制的使用

使用消息队列机制自行编制有一定长度的消息（1k左右）的发送和接收程序。

参考程序段：

#include

#include

#include

#include

#include//增加计算时间的程序代码；

#include

#include

#define key 1

#define buffersize 1024

int main()

{

struct SMSG

{

long mtype;

char mtext[buffersize];

}msg ;

int pid;

int p;

struct timeval tpstart,tpend;

float timeuse;

gettimeofday(&tpstart,NULL);

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

if(p==0)

{

sleep(5);

pid=msgget(key,IPC_CREA T|0600);

msgrcv(pid,&msg,buffersize,1,0);

printf("receive msg is:%s\n",msg.mtext);

msgctl(pid,IPC_RMID,0);

}

else

{

pid=msgget(key,IPC_CREA T|0600);

msg.mtype=1;

strcpy(msg.mtext,"This is the message which the parent have sent!");

while((msgsnd(pid,&msg,buffersize,0))==-1);

gettimeofday(&tpend,NULL);

timeuse=1000000*https://www.360docs.net/doc/1718314779.html,_https://www.360docs.net/doc/1718314779.html,_sec)+https://www.360docs.net/doc/1718314779.html,_https://www.360docs.net/doc/1718314779.html,_usec;

timeuse/=1000000;

printf(“Used Time:%f\n”,timeuse);

}

return 0;

}

显示结果：

Used Time:0.000067

receive msg is: This is the message which the parent have sent!

Used Time:0.000087

receive msg is: This is the message which the parent have sent!

Used Time:0.000075

receive msg is: This is the message which the parent have sent!

Used Time:0.000071

receive msg is: This is the message which the parent have sent!

平均耗时在0.000075

结果分析：

首先程序创建一个子进程，并暂停它5秒，然后两个进程申请共享一个地址为addr的内存空间，父进程往里面写入字符串，子进程读出这个字符串，然后两个进程都同时禁止使用这块共享内存。

相比于（2）程序来说，共享内存速度应该更快，比消息队列机制少了一步发送消息的步骤，父子进程都是直接操作同一块内存

1、消息队列创建函数分析

int msgget(key_t key,int flag)

key: key_t ftok(const char *pathname,int proj_id)

pathname:必须是存在而且可读取的文件，proj_id :表示序号，用来区别同时存在的文件

成功返回pathname 对应的键值，也就是key,错误返回－1

flag: IPC_CREAT、IPC_EXCL、IPC_NOW AIT

IPC_CREAT用于创建原来不存在的的队列，IPC_CREAT|0777,设置权限位

IPC_EXCL用于测试文件是否存在，若文件已存在则返回EEXIST，（IPC_EXCL与IPC_CREAT联合使用作为一个原子操作）

IPC_NOW AIT:不阻塞

若成功则返回消息队列的ID，若出错则返回－1

2、消息发送函数分析

int msgsnd(int msgid，struct msgbuf *msgp,size_t msgsz,int msgflg)

msgid:已打开的消息队列ID

msgp:存储要发送的消息结构体的地址

msgsz:消息数据长度

msgflag:IPC_NOWAIT：若消息没有立即被发送则调用进程会立即返回

0：msgsnd调用阻塞直到条件满足为止

若成功则返回0，若失败则返回－1

3、消息接受函数分析

nt msgrcv(int msgid,struct msgbuf *msgp,size_t msgsz,long msgtype,int msgflag)

msgid :要接受消息队列的ID

msgp:存储要接收的消息结构体的地址

msgsz:消息数据长度

msgtyoe:消息类型，如果为0则接受第一个，如果>0则接受具有与函数msgtype相同的msgtype消息结构（与fifo 不同，可以从队列中接受自己想接受的消息）。

如果<0则接受消息队列中第一个类型值不小于msgtype绝对值且类型值又最小的消息msgflag:IPC_NOWAIT：若消息没有立即被接收则调用进程会立即返回

IPC_NOERROR：若返回的消息比msgsz长度字节多，则消息会截断到与msgsz 长度相等。且不通知消息发送进程

0：msgsnd调用阻塞直到条件满足为止

若成功则返回0，失败则返回－1

4、消息队列控制函数分析

int msgctl(int msgid,int cmd,struct msqid_ds *buf)

msgid:要接受消息队列的ID

cmd: IPC_STAT:取得队列状态

IPC_SET:设置队列属性

IPC_RMID:删除队列属性

buf:存放队列的属性结构

（3）进程间共享存储区通信机制的使用

使用共享内存机制编制一个与上述（2）功能相同的程序。并比较分析与其运行的快慢。参考程序段：

#include

#include

#include

#include

#include

#include

#include

#define buffersize 1024

#define Key 1

int main()

{

int p;

struct timeval tpstart,tpend;

float timeuse;

gettimeofday(&tpstart,NULL);

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

if(p==0)

{

int pid;

sleep(5);

pid=shmget(Key,buffersize,IPC_CREAT|0600);

char *addr;

addr=(char *)shmat(pid,NULL,0);

printf("receive msg is:%s\n",addr);

shmdt(addr);

}

else

{

int pid;

pid=shmget(Key,buffersize,IPC_CREAT|0600);

char *addr;

addr=(char *)shmat(pid,NULL,0);

strcpy(addr," This is the message which the parent have sent!");

shmdt(addr);

gettimeofday(&tpend,NULL);

timeuse=1000000*https://www.360docs.net/doc/1718314779.html,_https://www.360docs.net/doc/1718314779.html,_sec)+https://www.360docs.net/doc/1718314779.html,_https://www.360docs.net/doc/1718314779.html,_usec;

timeuse/=1000000;

printf(“Used Time:%f\n”,timeuse);

}

return 0;

}

结果显示：Used Time:0.000090

receive msg is: This is the message which the parent have sent!

Used Time:0.000077

receive msg is: This is the message which the parent have sent!

Used Time: 0.000094

receive msg is: This is the message which the parent have sent!

平均耗时在0.000087

在同样传送1K消息时，从结果看，0.000075<0.000087,此时在我的计算机上共享内存速度稍稍慢于消息队列

当我将内存机制的传送消息增加到4K后，结果显示：

Used Time:0.000084

receive msg is: This is the message which the parent have sent!

Used Time:0.000092

receive msg is: This is the message which the parent have sent!

平均耗时在0.000088 ，可见共享内存的速度应较快

结果分析：理论上来说，共享内存是最快的IPC方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。针对消息缓冲需要占用CPU进行消息复制的缺点，OS提供了一种进程间直接进行数据交换的通信方式一共享内存。以下是程序中的主要函数分析：

1、int shmget(key_t key, int size, int flag)函数分析

这个函数有点类似malloc函数，系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面第一个函数的key。数据类型key_t是在头文件sys/types.h中定义的，它是一个长整形的数据。在我们后面的章节中，还会碰到这个关键字。

当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。

void *shmat(int shmid, void *addr, int flag);

shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。

使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现

2、shmat函数分析

void *shmat(int shmid, const void *addr, int flag);

shmid：共享存储的id

addr：一般为0，表示连接到由内核选择的第一个可用地址上，否则，如果flag没有指定SHM_RND，则连接到addr所指定的地址上，如果flag为SHM_RND，则地址取整flag：如前所述，一般为0

返回值：如果成功，返回共享存储段地址，出错返回-1

3、shmdt函数分析

int shmdt(void *addr);

addr:共享存储段的地址，以前调用shmat时的返回值

shmdt将使相关shmid_ds结构中的shm_nattch计数器值减1

4、shmctl函数分析

int shmctl(int shmid,int cmd,struct shmid_ds *buf)

shmid:共享存储段的id

cmd：一些命令，有：IPC_STA T,IPC_RMID,SHM_LOCK,SHM_UNLOCK

值得注意的是，共享内存不会随着程序结束而自动消除，要么调用shmctl删除，要么自己用手敲命令去删除，否则永远留在系统中。