Linux系统IPC进程间通信

IPC

进程间通信(两个/多个进程数据交互);

了解:信号应用中的计时器;

用指定的初始间隔和重复间隔时间为进程设定号一个计时器后,该计时器就会定时的向进程发送时钟信号;

Linux为每个进程维护3个计时器,分别是

真实计时器SIGALRM

计算程序运行的实际时间;

虚拟计时器SIGVTALRM

计算程序在用户态时所消耗的时间;

实用计时器SIGPROF

计算程序处于用户态和内核态所消耗的时间;

获取计时器的设置

int getitimer(int which, struct itimerval *value);

设置计时器:

int setitimer(int which, const struct itimerval *new_value,

struct itimerval *old_value);

struct itimerval {

struct timeval it_interval; //next value

struct timeval it_value; //current value

};

struct timeval {

long tv_sec; //seconds

long tv_usec; //microseconds

};

/*
* setitimer()定时器
*/
#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
void fa(int signo) {
printf("I am a superman!\n");
}
int main() {
signal(SIGALRM, fa);
/* 设置计时器 */
struct itimerval timer;
/* 开始时间 */
timer.it_value.tv_sec = 3;    //开始秒数
timer.it_value.tv_usec = 0;    //开始微秒数;
/* 间隔时间 */
timer.it_interval.tv_sec = 1;    //间隔的秒数;
timer.it_interval.tv_usec = 0;    //间隔的微秒数
setitimer(ITIMER_REAL, &timer, NULL);
while (1);
return 0;
}

/*
* setitimer()定时器
*/
#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
void fa(int signo) {
printf("I am a superman %d !\n", signo);
}
int main() {
signal(SIGPROF, fa);
/* 设置计时器 */
struct itimerval timer, otv;
timer.it_value.tv_sec = 3;    //开始秒数
timer.it_value.tv_usec = 0;    //开始微秒数;
timer.it_interval.tv_sec = 1;    //间隔的秒数;
timer.it_interval.tv_usec = 0;    //间隔的微秒数
setitimer(ITIMER_PROF, &timer, &otv); //似乎没有捕获到
//不确定这样的使用方式是否正确,待解
while (1) {
printf("hello\n");
sleep(1);
/* kill(getpid(), SIGPROF); */
}
return 0;
}

IPC进程间通信Inter Process Communication

进程间的通信方式

1-> 文件;

2-> 信号;

3-> 管道;

4-> 共享内存;

5-> 消息队列;

6-> 信号量集(semaphore);

7-> 网络(套接字socket);

...

其中,共享内存,消息队列和信号量集遵守相同的规范,叫XSI IPC;最重要的是消息队列;

IPC的应用基本上遵循一个固定的套路,在编程时只需要按照固定的步骤调用相应的函数即可;

消息队列,信号量和共享内存统称为XSI IPC;

管道

管道是Unix最古老的IPC方式之一,目前较少使用;

历史上它是半双工的(数据只能在一个方向流动),现在很多系统都提供全双工管道;

管道分为有名管道和无名管道;

有名管道可以用于各种进程的IPC; mkfifio()函数用于创建有名管道文件;

进程A 进程B 动作

建立管道文件 mkfifo

打开管道 打开管道 open

读写数据 读写数据 read/write

关闭管道 关闭管道 close

删除管道 unlink

无名管道只能用于fork()创建的父子进程之间的IPC;

管道(pipe)的交互媒介是一种特殊的文件即管道文件;管道文件的创建必须用mkfifo命令或mkfifo()函数,touch不能创建管道文件;管道文件的后缀是.pipe;

管道文件只做交互的媒介,不存储数据;因此只有在输入输出都存在时,才畅通,否则就卡住;

练习新建一个管道文件,用echo命令和cat命令测试以下;

mkfifo test.pipe

echo "hello" > test.pipe

会卡在这里等待下一步操作

再开启一个终端,然后

cat test.pipe

编写两个程序,一个发送整数0-99,另外一个接收,采用管道的方式;

思路

新建一个管道文件,然后发送的进程写文件,接收的进程读文件即可;

/*
* 管道练习a发送
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int main() {
int res = mkfifo("test.pipe", 0666);
if (res == -1) {
perror("mkfifo"); exit(-1);
}
/* open()的O_CRET是建立不了管道文件的,只能使用mkfifo */
/* open()函数只能创建普通文件 */
int fd = open("test.pipe", O_WRONLY); //写
/* 对管道文件不要使用O_RDWR,
* 否则系统会认为既是读管道又是写管道,直接运行; */
if (fd == -1) {
perror("open"), exit(-1);
}
int i;
for (i = 0; i <= 99; i++) {
write(fd, &i, 4);
usleep(100000);    //0.1s
printf("发送%d ", i);
if (!(i % 10))
printf("\n");
}
printf("\n");
close(fd);
return 0;
}

/*
* 管道练习b接收
*/
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
int main() {
int fd = open("test.pipe", O_RDONLY); //读
if (fd == -1) {
perror("open"), exit(-1);
}
int i;
for (i = 0; i <= 99; i++) {
int x;
read(fd, &x, 4);
printf("接收到%d\n", x);
}
close(fd);
return 0;
}

共同的使用方法

1.创建时都需要使用key,key是一个整数,外部程序使用key来获取内核中的IPC结构(共享内存/消息队列和信号量集,也就是交互媒介);

2.key的生成方式有三种

a.宏IPC_PRIVATE直接做key,这种基本不使用;只能创建IPC结构,别的进程不能调用;

b.定义一个头文件,把所有的key写在头文件中;

c.函数ftok()可以用一个真实存在的目录和一个人工分配的项目ID(0-255有效,即低8位有效)自动生成一个key;

3.所有的IPC结构在内核中对应一个唯一的ID,标识每一个IPC结构;

4.key是用来查找ID的,ID是用来定位IPC结构的;key -> ID -> IPC结构;

//key是外部的,只有找到ID之后才可以定位IPC结构;

函数xxxget(),比如shmget(key,...)取共享内存;msgget(key,...)取消息队列;可以用key取得ID,后续的代码使用ID即可;

5.创建IPC结构时,都需要提供一个flags参数,这个参数一般是

0666 | IPC_CREAT | IPC_EXCL

权限 创建IPC 如果存在,直接返回-1代表出错;

6.每种IPC结构都需要提供一个操作函数

xxxctl(),它至少包括以下功能

a-> IPC_STAT 取IPC结构的相关属性(查看);

b-> IPC_SET 修改IPC结构的部分属性;

c-> IPC_RMID 删除IPC结构;

注意:IPC结构由内核管理,如果不删除,重启后依然存在;用完记得删除;

关于IPC相关命令

ipcs 查看IPC结构;

ipcs -a 查看所有;

ipcs -m 共享内存;

ipcs -q 消息队列;

ipcs -s 信号量集;

ipcrm 删除IPC结构;需要指定结构的ID;

ipcrm -m ID 删除共享队列

ipcrm -q ID 删除消息队列

ipcrm -s ID 删除信号量集

共享内存

共享内存是以一块内存作为IPC交互的媒介,这块内存由内核维护和管理,允许其他进程映射;

IPC中共享内存效率高;

共享内存最大的问题就是多进程同时修改时很难控制;

编程模型

服务进程 客户进程 动作

使用约定文件创建key 使用约定文件创建key ftok()

使用key创建共享内存 使用key创建共享内存 shmget()

挂接到共享内存 挂接到共享内存 shmat()

使用内存 使用内存

卸载共享内存 卸载共享内存 shmdt()

释放共享内存 shmctl()

共享内存的使用步骤

1.创建key;

可以使用头文件定义或ftok()函数;

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

参数是真实存在的文件路径和非零的项目id;

2.用key创建/获取ID;

得到key后使用shmget(key,...)函数创建/获取共享内存ID;

#include <sys/shm.h>

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

size//共享内存的大小(字节);//获取时设为0即可;

shmflag//一般是0666|IPC_CREAT|IPC_EXCL;//获取时设为0即可;

成功返回虚拟内存首地址,失败返回-1;

3.挂接;

使用shmat(ID)函数挂接(映射)共享内存;

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

shmaddr为0时,系统自动分配地址;

后面两个参数设为0即可;

成功时返回共享的虚拟内存的首地址;

4.正常使用;

5.脱接;

使用shmdt(ID)函数脱接(解除映射)共享内存;

int shmdt(const void *shmaddr);

参数为挂接时返回的首地址;

6.删除;

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

如果确定不再使用,需要使用函数shmctl(id,IPC_RMID,NULL)删除共享内存;

/*
* IPC共享内存a
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
/* 创建共享内存,并存入数据 */
int main() {
//1创建key
key_t key = ftok(".", 100);    //路径不存在会失败;
if (key == -1) {
perror("ftok"), exit(-1);
}
//2用key创建ID
int shmid = shmget(key, 4, 0666 | IPC_CREAT | IPC_EXCL);    //
/* 新建时需要3个参数,获取时后两个参数为0即可; */
if (shmid == -1) {
perror("shmget"), exit(-1);
}
printf("共享内存创建成功\n");
//3挂接
void *p = shmat(shmid, 0, 0);    //挂接
if (p == (void *)-1) {
perror("shmat"), exit(-1);
}
//4使用
int *pi = p;
*pi = 100;
sleep(10); //使用ipcs -m 可以查看挂接数
//练习:写shmb.c把100从共享内存中读出来;
//5脱接
shmdt(p);        //脱接
//6删除
/* shmctl(shmid, IPC_RMID, 0);//删除 */
return 0;
}

/*
* IPC共享内存b
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int main() {
//1创建key
key_t key = ftok(".", 100);
if (key == -1) {
perror("ftok"), exit(-1);
}
//2用key获取ID
int shmid = shmget(key, 0, 0);
/* 获取的时候后两个参数给0就可以 */
if (shmid == -1) {
perror("shmget"), exit(-1);
}
printf("获取共享内存\n");
//3挂接
void *p = shmat(shmid, 0, 0);
if (p == (void *)-1) {
perror("shmat"), exit(-1);
}
//4使用
int *pi = p;
printf("*pi = %d\n", *pi);
//5脱接
shmdt(p);
sleep(1);
//6删除
shmctl(shmid, IPC_RMID, 0);
printf("共享内存已删除\n");
return 0;
}

消息队列

应用最广,IPC中的重点

把数据放入消息中,把消息放入队列中;队列由内核负责创建和维护;

消息队列的使用步骤

1.用ftok()或头文件定义方式生成key;

2.用key创建/获取消息队列的ID;

msgget(key, ...);

int msgget(key_t key, int msgflg);

成功返回ID,失败返回-1;

3.发送消息/接收消息;

msgsnd() //放入/发送消息;

msgrcv() //取出/接收消息;

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

msgsnd(ID, 消息首地址, 消息长度, 0/IPC_NOWAIT);

在使用有类型的消息时,第二个参数地址是整个结构的地址,第三个参数大小值是数据区的大小(不包括消息类型mtype);

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

msgrcv(ID, 接收变量首地址, 接收变量buf大小, 消息类型/*0代表接收所有类型*/, 0/IPC_NOWAIT);

4.如果确定不再使用消息队列,需要删除;

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

msgctl(msgid, IPC_RMID, struct msgid_ds *buf);

注意所有的函数名是msg而不是msq,或许是由于历史原因,应该小心;

可以用msgctl(msgid, IPC_STAT, &msqid_ds)查询消息队列的信息;

查询结果放在msqid_ds的结构体指针所对应的变量中;

/*
* 消息队列a
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int main() {
//1生成key
key_t key = ftok(".", 200);
//2创建消息队列的ID
int msgid = msgget(key, 0666 | IPC_CREAT);
/* IPC_EXCL不要,因为第二次放入时队列已经存在会失败; */
if (msgid == -1) {
perror("msgget"), exit(-1);
}
printf("消息队列创建成功\n");
//3发送消息
int res = msgsnd(msgid, "hello", 5, 0); /*IPC_NOWAIT非阻塞 */
if (res == -1) {
perror("msgsnd"), exit(-1);
}
printf("send ok !\n");
/* 练习:写msgb.c用msgrcv()把消息取出来并打印; */
return 0;
}

/*
* 消息队列b
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int main() {
//1生成key
key_t key = ftok(".", 200);
//2获取消息队列的ID
int msgid = msgget(key, 0);    //接收时最后一个参数为0
if (msgid == -1) {
perror("msgget"), exit(-1);
}
printf("消息队列获取成功\n");
//3接收消息
printf("消息队列recieving...\n");
char buf[50] = { };
ssize_t res = msgrcv(msgid, buf, sizeof(buf), 0, 0);
/* 前一个0表示接收任意类型的消息,后一个表示阻塞 */
if (res == -1) {
perror("msgrcv"), exit(-1);
}
printf("收到了%d字节,内容%s\n", res, buf);
//4删除消息队列
if (!msgctl(msgid, IPC_RMID, NULL)) {
printf("消息队列已删除\n");
}
return 0;
}

思考,如果消息被放入到消息队列中,本来是发给进程B的,但由于进程A先起来了,于是就把消息取走了,如何才能避免这种情况呢;

给每个消息贴上一个标签用于标识类型;

消息类型

消息分为有类型消息和无类型消息;

无类型消息 <==> 数据

可以使用任意类型;

比如可以是int,double,字符串,结构,联合;

这种消息严格遵守先进先出;

有类型的消息 == 消息类型 + 数据

因此必须是结构体类型;格式如下

struct 消息名/*可自定义*/ {

long mtype;//第一个成员必须是消息类型;

...//后面可以随便写,是自定义的数据;

};

msgsnd()发送有类型消息时,没有特殊要求;

msgrcv()接收有类型消息时,可以使用第4个参数选择接收消息的类型;

其中mtype必须大于0; 负数和0有特殊用途;

msgrcv()第4个参数(long msgtype)可能的值

1-> 正数 接收指定类型的消息;

2-> 0 接收任意类型的消息(先进先出);

3-> 负数 接收小于等于flags绝对值的消息,次序是先小后大;

number a b c d e f g h

msgtype 2 5 3 1 2 3 1 4

假如msgrcv()函数中接收类型是

3 : c f 阻塞或返回-1;

0 : a b c d e f g h 阻塞或返回-1;

-3 : d g a e c f 阻塞或返回-1;

/*
* 消息队列,按类型接收消息a
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <signal.h>
struct Msg {
long mtype;        //消息类型
char buf[20];    //存储有效数据;
};
/* int msgid; */
void fa(int signo) {
//信号处理函数无法传参,因此可以定义全局变量,也可重新获取
key_t key = ftok(".", 100);
int msgid = msgget(key, IPC_CREAT | 0666);
//练习:使用msgctl(msgid,IPC_STAT,结构指针)判断消息数是否为0再清空;
//或者关闭时将消息队列写入文件,启动时再加载进来;
printf("捕获信号%d\n", signo);
if (signo == 2) {
struct msqid_ds mds;
if (!msgctl(msgid, IPC_STAT, &mds)) {
if (mds.msg_qnum <= 0) {
msgctl(msgid, IPC_RMID, 0);
printf("消息队列%d已经删除\n", msgid);
} else {
printf("消息队列%d还有%d个msg\n", msgid, mds.msg_qnum);
}
}
printf("消息队列设置恢复默认\n");
printf("进程已退出\n");
signal(SIGINT, SIG_DFL);
exit(0);    //退出进程
}
}
int main() {
key_t key = ftok(".", 100);
int msgid = msgget(key, IPC_CREAT | 0666);
if (msgid == -1) {
perror("msgget"), exit(-1);
}
struct Msg msg1, msg2;
msg1.mtype = 1; strcpy(msg1.buf, "zhangfei");
msg2.mtype = 2; strcpy(msg2.buf, "guanyu");
/* 注意发送的时候,大小只是数据的大小,不包括数据类型 */
msgsnd(msgid, &msg1, sizeof(msg1.buf), 0);
msgsnd(msgid, &msg2, sizeof(msg2.buf), 0);
printf("pid = %d\n", getpid());
signal(SIGINT, fa);
while (1);    //为了回收消息队列的资源(删除);
return 0;
//在msgtypea中写用信号2删除消息队列的代码
}

/*
* 消息队列,按类型接收消息b
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct Msg {
long mtype;        //消息类型
char buf[20];    //存储有效数据;
};
int main() {
key_t key = ftok(".", 100);
int msgid = msgget(key, 0);
if (msgid == -1) {
perror("msgget"), exit(-1);
}
struct Msg msg;
int res, num;
for (num = 2; num >= 0; num--) {
/* 接收类型为num的消息 */
res = msgrcv(msgid, &msg, sizeof(msg.buf), num, 0);
printf("接收了%d字节数据,类型:%d,内容:%s\n",
res, msg.mtype, msg.buf);
}
return 0;
}

在使用有类型的消息时,第2个参数地址是整个结构的地址,但第3个参数大小只是数据区的大小(不包括消息类型msgtype):

资源的管理一般遵循谁创建谁回收的原则

信号量集(semaphore arrays)

信号量集和信号(signal)没有关系,是一个信号量的数组;

信号量集就是信号量数组,信号量就是一个计数器;

//如同马与马虎马上看起来很相似,其实没关系

信号量是一个计数器,用于控制访问共享资源的最大并行(同时运行)进程/线程总数;

假如信号量是3,有5个进程:1先进,结束;2 3 4同时上,2结束,5再上

计数器有两种工作方式:

1.自增型;开始时计数0,来一个自增1,走一个自减1,到计数最大值后不允许再来;

2.自减型;开始计数就是最大值,来一个自减1,走一个自增1,计数到0就阻塞,直到有其他进程结束,计数不再是0;//便于编程维护

如果进程需要访问多个共享资源,需要多个计数器,而多个计数器就使用信号量集(信号量数组);

信号量集其实是进程间的调度,并不能真正的互发数据;

信号量集的编程步骤

1.使用ftok()或者头文件生成key;

2.使用semget(key,...)创建/获取信号量集;

int semget(key_t key, int nsems/*数组大小*/, int semflg);

3.使用semctl(semid,...)给每个信号量集中的每个信号量赋值;//给数组中的每个元素赋值;

4.使用信号量集semop();

5.如果不再使用,可以用semctl(semid,0,IPC_RMID)删除;//与之前略有不同;

函数注解

semctl()初始化信号量集中的每个信号量,格式:

semctl(semid, int index, int cmd, ...)

如果cmd是SETVAL,可以给信号量集中的一个成员赋值,index是信号量集的下标,第四个参数就是初始值;比如:

setctl(semid, 0, SETVAL, 5)//给第1个信号量最大计数设置为5;

失败返回-1;可以使用errno;

semop()用于计数的+1和-1;

int semop(int semid, struct sembuf semoparray[], size_t nops);

参数nops为信号量数组的大小;

参数semoparray是一个指针,它指向一个信号量数组,信号量操作由sembuf结构表示:

struct sembuf{

unsigned short sem_num;/* 操作信号量的下标 */

short sem_op; /* 对信号量的操作方式:负数/0/正数 */

short sem_flg;/* 计数是否阻塞:0阻塞,IPC_NOWAIT不阻塞 */

};

如果sem_op为正,则对应于进程释放占用的资源数,sem_op值加到信号量上;如果指定了undo标志(sem_flg成员设置了SEM_UNDO位),则也从该进程的此信号量中减去sem_op;

若sem_op为负,则表示要获取该信号量的控制资源;

/*
* 信号量集操作演示
* sema.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <signal.h>
int semid;
void sem_free(int signo) {
printf("捕获到信号%d\n", signo);
printf("正在回收资源\n");
if (signo == 2) {
semctl(semid, 0, IPC_RMID);
printf("信号量集已回收\n");
exit(0);
}
}
int main() {
printf("PID = %d\n", getpid());
signal(SIGINT, sem_free);
printf("按Ctrl+C退出\n");
key_t key = ftok(".", 100);
semid = semget(key, 1, 0666 | IPC_CREAT); //第二个参数是数组长度
if (semid == -1) {
perror("semget"), exit(-1);
}
int res = semctl(semid, 0, SETVAL, 5);    //初始化最大计数5
if (res == -1) {
perror("semctl"), exit(-1);
}
printf("成功创建并初始化信号量集\n");
//练习:用信号Ctrl+C实现信号量集的回收;
while (1) ;
return 0;
}

/*
* 信号量集操作演示
* semb.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
int main() {
printf("pid = %d\n", getpid());
key_t key = ftok(".", 100);
int semid = semget(key, 0, 0);    //获取时给0
if (semid == -1) {
perror("semget"), exit(-1);
}
int i;
for (i = 0; i <= 9; i++) {
pid_t pid = fork();
if (pid == 0) {
printf("进程%d开始启动;申请访问资源\n", i + 1);
struct sembuf op;
op.sem_num = 0;    //操作下标为0的信号量
op.sem_op = -1;    //申请访问,计数-1
op.sem_flg = 0;    //0阻塞
/* op.sem_flg = IPC_NOWAIT; //不阻塞 */
semop(semid, &op, 1); //执行-1操作;
//数组的地址==首元素的地址;
printf("进程%d访问资源\n", i + 1);
sleep(10);
op.sem_op = 1; //释放资源,计数+1
semop(semid, &op, 1);    //执行计数+1
printf("进程%d释放资源\n", i + 1);
exit(0);
}
}
printf("父进程已经结束pid = %d\n", getpid());
return 0;
}