进程间通信的方式

管道

管道是Linux操作系统下的一种文件类型，该文件类型的文件就是为了给不同进程之间提供可以进行通信的文件资源。
一个管道只能单向通信。

为什么一个管道只能进行单向通信？

一个进程可以对一个管道文件进行读或写操作，当两个进程通过一个管道进行通信时，一定是有一个进程对管道进行写操作，另一个管道进行读操作，这样就可以实现进程之间的单向通信，但假如两个进程同时将读写端口都打开时，两个进程都可以进行读或写操作，这样就会造成进程之间读取信息紊乱，所以一个管道只能进行单向通信，如果想要以管道的方式实现两个进程之间双向通信，就必须实现两个管道。

管道操作

图解管道操作（以匿名管道为例）：

1.父进程创建管道

2.父进程fork出子进程

3.子进程关闭写端，父进程关闭读端

所以我们可以将管道视为文件，并且使用文件操作的方式去操作管道。

匿名管道

匿名管道只能用于有亲缘关系的两个进程之间的通信，通常用于子进程与父进程。
匿名管道属于管道的一种，它同样只可以单向通信。
匿名管道的生命周期随进程。
匿名管道是面向字节流的。
操作系统内核会对匿名管道进行同步于互斥。

接口

#include<unistd.h>

int pipe(int fd[2]);

接口功能：创建一个匿名管道文件
参数：文件描述符数组，fd[0]表示读端，fd[1]表示写端

代码实现匿名管道

/*
 *子进程向管道内写入10次，i am child...
 *父进程每隔1s从管道本读出一句i am child...
 *该进程的子进程与父进程未设置退出逻辑，需要使用[Ctrl+C]终止进程
 */
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<string.h>
void test_pipe()
{
    int fd[2];
    if(-1 == pipe(fd))//匿名管道创建失败
    {
        exit(EXIT_FAILURE);
    }
    pid_t id = fork();
    char buf[64];
	if(-1 == id)//子进程创建失败
    {
        exit(EXIT_FAILURE);
    }
    else if(0 == id)//子进程
    {
        int i = 0;
        close(fd[0]);//关闭子进程读端
        strcpy(buf, "i am child...\n");
        while(i < 10)
        {
            write(fd[1], buf, sizeof(buf));
            i += 1;
        }
        
        while(1);//子进程写入完成时不退出，管道写端不关闭
        close(fd[1]);
    }
    else//父进程
    {
        close(fd[1]);//关闭父进程的写端
        while(1)
        {
            read(fd[0], buf, sizeof(buf));//子进程从管道读数据
            printf("%s\n", buf);
        }
        
        while(wait(NULL)!=id);//等待子进程退出
        close(fd[0]);//关闭读端
    }
}
int main()
{
    test_pipe();
    return 0;
}
运行结果：
i am child...
i am child...
i am child...
i am child...    
i am child...
i am child...
i am child...
i am child...
i am child...
i am child...

命名管道

命名管道可以应用于两个毫不相干的进程之间的通信。
命名管道是一种特殊类型的文件。

接口

#include<sys/types.h>
#include<sys/stat.h>

int mkfifo(const char* pathname, mode_t mode);
功能：在pathname路径下，创建一个命名管道文件

参数：
	pathname：路径信息，表示管道文件将会创建在pathname路径下，不支持~
	mode:管道文件权限信息，通常配合umask(mode_t mode);使用

命名管道与匿名管道的区别

匿名管道只能用于具有亲缘关系的进程之间的通信，命名管道可以用于任意两个进程之间的通信。
匿名管道用pipe()函数创建并打开，命名管道通过mkfifo()函数创建，由open()函数打开

代码实现命名管道

通过命名管道实现client进程向service进程发送文本数据，该管道由service创建并销毁，client只打开并写入文本数据即可。client.c service.c pipe.h必须放在同一级目录下。

模代码结构

$ ls
service.c client.c pipe.h Makefile
$ cat Makefile
.PHONY:all
all:service client
service:service.c
	gcc $^ -o $@
client:client.c
	gcc $^ -o $@
	
.PHONY:clean
clean:
	rm -f service client

/*
 *pipe.h
 */
#ifndef _PIPE_H_
#define _PIPE_H_
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>

#define PATHNAME "/tmp/pipe_withname"
#define BUF_SIZE 1024
#denif

/*
 *service.c
 */
#include"./pipe.h"
int main()
{
    int fd;
    char buf[BUF_SIZE] = {0};
    umask(0);
    
    if(-1 == mkfifo(PATHNAME, 0644))//创建管道文件，文件权限为-rw-r--r--
    {
        exit(EXIT_FAILURE);//若管道创建失败，则失败退出
    }
    if(-1 == (fd = open(PATHNAME, O_RDONLY)))//只读打开管道文件
    {
        exit(EXIT_FAILURE);//如果打开失败，则失败退出
    }
    
    while(1)
    {
        ssize_t s;
        printf("please wait...\n");
        s = read(fd, buf, sizeof(BUF_SIZE));
        if(s <= 0)//s小于0，则读取出现异常
            break;
        if(0 == strcmp(buf, "quit\n"))//若client发送quit文本，则正常退出
        {
            printf("quit signal, Bye...\n");
            break;
        }
        printf("client said: %s", buf);
        fflush(stdout);
    }
    
    close(fd);
    return 0;
}

/*
 *client.c
 */
#include"./pipe.h"
int main()
{
    int fd;
    char buf[BUF_SIZE] = {0};
    if(-1 == (fd = open(PATHNAME, O_WRONLY)))//只写打开管道文件
    {
        exit(EXIT_FAILURE);//如打开失败，则失败退出
    }
    while(1)
    {
        printf("client: ");
        fflush(stdout);
        fgets(buf, sizeof(buf), stdin);//从键盘获取字符串
        write(fd, buf, sizeof(buf));//将获取到的字符串写进管道
        if(strcmp(buf, "quit\n"))
            break;
    }
    close(fd);
}

管道读写规则

当没有数据可读时：
- O_NONBLOCK disable：read调用阻塞，进程暂停执行，一直等到有数据来为止。
- O_NONBLOCK enable：read返回-1，errno值为EAGAIN。
当管道写满时：
- O_NONBLOCK disable：write调用阻塞，直到有进程读走数据。
- O_NONBLOCK enable：write调用返回-1，errno值为EAGAIN。
如果所有管道对应的写端文件描述符被关闭，则read返回0。
如果所有管道对应的读端文件描述符被关闭，则write操作会产生信号SIGPIPE，可能会导致write退出。
当要写入的数据不大于PIPE_BUF时，Linux保证写入数据的原子性。
当要写入的数据大于PIPE_BUF时，Linux不再保证写入数据的原子性。

消息队列

什么是消息队列

消息队列是操作系统内核提供的一个用于进程双方通信的队列（链表）
进程向消息队列中发送的数据块中包含一个特有的类型，类似于标签，用来表明该数据块来自哪个进程。（因为进程向消息队列中发送的数据块不能被自己拿走）
消息队列每个消息的最大长度是有上限的（MSGMAX），每个消息队列的总的字节数是有上限的（MSGMNB），系统中消息队列的总数也是有上限的（MSGMNI）。
消息队列的生命周期是随系统的。

IPC对象数据结构 /usr/include/linux/ipc.h

struct ipc_perm{
    key_t          _key; /* Key supplied to xxxget(2) */
    uid_t           uid; /* Effective UID of owner */
    gid_t           gid; /* Effective GID of owner */
    uid_t 		   cuid; /* Effective UID of Creater */
    gid_t          cgid; /* Effective GID of Creater */
    unsigned short mode; /* Permissions */
    unsigned short _seq; /* Sequeue number */
};

_key：用来判断两个进程看到的消息队列是否为同一个消息队列，每一个消息队列的_key值是唯一的。
进行通信的两个进程获取消息队列_key值的方式必须是相同的。
ipc资源的生命周期跟随内核的。
- ipcs -q ：查看系统中现存的消息队列
- ipcrm -q msgid ：删除消息队列

消息队列数据结构 /usr/include/linux/msg.h

struct msqid_ds {
 	struct ipc_perm msg_perm;
 	struct msg *msg_first; /* first message on queue,unused */
 	struct msg *msg_last; /* last message in queue,unused */
 	__kernel_time_t msg_stime; /* last msgsnd time */
 	__kernel_time_t msg_rtime; /* last msgrcv time */
 	__kernel_time_t msg_ctime; /* last change time */
 	unsigned long msg_lcbytes; /* Reuse junk fields for 32 bit */
 	unsigned long msg_lqbytes; /* ditto */
 	unsigned short msg_cbytes; /* current number of bytes on queue */
 	unsigned short msg_qnum; /* number of messages in queue */
 	unsigned short msg_qbytes; /* max number of bytes on queue */
 	__kernel_ipc_pid_t msg_lspid; /* pid of last msgsnd */
 	__kernel_ipc_pid_t msg_lrpid; /* last receive pid */
};

消息队列中消息块的数据结构（自己定义）

struct msgbuf{
	long mytype;
    char mtext[1];
};

mtype：指明消息类型，它必须大于0，类似于标签，用来表明该数据块来自哪个进程。
mtext[1]：存放消息数据，该数组的大小可以自行定义，但不能超过系统规定的上限值。

接口：

//创建/打开消息队列
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>

int msgget(key_t key, int msgflg);

key：用来判断两个进程看到的消息队列是否为同一个消息队列，每一个消息队列的_key值是唯一的。通常该处调用key_t ftok()函数来设置唯一键值。
msgflg：
- IPC_CREAT|IPC_EXEL：创建消息队列，如果想要创建的消息队列在底层已经存在，则出错返回；如果要创建的消息队列在底层不存在，则创建该消息队列，但不打开。
- IPC_CREAT：打开消息队列，如果想要打开的消息队列在底层已经存在，则打开该消息队列。
返回值：成功返回消息队列的标识符；失败返回-1。

//删除消息队列
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>

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

msqid：消息队列标识符。
cmd：表示要对消息队列所做的操作
- IPC_RMID：立即删除消息队列
- IPC_STAT：
buf：属性信息，若要删除消息队列，此处可以传递NULL

//向消息队列发送数据
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>

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

msqid：消息队列标识符。
msgp：是一个指针，指向准备发送的消息。
msgsz：是msgp指向的消息⻓度，这个⻓度不含保存消息类型的那个long int⻓整型。
msgflg：控制当队列存满或达到系统上限时要做的事情
- IPC_NOWAIT表示队列满不等待，返回EAGAIN错误
返回值：成功返回0；失败返回-1。

//从消息队列取出数据
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>

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

msgid：消息队列标识符。
msgp：是⼀个指针，指针指向准备接收的消息。
msgsz：是msgp指向的消息⻓度，这个⻓度不含保存消息类型的那个long int⻓整型
msgtype：它可以实现接收优先级的简单形式。
- msgtype=0返回队列第⼀条信息
- msgtype>0返回队列第⼀条类型等于msgtype的消息
- msgtype<0返回队列第⼀条类型⼩于等于msgtype绝对值的消息，并且是满⾜条件的消息类型最⼩的消息
msgflg：控制着队列中没有相应类型的消息可供接收时将要发⽣的事
- msgflg=IPC_NOWAIT，队列没有可读消息不等待，返回ENOMSG错误
- msgflg=MSG_NOERROR，消息⼤⼩超过msgsz时被截断
- msgtype>0且msgflg=MSG_EXCEPT，接收类型不等于msgtype的第⼀条消息
返回值：成功返回实际放到接收缓冲区⾥去的字符个数，失败返回-1

封装消息队列接口

/*
 * 注意：1.接受消息时，如果消息队列里没有符合要求的消息，则会发生堵塞，直至消息队列中出现符和要求的消息后并读取它
 */
#ifndef _MESSAGE_H_
#define _MESSAGE_H_

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<stdio.h>
#include<string.h>

#define PATHNAME "."
#define PRO_ID 0x6666

/*
 * type定义的值必须大于0
 */
#define SERVICE_TYPE 1
#define CLIENT_TYPE 2

struct msg_buf
{
  long type;
  char date[1024];
};

int CreatMsg();//创建消息队列，成功返回消息队列msgid,失败返回-1
int DestoryMsg(const int msgid);//删除消息队列，成功返回0，失败返回-1
int OpenMsg();//打开消息队列，打开成功返回消息队列msgid,失败返回-1
int SendMsg(int msgid,long who ,char* msg);//向消息队列发消息
int RecMsg(int msgid, long who,char msg[]);//从消息队列接受消息，成功返回0，并将消息写入msg，失败返回-1
#endif

//message.c
#include"./message.h"//使用时需确保头文件与message.c文件在同一级目录下

int CreatMsg()//创建消息队列,成功返回消息队列msgid,失败返回-1
{
  umask(0);
  return msgget(ftok(PATHNAME, PRO_ID),IPC_CREAT | IPC_SET | 0666);
}

int OpenMsg()//打开消息队列
{
  return msgget(ftok(PATHNAME, PRO_ID),IPC_CREAT);
}

int SendMsg(int msgid,long who ,char* msg)
{
  struct msg_buf buf;
  buf.type = who;
  strcpy(buf.date, msg);
  if(0 > msgsnd(msgid, (void*)&buf,sizeof(buf.date),0))
  {
    perror("msgsnd");
    return -1;
  }
  return 0;
}

int RecMsg(int msgid, long who, char  msg[])//从消息队列接受消息
{
  struct msg_buf buf;
  buf.type = who;
  printf("Please wait...\n");
  if(-1 == msgrcv(msgid, (void*)&buf, sizeof(buf.date), buf.type,0))
  {
    return -1;
  }
  strcpy(msg, buf.date);
  return 0;
}

int DestoryMsg(const int msgid)//删除消息队列，成功返回0，失败返回-1
{
  return msgctl(msgid, IPC_RMID, NULL);
}

通过封装好的消息队列接口实现client&service互相通信

service.c & client.c 需要和头文件在同一级目录下

目录结构

$ ls
service.c client.c message.c message.h Makefile
$ cat Makefile
.PHONY:all
all:service client
service:service.c message.c
	gcc $^ -o $@
client:client.c message.c
	gcc $^ -o $@
	
.PHONY:clean
clean:
	rm -f service client

//service.c
#include"./message.h"

int main()
{
  int msgid;
  char rec_msg[1024] = {0};
  char msg[1024] ={0};
  if(-1 != (msgid = CreatMsg()))
  {
    printf("CreatMsg success...\n");
  }
  if(-1 != (msgid = OpenMsg()))
  {
    printf("OpenMsg success...\n");
  } 
  while(1)
  {
    RecMsg(msgid, CLIENT_TYPE, rec_msg);
    if(0 == strcmp(rec_msg, "quit\n"))
    {
      printf("quit signal,Bye...\n");
      break;
    }
    printf("client$ %s",rec_msg);
    memset(rec_msg, 0, sizeof(rec_msg));

    printf("service# ");
    fflush(stdout);
    memset(msg, 0, sizeof(msg));
    fgets(msg, sizeof(msg), stdin);
    SendMsg(msgid, SERVICE_TYPE, msg);
  }

  DestoryMsg(msgid);
  return 0;
}

//client.c
#include"./message.h"

int main()
{
  int msgid;
  char msg[1024] = {0};
  char rec_msg[1024] = {0};
  if(-1 != (msgid = OpenMsg()))
  {
    printf("OpenMsg success...\n");
  }
  while(1)
  {
    printf("client# ");
    fflush(stdout);
    memset(msg, 0, sizeof(msg));
    fgets(msg, sizeof(msg), stdin);
    SendMsg(msgid, CLIENT_TYPE, msg);
    if(0 == strcmp(msg, "quit\n"))
    {
      printf("Bye...\n");
      break;
    }

    RecMsg(msgid, SERVICE_TYPE, rec_msg);

    printf("service# %s", rec_msg);
    memset(rec_msg, 0, sizeof(rec_msg));
  }
  return 0;
}

共享内存

共享内存的本质是不同的进程看到同一块物理内存。共享内存就是先在物理内存上开辟一段空间，再通过进程的页表映射进进程的虚拟内存空间。
共享内存同时映射进两个进程的虚拟内存空间，他们各自在虚拟内存空间上的地址可能不相同，但是他们的确会指向同一块物理内存。
共享内存是进程间通信最快的方式。
共享内存的生命周期跟随内核。
- ipcs -m：可以查看目前系统中存在的共享内存
- ipcrm -m shmid：删除共享内存（通过shmid指定）
共享内存没有提供互斥与同步机制，需要自己手动维护。

共享内存数据结构

struct shmid_ds {
 struct ipc_perm shm_perm; /* operation perms */
 int shm_segsz; /* size of segment (bytes) */
 __kernel_time_t shm_atime; /* last attach time */
 __kernel_time_t shm_dtime; /* last detach time */
 __kernel_time_t shm_ctime; /* last change time */
 __kernel_ipc_pid_t shm_cpid; /* pid of creator */
 __kernel_ipc_pid_t shm_lpid; /* pid of last operator */
 unsigned short shm_nattch; /* no. of current attaches */
 unsigned short shm_unused; /* compatibility */
 void *shm_unused2; /* ditto - used by DIPC */
 void *shm_unused3; /* unused */
};

可以看出，共享内存也为IPC资源。

接口

//创建共享内存
#include<sys/ipc.h>
#include<sys/shm.h>

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

key：共享内存段的名字。
size：所想要申请的共享内存的空间大小
- 一般必须为页（1页=4KB）的整数倍
- 如果此处size = 4097（字节），那么操作系统会分配2页（4096 * 2字节）的空间用于该共享内存，但是用户只可以使用4097字节的空间大小，这样就会造成空间的浪费。
shmflg：由九个权限标志构成，用法与创建文件时使用的mode模式标志是一样的
返回值：成功返回共享内存标识码（shmid）；失败返回-1

//将创建好的共享内存传递给进程
#include<sys/types.h>
#include<sys/shm.h>

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

shmid：共享内存的标识码（即为shmget成功返回值）。
shmaddr：指定连接的地址，即指定该进程虚拟内存中的shmaddr地址与实际物理内存中的共享内存连接
- shmaddr为NULL时，内核自动分配地址
- shmaddr不为NULL时：
  - shmflg无SHM_RND标记，则以shmaddr为连接地址
  - shmflg有SHM_RND标记，则连接地址会自动向下调整为SHMLBA的整数倍；公式：shmaddr-(shmaddr%SHNLBA)
shmflg：两个可能取值为SHM_RND和SHM_RDONLY
- shmflg = SHM_RDONLY表示连接操作用来只读共享内存
返回值：成功返回一个指针，指向共享内存；失败返回-1

//将共享内存与当前进程脱离，不会删除共享内存
#include<sys/types.h>
#include<sys/shm.h>

int shmdt(void* shmaddr);

shmaddr：指向共享内存的指针
返回值：成功返回0；失败返回-1

//删除共享内存
#include<sys/ipc.h>
#include<sys/shm.h>

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

shmid：共享内存标识码
cmd：表示要对共享内存做的操作（有3个可取值）
- IPC_STAT：把shmid_ds结构中的数据设置为共享内存的当前关联值
- IPC_SET：在进程有足够权限的前提下，把共享内存的当前关联值设置为shmid_ds数据结构中给出的值
- IPC_RMID：删除共享内存段

封装共享内存接口

//shared_mem.h
/*
 * 封装共享内存接口
 */

#ifndef _SHARED_MEM_H_
#define _SHARED_MEM_H_

#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>

#define PATHNAME "."
#define PRO_ID 0x6666

int CreatShm(size_t size);
int DestoryShm(int shmid);
int GetShm(int size);
void* LinkShm(int size);
int CutShm(const void* shmaddr);


#endif

//shared_mem.c
//确保头文件shared_mem.h与该文件在同一级目录下

#include"./shared_mem.h"

int CreatShm(size_t size)
{
  umask(0);
  return shmget(ftok(PATHNAME, PRO_ID), size, IPC_CREAT | IPC_EXCL | 0644);
}

int DestoryShm(int shmid)
{
  return shmctl(shmid, IPC_RMID, NULL);
}

int GetShm(int size)
{
  return shmget(ftok(PATHNAME, PRO_ID), size, IPC_CREAT);
}
void* LinkShm(int shmid)
{
  return shmat(shmid, NULL, 0);
}
int CutShm(const void* shmaddr)
{
    return shmdt(shmaddr);
}

使用封装好的接口来验证共享内存

运行时service进程先运行，client后运行