进程间通信（IPC）介绍
进程间通信（IPC）是指在不同的进程之间传播或交换信息。
IPC的方式通常有管道（包括无名管道和命名管道），消息队列，信号量，共享储存，Socket，Streams等，其中Socket和streams支持不同主机上的两个进程IPC
一.管道
1.特点
``
1.它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
2.它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
3.它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write等函数，但是它不是普通的文件、并不属于其他任何文件系统，并且只存在于内存中。
f[0]为读而打开，f[1]为写而打开
创建命名管道
int fd[2];
int pid;
char buf[128];
if(pipe(fd)==-1)
{
printf("creat pipe failed");
}
pid=fork();
if(pid<0)
{
printf("creat pipe failed\n");
}
else if(pid > 0)
{ sleep(3); //只有等待父进程读入的时候子进程才会输出
printf("this is father\n");
close(fd[0]);
write(fd[1],"hello from father",strlen);
}
else
{
printf("this is the child");
close(fd[0]);
read(fd[0],buf,129);
printf("read from father:%s\n",buf);
exit(0);
}
FIFO
FIFO，也称命名管道，它是一种文件类型。
1.特点
1.FIFO可以在无关的进程之间交换的数据，与无名管道不同。
2.FIFO有路径名与之间相关联，它以一种特殊设备文件形式存在于文件中
int mkfifo(const char *pathname,mode_t mode);
‘其中mode参数与open函数中的mode相同。如：0600； 一旦创建了一个FIFO，就可以用一般的文件I/O函数操作它。
当open一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别:
- 若没有指定O_NONBLOCK,只读open要阻塞到某个其他进程为写而打开此FIFO。类似的，只写open要阻塞到某个其他进程为读而打开他。
- 若指定了O_NONBLOCK ,则只读open立即返回。而只写open将出错返回-1如果没有进程已经为读而打开该FIFO，其errno置ENXIO
创建成功返回0，创建失败返回-1；
创建成功，创建失败说明原因
int main()
{
if(mkfifo("./file",0600) == -1 &&errno != EEXIFST)
{
printf("mkfifo failed");
perro("why")；
}
}
命名管道的数据通信编程实现
vi read.c
int main()
{
char buf[30]={0};
if(mkfifo("./file",0600) == -1 &&errno != EEXIFST)
{
printf("mkfifo failed");
perro("why");
}
int fd =open("./file",O_RDONLY);
int nread =read(fd,buf,30);
printf("read %d byte from fifo,context:%s",nread,buf);
close(fd);
}
vi write.c
int main()
{
char *str = "message from fifo";
int fd=open("./file",O_WRONLY);
printf("write open success");
write(fd,str,strlen(str));
close(fd);
}
先gcc read.c -o read
在gcc write.c -o write
在一进程里 ./read 等待 写入才会出结果
另外一个进程./write 写入
加入while循环不停写入也可
消息队列的通信
消息队列，是消息的链接表，存放在内核中，一个消息队列由一个表示符（即队列ID）来标识。
特点
1.消息队列里面向记录的，其中的消息具有特定的格式以及特定的优先级。
2.消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会删除。
3.消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取
原型
#include<sys/msg.h>
//创建或打开消息队列:成功返回队列ID，失败返回-1
int msgget(key_t key,int flag);
//添加消息：成功返回0，失败返回-1
int msgsnd(int msqid,const void *ptr,size_t size,int flag);
//读取消息：成功返回消息数据的长度，失败返回-1
int msgrcv(int msqid,void *ptr,size_t size,int flag);
//控制消息队列：成功返回0，失败返回-1
int msgctl(int msqid,int cmd,struct msqid_ds *buf);
vi msgget.c
struct msgbuf
{
long mtype;
char mtext[128];
};
int main()
{
struct msgbuf readbuf;
int msgID =msgget(0x1234,IPC_CREAT|0777);
if(msgID == -1)
{
printf("get que failed\n");
}
msgrcv(msgID,&readbuf,sizeof(readbuf.mtext),888,0);
printf("read from que:%s\n",readbuf.mtext);
struct msg sendbuf ={988,"thank you for reach"};
msgsnd(msgID,&sendbuf,sizeof(sendbuf.mtext),0);
}
vi msgsend.c
struct msgbuf
{
long mtype;
char mtext[128];
};
int main()
{
struct msgbuf readbuf;
struct msg sendbuf ={888,"this is message from que\n"};
int msgID =msgget(0x1234,IPC_CREAT|0777);
if(msgID == -1)
{
printf("get que failed\n");
}
msgsnd(msgID,&sendbuf,sizeof(sendbuf.mtext),0);
msgrcv(msgID,&readbuf,sizeof(readbuf.mtext),988,0);
printf("read from que:%s\n",readbuf.mtext);
}
ftok函数
系统建立IPC通讯(消息队列、信号量和共享内存)时必须指定一个ID值。通常情况下，该ID通过ftok函数得到。
函数原型：
key_t ftok(const char *frame,int id);
frame 就是你指定的文件名（已经存放的文件名），一般使用当前目录，如：
key_t key;
key=ftok(".",1); 这样就是将frame设为当前目录。
ID是子序号，虽然是int类型，但是只使用8bits（1-255）
key_t key;
key=ftok(".",1);
//可以调换key
通过key找队列，找不到产生新的队列
msgctl(msgID,IPC_RMID,NULL);
队列多了，内存占的多，所以要用完删除一定啊
进程间通信
1.无名管道
2.命名管道
3.消息队列
4.共享内存
5.信号
6.信号量
共享内存
//创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
int shmget(key_t,size_t size,int flag);
//连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
void *shmat(int shm_id,const void *addr,int flag);
//断开与共享内存的连接，成功返回0，失败返回-1
int shmdt(void *addr);
//控制共享内存的相关信息，成功返回0，失败返回-1
int shmctl(int shm_id,int cmd,struct shmid_ds *buf);
当用shmget函数创建一段共享内存时，必须指定其size,而如果引用一个已存在的共享内存，则将size指定为0.
当一段共享内存或被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。
shmdt函数是用来断开shmat建立的连接的。注意，这不是从系统中删除共享文件，只是当前进程不能再访问该共享内存而已。
shmct函数可以对共享文件执行多种操作，根据参数cmd执行相应的操作。常用的量IPC_RMID(从系统中删除该共享内存)。
共享内存编程实现
五个步骤
1.创建共享内存
2.映射连接
3.搞入数据
3.断开连接
3.清理共享内存
vi shmw.c
int shmid;
char *shmaddr;
key_t key;
key=ftok(".",1);
shmid = shmget(key,1024*4,IPC_CREAT|0666);
if(shmid == -1)
{
printf("shmget failed\n")
exit(-1);
}
shmaddr = shmat(shmid,0,0);
printf("shmat ok\n");
strcpy(shmaddr,0,0);
sleep(5);
shmdt(shmaddr);
shmctl(shmid,IPC_RMID,0);
printf("quit");
vi shmr.c
int shmid;
char *shmaddr;
key_t key;
key=ftok(".",1);
shmid = shmget(key,1024*4,0); //有了共享内存就不用创建
if(shmid == -1)
{
printf("shmget failed\n")
exit(-1);
}
shmaddr = shmat(shmid,0,0);
printf("shmat ok\n");
printf("data: %s\n",shmaddr);
shmdt(shmaddr);
//shmctl(shmid,IPC_RMID,0);
//输入的时候已经删除了共享内存这里不用了
printf("quit");
ipcs -m 搜索所有的共享内存
ipcrm -m 共享内存的ID
信号编程
对于linux来说，实际的信号是软中断，许多重要的程序需要处理信号，信号，为linux提供了一种处理异步事件的方法，比如，终端用户输入了ctrl+c来中断程序，会通过信号机制停止一个程序
每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO”、“SIGCHILD”等等。
信号定义在signal.h头文件中，信号名都定义为正整数。
具体的信号名称可以使用kill-l来查看信号的名字以及序号，信号是从1开始编号的，不存在0信号，kill对于信号0又特殊的应用
kill -l
查看系统中所有的信号
信号的处理：
信号的处理有三种方法，分别是：忽略、捕捉和默认动作
- 忽略信号，大多数信号可以使用这个方式来处理，但是有两种信号不能被忽略（分别是SIGKILL和SIGSTOP）因为他们向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成了没人能管理的进程，显然是内核设计者不希望看到的场景
- 捕捉信号，需要告诉内核，用户希望如何处理某一种信号，说白了就是写一个信号处理函数，然后这个函数告诉内核，当该信号产生时，由内核来调用用户自定义的函数，以此来实现某种信号的处理。
- 系统默认动作，对于每个信号来说，系统都对应默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。
- 具体的信号默认动作可以使用man 2 signal 来查看系统的具体定义。
了解信号的概述，信号怎么使用呢？
其实对于常用的kill命令就是一个发送信号的工具，kill 9 pid 来杀死进程。比如，我在后台运行了一个top工具，通过ps命令可以查看他的PID，通过kill 9 来发送了一个终止进程的信号来结束了top进程。如果查看信号编号和名称，可以发现9对应的是9.SIGKILL
vi signal.c
vi signalcon.c
发送指令的在signal.c执行文件的时候,利用pid号 将信号发送过去
atoi 字符串转换成数字
SIG_IGN 忽略
ps -aux |grep a.out
可以查a.out 的pid
第二钟方法是利用system执行
sprint 可以将内容打印到cmd的指令里面
信号如何携带消息
信号注册函数——高级版
我们已经成功完成了信号的收发，那么为什么会有高级版出现呢？其实之前的信号存在一个问题就是，虽然发送和接收到了信号，可是总感觉少些什么，既然都已经把信号发送过去了，为何不能再携带一些数据呢？
正是如此，我们需要另外的函数来通过信号传递的过程中，携带一些数据。咱么先来看看发送的函数吧。
#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
struct sigaction {
void (*sa_handler)(int); //信号处理程序，不接受额外数据，SIG_IGN 为忽略，SIG_DFL 为默认动作
void (*sa_sigaction)(int, siginfo_t *, void *); //信号处理程序，能够接受额外数据和sigqueue配合使用
sigset_t sa_mask;//阻塞关键字的信号集，可以再调用捕捉函数之前，把信号添加到信号阻塞字，信号捕捉函数返回之前恢复为原先的值。
int sa_flags;//影响信号的行为SA_SIGINFO表示能够接受数据
};
//回调函数句柄sa_handler、sa_sigaction只能任选其一
sigaction 是一个系统调用，根据这个函数原型，我们不难看出，在函数原型中，第一个参数signum应该就是注册的信号的编号；第二个参数act如果不为空说明需要对该信号有新的配置；第三个参数oldact如果不为空，那么可以对之前的信号配置进行备份，以方便之后进行恢复。
关于void (*sa_sigaction)(int, siginfo_t *, void );处理函数来说还需要有一些说明。void 是接收到信号所携带的额外数据；而struct siginfo这个结构体主要适用于记录接收信号的一些相关信息
siginfo_t {
int si_signo; /* Signal number */
int si_errno; /* An errno value */
int si_code; /* Signal code */
int si_trapno; /* Trap number that caused
hardware-generated signal
(unused on most architectures) */
pid_t si_pid; /* Sending process ID */
uid_t si_uid; /* Real user ID of sending process */
int si_status; /* Exit value or signal */
clock_t si_utime; /* User time consumed */
clock_t si_stime; /* System time consumed */
sigval_t si_value; /* Signal value */
int si_int; /* POSIX.1b signal */
void *si_ptr; /* POSIX.1b signal */
int si_overrun; /* Timer overrun count; POSIX.1b timers */
int si_timerid; /* Timer ID; POSIX.1b timers */
void *si_addr; /* Memory location which caused fault */
int si_band; /* Band event */
int si_fd; /* File descriptor */
}
信号发送函数——高级版
#include <signal.h>
int sigqueue(pid_t pid, int sig, const union sigval value);
union sigval {
int sival_int;
void *sival_ptr;
};
使用 sigaction 函数安装信号处理程序时，制定了 SA_SIGINFO 的标志
sigqueue 函数只能把信号发送给单个进程，可以使用 value 参数向信号处理程序传递整数值或者指针值
vi nicesignal.c
void handler(int signum , siginfo_t *info,void *context)
{
printf("get signum %d\n",signum);
if(context != NULL)
{
printf("get data=%d\n",info.si_int);
printf("get data=%d\n",info.si_value.sival_int);
printf("from:%d\n,info->si_pid")
}
}
int main()
{
struct sigaction act;
printf("pid = %d\n",getpid());
act.sa_sigaction = handler;
act.sa_flags = SA_SIGINFO; //bu able to get message
sigaction(SIGUSR1,&act,NULL);
while(1);
}
vi send.c
int main(int argc,char **argv)
{
int signum;
int pid;
signum = atoi(argv[1]);
pid = atoi(argv[2]);
union sigval value;
value.sival_int = 100;
sigqueue(pid,signum,value);
return 0;
}
信号量
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
1、特点
信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
支持信号量组。
2、原型
最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。
Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。
#include <sys/sem.h>
// 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
int semget(key_t key, int num_sems, int sem_flags);
// 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
int semop(int semid, struct sembuf semoparray[], size_t numops);
// 控制信号量的相关信息
int semctl(int semid, int sem_num, int cmd, ...);
在semctl函数中的命令有多种，这里就说两个常用的：
SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源
信号量可以比作锁
union semun
{
int val; /*for SETVAL*/
struct semid_ds *buf;
unsigned short *array;
struct seminfo *_buf;
};
void pGetKey(int id)
{
struct sembuf set; //因为1 所以就不用定义数组
set.sem_num = 0;
set.sem_op = -1;
set.sem_flag=SEM_UNDO;
semop(id,&set,1);
printf("getkey\n");
}
void pGetKey(int id)
{
struct sembuf set; //因为1 所以就不用定义数组
set.sem_num = 0;
set.sem_op = -1;
set.sem_flg=SEM_UNDO;
semop(id,&set,1);
printf("getkey\n");
}
void vPutBackKey(int id)
{
struct sembuf set; //因为1 所以就不用定义数组
set.sem_num = 0;
set.sem_op = 1;
set.sem_flg=SEM_UNDO;
semop(id,&set,1);
printf("put back the key\n");
}
int main(int argc,char const*argv[])
{
key_t key;
int semid;
key = ftok(".",2);
//信号量集合中有一个信号量
semid = semget(key,1,IPC_CREAT|0666); //获取/创建信号量
nion semun initsem;
initsem.val = 0;
//操作第0个信号量
semctl(semid,0,SETVAL,initsem); //初始化信号量
//SETVAL 设置信号量的值，设置initsem
int pid=fork();
if(pid>0)
{
//去拿锁
pGetKey(semid);
printf("this is father\n");
vPutBackKey(semid);
//锁放回去
semctl(semid,0,SETVAL,IPC_RMID); //删除
}
else if(pid == 0)
{
printf("this is child\n");
vPutBackKey(semid);
}
else{
printf("fork error\n");
}
}
这样子进程会优先进行
也可以配合共享内存进行使用
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<sys/sem.h>
4
5 // 联合体，用于semctl初始化
6 union semun
7 {
8 int val; /for SETVAL/
9 struct semid_ds *buf;
10 unsigned short *array;
11 };
12
13 // 初始化信号量
14 int init_sem(int sem_id, int value)
15 {
16 union semun tmp;
17 tmp.val = value;
18 if(semctl(sem_id, 0, SETVAL, tmp) == -1)
19 {
20 perror(“Init Semaphore Error”);
21 return -1;
22 }
23 return 0;
24 }
25
26 // P操作:
27 // 若信号量值为1，获取资源并将信号量值-1
28 // 若信号量值为0，进程挂起等待
29 int sem_p(int sem_id)
30 {
31 struct sembuf sbuf;
32 sbuf.sem_num = 0; /序号/
33 sbuf.sem_op = -1; /P操作/
34 sbuf.sem_flg = SEM_UNDO;
35
36 if(semop(sem_id, &sbuf, 1) == -1)
37 {
38 perror(“P operation Error”);
39 return -1;
40 }
41 return 0;
42 }
43
44 // V操作：
45 // 释放资源并将信号量值+1
46 // 如果有进程正在挂起等待，则唤醒它们
47 int sem_v(int sem_id)
48 {
49 struct sembuf sbuf;
50 sbuf.sem_num = 0; /序号/
51 sbuf.sem_op = 1; /V操作/
52 sbuf.sem_flg = SEM_UNDO;
53
54 if(semop(sem_id, &sbuf, 1) == -1)
55 {
56 perror(“V operation Error”);
57 return -1;
58 }
59 return 0;
60 }
61
62 // 删除信号量集
63 int del_sem(int sem_id)
64 {
65 union semun tmp;
66 if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
67 {
68 perror(“Delete Semaphore Error”);
69 return -1;
70 }
71 return 0;
72 }
73
74
75 int main()
76 {
77 int sem_id; // 信号量集ID
78 key_t key;
79 pid_t pid;
80
81 // 获取key值
82 if((key = ftok(".", ‘z’)) < 0)
83 {
84 perror(“ftok error”);
85 exit(1);
86 }
87
88 // 创建信号量集，其中只有一个信号量
89 if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
90 {
91 perror(“semget error”);
92 exit(1);
93 }
94
95 // 初始化：初值设为0资源被占用
96 init_sem(sem_id, 0);
97
98 if((pid = fork()) == -1)
99 perror(“Fork Error”);
100 else if(pid == 0) /子进程/
101 {
102 sleep(2);
103 printf(“Process child: pid=%d\n”, getpid());
104 sem_v(sem_id); /释放资源/
105 }
106 else /父进程/
107 {
108 sem_p(sem_id); /等待资源/
109 printf(“Process father: pid=%d\n”, getpid());
110 sem_v(sem_id); /释放资源/
111 del_sem(sem_id); /删除信号量集/
112 }
113 return 0;
114 }
扫一扫
7683
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
