进程和进程间的通信

1、进程概念；

2、进程的控制：

（1）生成一个进程：fork

（2）进程的同步：wait waitpid

（3）进程的退出：exit _exit

（4）进程“脱胎换骨”：exec函数族

3、进程通信

（1）进程为什么需要通信？

（2）linux下进程如何通信

●早期的unix通信方式

无名管道；有名管道;信号

●sysem v的通信方式：共享内存、消息队列、信号量

●BSD的通信方式：socket

4、无名管道：适用于有血缘关系进程通信

小任务1：父进程通过无名管道向子进程发送字符串“Hello,you man!”,子进程接收到后显示出来，然后子进程退出，最后父进程退出。

（1）创建子进程：fork

（2）创建管道

#include

int pipe(int pipefd[2]);

参数说明（当管道创建成功后）：

pipefd[0]:读端的文件描述符；

pipefd[1]:写端的文件描述

返回值：0表示创建成功，-1表示创建失败

（3）父亲写管道

write

（4）儿子读管道

read

（5）父亲等待儿子退出

wait

参考代码：

#include

#include

#include

#include

#include

int main()

{

int pid;

int pipefd[2];

int ret;

char buf[]="Hello,young man!";

ret=pipe(pipefd);//创建管道（1）

if(ret<0)

{

perror("Failed to create pipe:");

return -1;

}

pid=fork();

//能够把（1）语句放此注释的下一样？？

if(pid<0)

{

perror("Failed to create child process:");

return -1;

}

if(pid>0)

{

close(pipefd[0]);//父进程中关闭无关的读端

write(pipefd[1],buf,strlen(buf));

wait(NULL);

printf("Parent process exit!\n");

}

else

{

char receive_buf[100];

int count;

close(pipefd[1]);//子进程中关闭无关的写端

count=read(pipefd[0],receive_buf,100);

if(count>0)

{

receive_buf[count]='\0';

printf("Child process receive a string:%s\n",receive_buf);

}

printf("Child process exit!\n");

}

return 0;

}

5、有名管道（fifo）

(1)文件系统中可见，可以通过mkfifo 命令来创建一个有名管道

eg: mkfifo -m 0666 myfifo

(2)有名管道的使用跟普通文件一样：open read write close,不用使用lseek!!!!

任务2：

进程1通过有名管道把键盘输入字符串发送给进程2,进程2收到后显

示出来，当收到字符串“exit”是退出程序！！

（1）手工建立一个有名管道myfifo

（2）打开管道；

（3）读写管道

注意：有名管道的读写跟普通文件没有什么区别！！

参考代码：

//fifoReader.c

#include

#include

#include

#include

#include

int main()

{

int fd;

char buf[128];

fd=open("/home/gec/myfifo",O_RDONL Y);

if(fd<0)

{

perror("Failed to open fifo:");

return -1;

}

while(1)

{

int count;

count=read(fd,buf,127);

if(count>0)

{

buf[count]=0;

printf("fifoReader receive a string:%s\n",buf);

}

if(strncmp(buf,"exit",4)==0)

{

break;

}

}

close(fd);

return 0;

}

//fifoWrite.c

#include

#include

#include

#include

#include

int main()

{

int fd;

char buf[128];

fd=open("/home/gec/myfifo",O_WRONL Y);

if(fd<0)

{

perror("Failed to open fifo:");

return -1;

}

while(1)

{

fgets(buf,128,stdin);

write(fd,buf,strlen(buf));

if(strncmp(buf,"exit",4)==0)

{

break;

}

}

close(fd);

return 0;

}

6、信号

（1）可以用命令kill -l列出当前系统所支持的信号

（2）对于很多信号，进程都有默认的处理方式；

（3）信号的发送

#include

#include

int kill(pid_t pid, int sig);

（4）信号的处理：当进程接收一个信号后如何与“一段代码关联起来”

模版：

//信号处理函数

void 你自己命名的信号处理函数名（int sig）//sig:信号值

｛

//对信号的处理

｝

//在程序的某一个地方把信号处理函数和信号关联起来，其“后果”就是进程一旦接收到该信号，就会导致该信号处理函数的调用！！

#include

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

在需要关联的时候只需要调用signal函数就可以了！！

信号：signum--------------------信号处理函数：handler

小任务3：

用触发信号的方式每2秒钟向屏幕打印“Hello,world!”

(1)每隔2秒钟触发一个闹钟信号SIGALRM

alarm(2);

(2)在信号处理函数里完成屏幕大打印：

void alarm_handler(int sig)

{

if(sig==SIGALRM)

{

printf(“Hello,world!\n”);\

alarm(2);

}

}

(3)在你的程序的某个地方添加如下语句

signal(SIGALRM, alarm_handler);

参考代码：

#include

#include

#include

#include

void alarm_handler(int sig)

{

if(sig==SIGALRM)

{

printf("Hello,world!\n");

alarm(2);

}

}

int main()

{

signal(SIGALRM,alarm_handler);//此语句的作用：一旦进程接收到SIGALRM信号，就会导致alarm_handler的调用

alarm(2);//此语句的作用：2秒钟后会向调用进程发送SIGALRM信号

while(1);

return 0;

}

小任务4：(练习kill的使用)

当进程2收到进程1发出的SIGUSR1信号后停止向屏幕输出“Hello,world!\n”. 进程2的执行格式可以如下：

./进程1 进程2的进程号

参考代码

//p1.c

#include

#include

#include

#include

int main(int argc,char **argv)

{

int dest_id;

int ret;

if(argc<2)

{

printf("Argument too few!\n");

return 0;

}

dest_id=atoi(argv[1]);//将参数指针型转换成整型；

//sscanf(argv[1],"%d",&dest_id);也可用这个语句实现数据类型转化；

printf("The pid of destination process id %d\n",dest_id);

ret=kill(dest_id,SIGUSR1);

if(ret<0)

printf("Failed to send signal.\n");

return 0;

}

//p2.c

#include

#include

#include

int flag=1;

void sigusr1_handler(int sig)

{

if(sig==SIGUSR1)

{

flag=0;

}

}

int main()

{

signal(SIGUSR1,sigusr1_handler);建立与信号相关联的回调函数关系；

while(flag==1)

{

printf("Hello,world!\n");

sleep(2);

}

return 0;

}

7、共享内存

8、共享内存使用的步骤

（1）创建共享内存块的一个外键

#include

#include

key_t ftok(const char *pathname, int proj_id);

注意：ｐａｔｈｎａｍｅ必须是系统中真实存在的而且稳定的路径，一般ｐｒｏｊ＿ｉｄ用一个ａｓｃｉｉ字符来代替

（２）获取或者创建共享内存块

#include

#include

int shmget(key_t key, size_t size, int shmflg);

注意：

第一个参数一般为在步骤1所创建或获取的外键，如果你的共享内存块是一个私有共享内存块，可以选择为IPC_PRIV ATE;

第二个参数为所创建或获取的共享内存块的大小（以字节为单位）；

第三个参数所为所创建或获取共享内存块的权限：

IPC_CREAT: 当用key所对应共享内存不存在时则创建它；

IPC_EXCL：当空享内存块存在则创建失败；

0666:共享内块的权限；

该函数的返回值，当创建成功是为共享内存块的内部标识！

（3）共享内存块的映射

#include

#include

void *shmat(int shmid, const void *shmaddr, int shmflg);

把shmid所标识的共享内存块映射调用进程的地址空间，第2、3参数一般为0；当映射成功是返回共享内存块在用户空间地址，失败则为-1；

（3）撤销共享内存块的映射

#include

#include

int shmdt(const void *shmaddr);

当进程不需要对共享内存块进行读写的时候调用该函数！！

（4）删除共享内存块

#include

#include

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

一般的调用格式：

shmctl(shmid,IPC_RMID,NULL);

小任务：

进程1把从键盘获取的字符串通过共享内存发送给进程2，进程接手后显示出来，当接收到”exit”时退出。需要通过信号处理进程1、2的同步关系：当进程往共享内写字符串后给进程2发送信号。

提示：

共享内块的数据定义：

struct shm_struct

{

int writerProcessId;

int readerProcessId;

char buf[512];

};

参考代码：

//shmWriter.c

#include

#include

#include

#include

#include

#include

//定义结构体以格式化共享内存块,并声明了该结构体类型指针变量pShm

struct shm_struct

{

int writerProcessId;

int readerProcessId;

char buf[512];

}*pShm;

int main()

{

int shmid;

key_t key=ftok("/home",'a');//获取共享内存块外键

printf("Key=%d\n",key);

shmid=shmget(key,sizeof(struct shm_struct),IPC_CREA T|0666);//获取共享内存块标示符

if(shmid<0)

{

perror("Failed to create share memory!\n");

return -1;

}

printf("shmid=%d\n",shmid);

pShm=(struct shm_struct*)shmat(shmid,0,0);//映射共享内存块

bzero(pShm,sizeof(struct shm_struct)); //把共享内存块清0

pShm->writerProcessId=getpid();//初始化内存块的写者pid

while(1)

{

fgets(pShm->buf,512,stdin);//从键盘获取字符串

if(pShm->readerProcessId!=0)

{

kill(pShm->readerProcessId,SIGUSR1);//给读者发信号表示已经写了一个新的字符串到共享内存块

}

}

return 0;

}

//shmReader.c

#include

#include

#include

#include

#include

#include

struct shm_struct

{

int writerProcessId;

int readerProcessId;

char buf[512];

}*pShm;

int flag=0;

void can_read_shm(int sig)

{

flag=1;

}

int main()

{

int shmid;

key_t key=ftok("/home",'a');

printf("Key=%d\n",key);

shmid=shmget(key,sizeof(struct shm_struct),IPC_CREAT|0666);

if(shmid<0)

{

perror("Failed to create share memory!\n");

return -1;

}

printf("shmid=%d\n",shmid);

pShm=(struct shm_struct*)shmat(shmid,0,0);

pShm->readerProcessId=getpid();

signal(SIGUSR1,can_read_shm);

while(1)

{

if(flag==1)

{

flag=0;

printf("%s",pShm->buf);

if(strncmp(pShm->buf,"exit",4)==0)

break;

}

}

pShm->readerProcessId=0;

return 0;

}

9.消息队列

相关函数：msgget msgsnd msgrcv msgctl

注意：

（1）消息缓冲区的最大长度（含消息类型）的最大长度不要超过4096字节；（2）msgsnd msgrcv的正文长度参数是以字节为单位的；

（3）定义消息结构体时，消息类型一定最开始的成员：

错误的定义：

struct message_buf

{

char buf[512];

long msgType;

};

正确的定义：

struct message_buf

{

long msgType;

char buf[512];

};

小任务：

基于消息队列的通信方式实现一个服务器/客户端模式的计算系统：

（1）服务端从消息队列读取需要计算的两个整数，求和后把结果同通过消息队列返回客户端；

（2）客户端从键盘读取两个整数，通过消息队列发送服务器，接收到计算结果后显示出来

（3）要求服务端能同时处理多个客户端的请求

分析：

服务器端：

（1）初始化；

（2）从消息队列获取消息；

（3）求和计算；

（4）给客户端发送和消息

（5）转（2）

客户端：

（1）初始化；

（2）从键盘获取两个整数；

（3）通过消息队列发送两个整数给服务器；

（4）接收服务器端和消息；

（5）转（2）

参考代码：

//msgServer.c

#include

#include

#include

#include

#include

#include "comm.h"（此头文件包含结构体struct c2s_Message 、struct s2s_message）

int main()

{

int msgid;

int sum;

struct c2s_message c2sMessage;

struct s2c_message s2cMessage;

key_t key=ftok("/usr/lib",'a');创建外键

msgid=msgget(key,IPC_CREAT|0666);建立消息队列

s2cMessage.msgType=2;消息类型为2

while(1)

{

msgrcv(msgid,(void*)&c2sMessage,sizeof(struct c2s_message)-sizeof(long),1,0);

sum=c2sMessage.x+c2sMessage.y;

s2cMessage.sum=sum;

msgsnd(msgid,(void*)&s2cMessage,sizeof(struct s2c_message)-sizeof(long),0);

}

return 0;

}

//msgClient.c

#include

#include

#include

#include

#include

#include "comm.h"

int main()

{

int msgid;

struct c2s_message c2sMessage;

struct s2c_message s2cMessage;

key_t key=ftok("/usr/lib",'a');

msgid=msgget(key,IPC_CREAT|0666);

c2sMessage.msgType=1;

while(1)

{

scanf("%d%d",&c2sMessage.x,&c2sMessage.y);

msgsnd(msgid,(void*)&c2sMessage,sizeof(struct c2s_message)-sizeof(long),0);发送消息

msgrcv(msgid,(void*)&s2cMessage,sizeof(struct s2c_message)-sizeof(long),2,0);接收消息

printf("sum=%d\n",s2cMessage.sum);

}

return 0;

}