概念：就是进程和进程之间交换信息。
常用通信方式
无名管道（pipe）
有名管道 （fifo）
信号（signal）
共享内存映射(mmap)
套接字（socket）
过时的IPC通信方式
System V IPC
共享内存（share memory）
消息队列（message queue）
信号灯集（semaphore set）
无名管道
int pipe(int pfd[2]); 成功：0；失败：-1，设置errno
pfd[0] 为读描述符
pfd[1] 为写描述符
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(){int pfd[2];int re;char buf[20]={0};pid_t pid;re = pipe(pfd);if(re<0){perror("pipe");return 0;}printf("%d,%d\n",pfd[0],pfd[1]);pid = fork();if(pid<0){perror("fork");return 0;}else if(pid>0){//close(pfd[0]);while(1){strcpy(buf,"hhahahahah");write(pfd[1],buf,strlen(buf));sleep(1);}}else{close(pfd[1]); while(1){re=read(pfd[0],buf,20);if(re>0){printf("read pipe=%s\n",buf);} }}}无名管道注意事项：
- 只能用于亲缘关系的进程间通信（父子进程，兄弟进程）
- 管道通信是单工的，一端读，一端写（程序实现设计好）。
- 数据自己读不能自己写
- 管道可以用于大于2个进程共享
无名管道的读写特性：
- 读管道：
1. 管道中有数据，read返回实际读到的字节数。
2. 管道中无数据：
(1) 管道写端被全部关闭，read返回0 (好像读到文件结尾)
(2) 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)
- 写管道：
1. 管道读端全部被关闭， 进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)
2. 管道读端没有全部关闭：
(1) 管道已满，write阻塞。（管道大小64K）
(2) 管道未满，write将数据写入，并返回实际写入的字节数。
有名管道（命名管道）
创建管道
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *filename, mode_t mode);
open(const char *path, O_RDONLY);//1
open(const char *path, O_RDONLY | O_NONBLOCK);//2
open(const char *path, O_WRONLY);//3
open(const char *path, O_WRONLY | O_NONBLOCK);//4
特点：
1有名管道可以使非亲缘的两个进程互相通信
2通过路径名来操作，在文件系统中可见，但内容存放在内存中
3 文件IO来操作有名管道
4 遵循先进先出规则
5 不支持leek操作
6 单工读写
注意事项：
1 就是程序不能以O_RDWR(读写)模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程可以读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递
2 第二个参数中的选项O_NONBLOCK，选项O_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的
3 对于以只读方式（O_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。
对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。
4.数据完整性,如果有多个进程写同一个管道，使用O_WRONLY方式打开管道，如果写入的数据长度小于等于PIPE_BUF（4K），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。
内存映射
概念：
使一个磁盘文件与内存中的一个缓冲区相映射，进程可以像访问普通内存一样对文件进行访问，不必再调用read,write。
mmap()的优点：
实现了用户空间和内核空间的高效交互方式
函数定义：
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
功能：创建共享内存映射
函数返回值：成功返回创建的映射区首地址，失败返回MAP_FAILED（ ((void *) -1) ），设置errno值
参数说明：
addr：指定要映射的内存地址，一般设置为 NULL 让操作系统自动选择合适的内存地址。
length：必须>0。映射地址空间的字节数，它从被映射文件开头 offset 个字节开始算起。
prot：指定共享内存的访问权限。可取如下几个值的可选：PROT_READ（可读）, PROT_WRITE（可写）, PROT_EXEC（可执行）, PROT_NONE（不可访问）。
flags：由以下几个常值指定：MAP_SHARED（共享的） MAP_PRIVATE（私有的）, MAP_FIXED（表示必须使用 start 参数作为开始地址，如果失败不进行修正），其中，MAP_SHARED , MAP_PRIVATE必选其一，而 MAP_FIXED 则不推荐使用。MAP_ANONYMOUS（匿名映射，用于血缘关系进程间通信）
fd：表示要映射的文件句柄。如果匿名映射写-1。
offset：表示映射文件的偏移量，一般设置为 0 表示从文件头部开始映射。
注意事项：
（1） 创建映射区的过程中，隐含着一次对映射文件的读操作，将文件内容读取到映射区。
（2） 当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)，如果不满足报非法参数（Invalid argument）错误。
当MAP_PRIVATE时候，mmap中的权限是对内存的限制，只需要文件有读权限即可，操作只在内存有效，不会写到物理磁盘，且不能在进程间共享。
（3） 映射区的释放与文件关闭无关，只要映射建立成功，文件可以立即关闭。
（4） 用于映射的文件大小必须>0，当映射文件大小为0时，指定非0大小创建映射区，访问映射地址会报总线错误，指定0大小创建映射区，报非法参数错误（Invalid argument）
（5） 文件偏移量必须为0或者4K的整数倍（不是会报非法参数Invalid argument错误）.
（6）映射大小可以大于文件大小，但只能访问文件page的内存地址，否则报总线错误 ，超出映射的内存大小报段错误
（7）mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
mmap()映射的种类：
1基于文件的映射
写
#include <sys/mman.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main(){void *addr;int fd;fd =open("test",O_RDWR);if(fd<0){perror("open");return 0;}int len = lseek(fd,0,SEEK_END); addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);if(addr == MAP_FAILED){perror("mmap");return 0;}close(fd);int i=0;while(i<2048){memcpy((addr+i),"a",1);i++;sleep(1);}
// printf("read=%s\n",(char*)(addr));}
读
#include <sys/mman.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main(){void *addr;int fd;fd =open("test",O_RDWR);if(fd<0){perror("open");return 0;}int len = lseek(fd,0,SEEK_END); addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);if(addr == MAP_FAILED){perror("mmap");return 0;}close(fd);// memcpy((addr),"99999999999999",15);while(1){printf("read=%s\n",(char*)(addr));sleep(1);}}2 匿名映射
适用于具有亲缘关系的进程之间，
#include <sys/mman.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>int main(){void *addr;addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);if(addr == MAP_FAILED){perror("mmap");return 0;}pid_t pid;pid = fork();if(pid<0){perror("fork");return 0;}else if(pid>0){memcpy(addr,"1234567890",10);wait(NULL);}else {sleep(1);printf("read father val=%s\n",(char *)addr);}munmap(addr,2048);}释放内存映射
munmap函数
int munmap(void *addr, size_t length);
返回值：成功返回0，失败返回-1，并设置errno值。
函数参数：
addr：调用mmap函数成功返回的映射区首地址
length：映射区大小（即：mmap函数的第二个参数）
System V共享内存
IPC 的key
ftok函数
key_t ftok(const char *path, int id);
其中参数path是指定的文件名，这个文件必须是存在的而且可以访问的。id是子序号，它是一个8bit的整数。即范围是0~255。当函数执行成功，则会返回key_t键值，否则返回-1。在一般的UNIX中，通常是将文件的索引节点取出，然后在前面加上子序号就得到key_t的值
system V 共享内存使用步骤：
1创建/打开共享内存
2映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
3 读写共享内存
4 撤销共享内存映射
5 删除共享内存对象
查看共享内存命令ipcs
共享内存创建 – shmget
int shmget(key_t key, int size, int shmflg);
共享内存映射
void *shmat(int shmid, const void *shmaddr, int shmflg);
第二个参数一般写NULL，表示自动映射
第三参数一般写0 ，表示可读写
共享内存撤销
int shmdt(void *shmaddr);
撤销后，内存地址不可再访问。
共享内存控制
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
shmctl(shmid, IPC_RMID, NULL);删除共享内存
信号机制
概念：信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式
所有信号的产生及处理全部都是由内核完成的
信号的产生：
1 按键产生
2 系统调用函数产生（比如raise， kill）
3 硬件异常
4 命令行产生 （kill）
5 软件条件（比如被0除，访问非法内存等）
信号处理方式：
1 缺省方式
2 忽略信号
3 捕捉信号
常用信号：
| 信号名 | 含义 | 默认操作 |
| SIGHUP | 该信号在用户终端关闭时产生，通常是发给和该 终端关联的会话内的所有进程 | 终止 |
| SIGINT | 该信号在用户键入INTR字符(Ctrl-C)时产生，内 核发送此信号送到当前终端的所有前台进程 | 终止 |
| SIGQUIT | 该信号和SIGINT类似，但由QUIT字符(通常是 Ctrl-\)来产生 | 终止 |
| SIGILL | 该信号在一个进程企图执行一条非法指令时产生 | 终止 |
| SIGSEV | 该信号在非法访问内存时产生，如野指针、缓 冲区溢出 | 终止 |
| SIGPIPE | 当进程往一个没有读端的管道中写入时产生，代 表“管道断裂” | 终止 |
| 信号名 | 含义 | 默认操作 |
| SIGKILL | 该信号用来结束进程，并且不能被捕捉和忽略 | 终止 |
| SIGSTOP | 该信号用于暂停进程，并且不能被捕捉和忽略 | 暂停进程 |
| SIGTSTP | 该信号用于暂停进程，用户可键入SUSP字符( 通常是Ctrl-Z)发出这个信号 | 暂停进程 |
| SIGCONT | 该信号让进程进入运行态 | 继续运行 |
| SIGALRM | 该信号用于通知进程定时器时间已到 | 终止 |
| SIGUSR1/2 | 该信号保留给用户程序使用 | 终止 |
| SIGCHLD | 是子进程状态改变发给父进程的。 | 忽略 |
信号命令：
kill [-signal] pid
killall [-u user | prog]
信号的函数：
int kill（pid_t pid, int signum）
功能：发送信号
参数：
pid: > 0:发送信号给指定进程
= 0：发送信号给跟调用kill函数的那个进程处于同一进程组的进程。
< -1: 取绝对值，发送信号给该绝对值所对应的进程组的所有组员。
= -1：发送信号给，有权限发送的所有进程。
signum：待发送的信号
int raise(int sig);
给自己发信号，等价于kill(getpid(), signo);
定时器函数
unsigned int alarm(unsigned int seconds);
功能：定时发送SIGALRM给当前进程
参数： seconds：定时秒数
返回值：上次定时剩余时间。
ualarm （循环发送）
useconds_t ualarm(useconds_t usecs, useconds_t interval);
以useconds为单位，第一个参数为第一次产生时间，第二个参数为间隔产生
int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);
功能：定时的发送alarm信号
参数：
which：
ITIMER_REAL：以逝去时间递减。发送SIGALRM信号
ITIMER_VIRTUAL: 计算进程（用户模式）执行的时间。 发送SIGVTALRM信号
ITIMER_PROF: 进程在用户模式（即程序执行时）和核心模式（即进程调度用时）均计算时间。 发送SIGPROF信号
new_value： 负责设定 timout 时间
old_value： 存放旧的timeout值，一般指定为NULL
struct itimerval {
struct timeval it_interval; // 闹钟触发周期
struct timeval it_value; // 闹钟触发时间
};
struct timeval {
time_t tv_sec; /* seconds */
suseconds_t tv_usec; /* microseconds */
};
信号的捕捉
信号捕捉过程：
- 定义新的信号的执行函数handle。
- 使用signal/sigaction 函数，把自定义的handle和指定的信号相关联。
signal函数：
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
功能：捕捉信号执行自定义函数
返回值：成功时返回原先的信号处理函数，失败时返回SIG_ERR
参数：
signo 要设置的信号类型
handler 指定的信号处理函数: SIG_DFL代表缺省方式; SIG_IGN 代表忽略信号;
系统建议使用sigaction函数，因为signal在不同类unix系统的行为不完全一样。
sigaction函数：
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);
struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
}
参数：
signum：处理的信号
act,oldact: 处理信号的新行为和旧的行为，是一个sigaction结构体。
sigaction结构体成员定义如下：
sa_handler： 是一个函数指针，其含义与 signal 函数中的信号处理函数类似
sa_sigaction： 另一个信号处理函数，它有三个参数，可以获得关于信号的更详细的信息。
sa_flags参考值如下：
SA_SIGINFO：使用 sa_sigaction 成员而不是 sa_handler 作为信号处理函数
SA_RESTART：使被信号打断的系统调用自动重新发起。
SA_RESETHAND：信号处理之后重新设置为默认的处理方式。
SA_NODEFER：使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号。
re_restorer：是一个已经废弃的数据域
定时器的实现
使用SIGCHLD信号实现回收子进程
SIGCHLD的产生条件
1子进程终止时
2子进程接收到SIGSTOP信号停止时
3子进程处在停止态，接受到SIGCONT后唤醒时
信号集、信号的阻塞
有时候不希望在接到信号时就立即停止当前执行，去处理信号，同时也不希望忽略该信号，而是延时一段时间去调用信号处理函数。这种情况可以通过阻塞信号实现。
信号的阻塞概念：信号的”阻塞“是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。
信号的状态：
信号递达（Delivery ）：实际信号执行的处理过程(3种状态：忽略，执行默认动作，捕获)
信号未决（Pending）：从产生到递达之间的状态
信号集操作函数
sigset_t set; 自定义信号集。 是一个32bit 64bit 128bit的数组。
sigemptyset(sigset_t *set); 清空信号集
sigfillset(sigset_t *set); 全部置1
sigaddset(sigset_t *set, int signum); 将一个信号添加到集合中
sigdelset(sigset_t *set, int signum); 将一个信号从集合中移除
sigismember（const sigset_t *set，int signum); 判断一个信号是否在集合中。
设定对信号集内的信号的处理方式(阻塞或不阻塞)
#include <signal.h>
int sigprocmask( int how, const sigset_t *restrict set, sigset_t *restrict oset );
返回值：若成功则返回0，若出错则返回-1
首先，若oset是非空指针，那么进程的当前信号屏蔽字通过oset返回。
其次，若set是一个非空指针，则参数how指示如何修改当前信号屏蔽字。
how可选用的值：（注意，不能阻塞SIGKILL和SIGSTOP信号）
SIG_BLOCK ： 把参数set中的信号添加到信号屏蔽字中
SIG_UNBLOCK： 从信号屏蔽字中删除参数set中的信号
SIG_SETMASK： 把信号屏蔽字设置为参数set中的信号
信号驱动程序
int pause(void);
进程一直阻塞，直到被信号中断，返回值：-1 并设置errno为EINTR
函数行为：
1如果信号的默认处理动作是终止进程，则进程终止，pause函数么有机会返回。
2如果信号的默认处理动作是忽略，进程继续处于挂起状态，pause函数不返回
3 如果信号的处理动作是捕捉，则调用完信号处理函数之后，pause返回-1。
4 pause收到的信号如果被屏蔽，那么pause就不能被唤醒
int sigsuspend(const sigset_t *sigmask);
功能：将进程的屏蔽字替换为由参数sigmask给出的信号集，然后挂起进程的执行
参数：
sigmask：希望屏蔽的信号
信号驱动函数
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>void handle(int sig){printf("I get sig=%d\n",sig);}void mytask(){printf("My task start\n");sleep(3);printf("My task end\n");}int main(){struct sigaction act;act.sa_handler = handle;act.sa_flags = 0;sigemptyset(&act.sa_mask);sigaction(SIGINT,&act,NULL);sigaction(SIGHUP,&act,NULL);sigset_t set,set2;sigemptyset(&set2);sigaddset(&set,SIGHUP);sigaddset(&set,SIGINT);pause();while(1){sigprocmask(SIG_BLOCK,&set,NULL);mytask();// sigprocmask(SIG_UNBLOCK,&set,NULL);// pause();sigsuspend(&set2);}printf("After pause\n");while(1){sleep(1);} } 消息队列
概念：
消息队列是System V IPC对象的一种
消息队列的使用：
发送端：
1 申请Key
2打开/创建消息队列 msgget
3向消息队列发送消息 msgsnd
接收端：
1打开/创建消息队列 msgget
2从消息队列接收消息 msgrcv
3 控制（删除）消息队列 msgctl
打开/创建消息队列
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg);
成功时返回消息队列的id，失败时返回EOF
key 和消息队列关联的key IPC_PRIVATE 或 ftok
msgflg 标志位 IPC_CREAT|0666 IPC_CREAT：没有创建，有则打开。
发送消息
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msgid, const void *msgp, size_t size,
int msgflg);
成功时返回0，失败时返回-1
msgid 消息队列id
msgp 消息缓冲区地址
size 消息正文长度
msgflg 标志位 0 或 IPC_NOWAIT
msgflg:
0：当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列
IPC_NOWAIT：当消息队列已满的时候，msgsnd函数不等待立即返回
消息格式：
typedef struct{
long msg_type;
char buf[128];
}msgT;
注意：
1 消息结构必须有long类型的msg_type字段，表示消息的类型。
2消息长度不包括首类型 long
消息的接收：
#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv(int msgid, void *msgp, size_t size, long msgtype,
int msgflg);
成功时返回收到的消息长度，失败时返回-1
msgid 消息队列id
msgp 消息缓冲区地址
size 指定接收的消息长度
msgtype 指定接收的消息类型
msgflg 标志位
msgtype：
msgtype=0：收到的第一条消息，任意类型。
msgtype>0：收到的第一条 msg_type类型的消息。
msgtype<0：接收类型等于或者小于msgtype绝对值的第一个消息。
例子：如果msgtype=-4，只接受类型是1、2、3、4的消息
msgflg：
0：阻塞式接收消息
IPC_NOWAIT：如果没有返回条件的消息调用立即返回，此时错误码为ENOMSG
MSG_EXCEPT：与msgtype配合使用返回队列中第一个类型不为msgtype的消息
消息队列的控制
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msgid, int cmd, struct msqid_ds *buf);
成功时返回0，失败时返回-1
msgid 消息队列id
cmd 要执行的操作 IPC_STAT / IPC_SET / IPC_RMID（删除）
buf 存放消息队列属性的地址
msgsnd.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>typedef struct{long msg_type;char buf[128];
}msgT; #define MSGLEN (sizeof(msgT)-sizeof(long))int main(){key_t key;int msgid;int ret;msgT msg;key = ftok(".",100);if(key<0){perror("ftok");return 0;}msgid = msgget(key,IPC_CREAT|0666);if(msgid<0){perror("msgget");return 0;}msg.msg_type = 1;strcpy(msg.buf,"this msg type 1");ret = msgsnd(msgid,&msg,MSGLEN,0);if(ret<0){perror("msgsnd");return 0;} msg.msg_type = 2;strcpy(msg.buf,"this msg type 2");ret = msgsnd(msgid,&msg,MSGLEN,0);if(ret<0){perror("msgsnd");return 0;}msg.msg_type = 3;strcpy(msg.buf,"this msg type 3");ret = msgsnd(msgid,&msg,MSGLEN,0);if(ret<0){perror("msgsnd");return 0;}msg.msg_type = 4;strcpy(msg.buf,"this msg type 4");ret = msgsnd(msgid,&msg,MSGLEN,0);if(ret<0){perror("msgsnd");return 0;}msg.msg_type = 5;strcpy(msg.buf,"this msg type 5");ret = msgsnd(msgid,&msg,MSGLEN,0);if(ret<0){perror("msgsnd");return 0;}}msgrcv.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>typedef struct{long msg_type;char buf[128];
}msgT; #define MSGLEN (sizeof(msgT)-sizeof(long))
int main(){int msgid;key_t key;msgT msg;int ret;key = ftok(".",100);if(key<0){perror("ftok");return 0;} msgid = msgget(key,IPC_CREAT|0666);if(msgid<0){perror("msgget");return 0;}int count=0;while(1){ret = msgrcv(msgid,&msg,MSGLEN,0,0);if(ret<0){perror("msgrcv");return 0;} count++;if(count>3){break;}printf("receiv msg type=%d,buf=%s\n",(int)msg.msg_type,msg.buf);}ret = msgctl(msgid,IPC_RMID,NULL);if(ret<0){perror("msgctl");return 0;} }
