进程通讯

参考博客：https://www.jianshu.com/p/c1015f5ffa74

进程间通信的概念

每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）

进程间通信的7种方式

管道/匿名管道(pipe)

管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。

只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程);

单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。

数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

管道的实质：
管道的实质是一个内核缓冲区，进程以先进先出的方式从缓冲区存取数据，管道一端的进程顺序的将数据写入缓冲区，另一端的进程则顺序的读出数据。

该缓冲区可以看做是一个循环队列，读和写的位置都是自动增长的，不能随意改变，一个数据只能被读一次，读出来以后在缓冲区就不复存在了。

当缓冲区读空或者写满时，有一定的规则控制相应的读进程或者写进程进入等待队列，当空的缓冲区有新数据写入或者满的缓冲区有数据读出来时，就唤醒等待队列中的进程继续读写。

管道的局限：
管道的主要局限性正体现在它的特点上：

• 只支持单向数据流；
• 只能用于具有亲缘关系的进程之间；
• 没有名字；
• 管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
• 管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；

管道实践(C++)

#include <iostream>
#include <unistd.h>
int main()
{
    int fds[2]; 		//2个元素的int类型的数组，filedes[0]读端、filedes[1]写端。
    int len;
    char buf[100]={};// 缓冲区
    if(pipe(fds)==-1) //创建管道
        perror("pipe"),exit(1);
    while(fgets(buf,100,stdin)) //把输入先读入buf当中
    {
        len = strlen(buf);							//求出buf中字符串的长度
        if(write(fds[1],buf,len)==-1) 	//把内容写进管道
            perror("write"),exit(1);		
        memset(buf,0x00,sizeof(char)*100);//把buf缓存初始化掉
        if(read(fds[0],buf,len)==-1) 		//再从管道里面读取内容到数组中
            perror("read"),exit(1);			
        if(write(STDOUT_FILENO,buf,len)==-1) 				//把从管道里读出的内容写到标准输出
            perror("write"),exit(1);
    }
    return 0;
}

父子进程之间的管道通讯：

int main(int argc,char* argv[])
{
    pid_t pid;

    int fd[2];//定义管道的读、写端文件描述符
    int ret;

    char* str = "hello pipe\n";//指定写数据
    char buf[1024];//定义接收缓冲区
    ret = pipe(fd);//调用pipe()函数就已将管道打开

    if(ret == -1)
    {
        perror("pipe error");
        exit(1);
    }

    pid = fork();	// fork子进程

    if(pid > 0)//父进程
    {
        close(fd[0]);
        write(fd[1],str,strlen(str));//写到管道中
        close(fd[1]);
    }
    else if(pid == 0)//子进程
    {
        close(fd[1]);
        ret = read(fd[0],buf,sizeof(buf));//从管道中的读，返回读到的字节数
        write(STDOUT_FILENO,buf,ret);//写到标准输出
        close(fd[0]);
    }

    return 0;
}

有名管道(FIFO)

匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道(FIFO)。

有名管道不同于匿名管道之处在于它提供了一个路径名与之关联，以有名管道的文件形式存在于文件系统中，这样，即使与有名管道的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过有名管道相互通信，因此，通过有名管道不相关的进程也能交换数据。值的注意的是，有名管道严格遵循先进先出(first in first out),对匿名管道及有名管道的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。有名管道的名字存在于文件系统中，内容存放在内存中。

匿名管道和有名管道总结：
（1）管道是特殊类型的文件，在满足先入先出的原则条件下可以进行读写，但不能进行定位读写。
（2）匿名管道是单向的，只能在有亲缘关系的进程间通信；有名管道以磁盘文件的方式存在，可以实现本机任意两个进程通信。
（3）无名管道阻塞问题：无名管道无需显示打开，创建时直接返回文件描述符，在读写时需要确定对方的存在，否则将退出。如果当前进程向无名管道的一端写数据，必须确定另一端有某一进程。如果写入无名管道的数据超过其最大值，写操作将阻塞，如果管道中没有数据，读操作将阻塞，如果管道发现另一端断开，将自动退出。
（4）有名管道阻塞问题：有名管道在打开时需要确实对方的存在，否则将阻塞。即以读方式打开某管道，在此之前必须一个进程以写方式打开管道，否则阻塞。此外，可以以读写（O_RDWR）模式打开有名管道，即当前进程读，当前进程写，不会阻塞。

信号(Signal)

• 信号是Linux系统中用于进程间互相通信或者操作的一种机制，信号可以在任何时候发给某一进程，而无需知道该进程的状态。
• 如果该进程当前并未处于执行状态，则该信号就有内核保存起来，知道该进程回复执行并传递给它为止。
• 如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消是才被传递给进程。

Linux系统中常用信号：

（1）SIGHUP：用户从终端注销，所有已启动进程都将收到该进程。系统缺省状态下对该信号的处理是终止进程。
（2）SIGINT：程序终止信号。程序运行过程中，按Ctrl+C键将产生该信号。
（3）SIGQUIT：程序退出信号。程序运行过程中，按Ctrl+\\键将产生该信号。
（4）SIGBUS和SIGSEGV：进程访问非法地址。
（5）SIGFPE：运算中出现致命错误，如除零操作、数据溢出等。
（6）SIGKILL：用户终止进程执行信号。shell下执行kill -9发送该信号。
（7）SIGTERM：结束进程信号。shell下执行kill 进程pid发送该信号。
（8）SIGALRM：定时器信号。
（9）SIGCLD：子进程退出信号。如果其父进程没有忽略该信号也没有处理该信号，则子进程退出后将形成僵尸进程。

信号来源

信号是软件层次上对中断机制的一种模拟，是一种异步通信方式，信号可以在用户空间进程和内核之间直接交互，内核可以利用信号来通知用户空间的进程发生了哪些系统事件，信号事件主要有两个来源：

• 硬件来源：用户按键输入Ctrl+C退出、硬件异常如无效的存储访问等。
• 软件终止：终止进程信号、其他进程调用kill函数、软件异常产生信号。

信号生命周期和处理流程

1. 信号被某个进程产生，并设置此信号传递的对象（一般为对应进程的pid），然后传递给操作系统；

2. 操作系统根据接收进程的设置（是否阻塞）而选择性的发送给接收者，如果接收者阻塞该信号（且该信号是可以阻塞的），操作系统将暂时保留该信号，而不传递，直到该进程解除了对此信号的阻塞（如果对应进程已经退出，则丢弃此信号），如果对应进程没有阻塞，操作系统将传递此信号。

3. 目的进程接收到此信号后，将根据当前进程对此信号设置的预处理方式，暂时终止当前代码的执行，保护上下文（主要包括临时寄存器数据，当前程序位置以及当前CPU的状态）、转而执行中断服务程序，执行完成后在回复到中断的位置。当然，对于抢占式内核，在中断返回时还将引发新的调度。

信号实践(C++)

#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
int main(void)
{
    pid_t childpid;
    int status;
    int retval;

    childpid = fork();  // 创建子进程
    if (-1 == childpid)  //判断是否创建失败
    {
        perror("fork()");
        exit(EXIT_FAILURE);
    }
    else if (0 == childpid)// 子进程创建成功
    {
        puts("In child process");
        sleep(1000); //让子进程睡眠，以便父进程查看其行为
        exit(EXIT_SUCCESS);
    }
    else
    {
        if (0 == (waitpid(childpid, &status, WNOHANG))) //判断子进程是否已经退出
        {
          //发送SIGKILL给子进程，要求其停止运行。成功返回0，不成功就返回-1；
            retval = kill(childpid, SIGKILL);  

            if (retval)   //判断是否发生信号，
            {
                puts("kill failed.");
                perror("kill");
                waitpid(childpid, &status, 0);
            }
            else
                printf("%d killed\n", childpid);
        }
    }

    exit(EXIT_SUCCESS);
}

输出：

55382 killed

消息队列

消息(Message)队列

• 消息队列是存放在内核中的消息链表，每个消息队列由消息队列标识符表示。
• 与管道（无名管道：只存在于内存中的文件；命名管道：存在于实际的磁盘介质或者文件系统）不同的是消息队列存放在内核中，只有在内核重启(即，操作系统重启)或者显示地删除一个消息队列时，该消息队列才会被真正的删除。
• 另外与管道不同的是，消息队列在某个进程往一个队列写入消息之前，并不需要另外某个进程在该队列上等待消息的到达。

消息队列特点总结：

1. 消息队列是消息的链表,具有特定的格式,存放在内存中并由消息队列标识符标识.
2. 消息队列允许一个或多个进程向它写入与读取消息.
3. 管道和消息队列的通信数据都是先进先出的原则。
4. 消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取.比FIFO更有优势。
5. 消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺。
6. 目前主要有两种类型的消息队列：POSIX消息队列以及System V消息队列，System V消息队列目前被大量使用。System V消息队列是随内核持续的，只有在内核重起或者人工删除时，该消息队列才会被删除。

共享内存(share memory)

原理

在CSAPP虚拟内存这篇博客中，我们学习到虚拟内存可以简化共享。例如，每个进程必须调用相同的操作系统内核代码，而每个C 程序都会调用C 标准库中的程序，比如 printf() . 操作系统通过将不同进程中适当的虚拟页面映射到相同的物理页面，从而安排多个进程共享这部分代码的一个副本，而不是在每个进程中都包括单独的内核和C标准库的副本

那么，将共享内存用来进程之间的通讯，以传送数据为目的，显然这是进程通信中速度最快的一种方式（例：进程一向共享内存传送数据，进程二能够立马看见传送的数据，少了若干次拷贝）

为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间。进程就可以直接读写这一块内存而不需要进行数据的拷贝，从而大大提高效率

共享内存生命周期跟随内核，共享没有自带同步或互斥，由用户来维护共享内存。因此，信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问

共享内存的优缺点

1、优点：我们可以看到使用共享内存进行进程间的通信真的是非常方便，而且函数的接口也简单，数据的共享还使进程间的数据不用传送，而是直接访问内存，也加快了程序的效率。同时，它也不像匿名管道那样要求通信的进程有一定的父子关系。

2、缺点：共享内存没有提供同步的机制，这使得我们在使用共享内存进行进程间通信时，往往要借助其他的手段来进行进程间的同步工作。(如信号量)

共享内存接口

在C++中，有关于和共享内存的库是#include <sys/shm.h>，里面有对共享内存的方法：

共享内存的创建：

#include <sys/ipc.h>
#include <sys/shm.h>
//如果共享内存不存在，创建共享内存，如果存在就打开共享内存
int shmget(key_t key, size_t size, int shmflg);
//返回值：成功返回共享内存的标识符，失败返回-1

参数：共享内存的关键字key

共享内存的标识符，获取方法和消息队列 key的方法一致，也可认为key就是共享内存的名字

参数：共享内存的大小size：

由你自己指定，一般指定为4k的倍数（内存4k为一页）

参数：共享内存的访问权限shmflg

共享内存的权限，它与文件的访问权限一样
IPC_CREAT:创建新的共享内存。

IPC_EXCL:与IPC_CREAT一同使用，表示如果要创建的共享内存已经存在，则返回错误。

IPC_NOWAIT:读写共享内存要求无法满足时，不阻塞

0：如果是打开文件，即文件已存在，写0

共享内存的挂载

共享内存的挂载

#include <sys/types.h>
#include <sys/shm.h>
//将共享内存链接到进程地址空间
void *shmat(int shmid, const void *shmaddr, int shmflg);
//返回值：失败返回NULL,成功返回一个指针，为地址空间的虚拟地址，并且连接数加1（nattch）

参数：共享内存的标识符shmid

shmget的返回值

参数：指定连接进程地址空间的地址shmaddr

共享存储段连接到调用进程的哪个地址上与addr参数以及在flag中是否指定SHM_RND位有关

如果addr为0，则此段连接到由内核选择的第一个可用地址上。这是推荐的使用方式。

如果addr非0，并且没有指定SHM_RND，则此段连接到addr所指定的地址上。

如果addr非0,并且指定了SHM_ RND，则此段连接到（shmaddr -（shmaddr % SHMLBA））所表示的地址上。SHM_RND命令的意思是取整。SHMLBA的意思是低边界地址倍数，它总是2的乘方。该算式是将地址向下取最近1个SHMLBA的倍数。

注：除非只计划在一种硬件上运行应用程序（这在当今是不大可能的），否则不应指定共享段所连接到的地址。所以一般应指定addr为0，以便由内核选择地址

参数：共享内存的权限shmflg

shmflg = SHM_RDONLY，表示连接操作作用来只读共享内存

共享内存的卸载

#include <sys/types.h>
#include <sys/shm.h>
//将共享内存与当前连接进程脱离
int shmdt(const void* shmaddr)
//返回值：成功返回0,失败返回-1
//参数：由shmat返回的指针
//注意：将共享内存与进程脱离不等于删除共享内存

共享内存的控制

#include <sys/ipc.h>
#include <sys/shm.h>
//shmctl系统调用对shmid标识的共享内存执行cmd操作
//返回值：成功返回0，失败返回-1
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

参数：共享内存的表示符shmid

shmget的返回值

参数：将要采取的操作cmd

选项 说明
IPC_STAT 把shmid_ds结构中的数据设置为共享内存的当前关联值

IPC_SET 在进程有足够权限的前提下，把共享内存的当前关联值设置为shmid_ds数 据结构中给出的值

IPC_RMID 删除共享内存

参数：保存共享内存的模式状态和访问权限的数据结构buf

共享内存的一些属性，填NULL

封装API

我们要利用它封装一些自己的API，让其对用户操作友好

• int commShm(int size,int flags)

static int commShm(int size, int flags) //创建共享内存
{
  	//利用 ftok获取key值，用来申请共享内存
    key_t key = ftok(PATHNAME, PROJ_ID);
    if (key < 0)
    {
        perror("ftok");
        return -1;
    }
    int shmid = shmget(key, size, flags);
    if (shmid < 0)
    {
        perror("shmget");
        return -2;
    }
    return shmid;
}

• int createShm (int size)

int createShm(int size)
{
    return commShm(size, IPC_CREAT | IPC_EXCL);
}

• int getShm(int size)//获取共享内存

int getShm(int size)//获取共享内存
{
		return commShm(size, IPC_CREAT);
}

• int destoryShm(int shmid)

int destoryShm(int shmid) //销毁共享内存
{
    if (shmctl(shmid, IPC_RMID, NULL) < 0)
    {
        perror("shmctl");
        return -3;
    }
}

server进程

#include "comm.h"
int main()
{
    int shmid = createShm(4096);                //创建共享内存
    char *addr = (char *)shmat(shmid, NULL, 0); //将共享内存进行挂接
    int i = 0;
    while (i++ < 26)
    {
     //每次都输出 共享内存中的数据
        printf("client：%s\n", addr);
        sleep(1);
    }
    shmdt(addr); //删除共享内存
    sleep(1);
    destoryShm(shmid);//卸载共享内存
    return 0;
}

client进程

#include "comm.h"
int main()
{
    int shmid = getShm(0);                      //创建共享内存
    char *addr = (char *)shmat(shmid, NULL, 0); //将共享内存进行挂接
    int i = 0;
    while (i < 26)
    {
  			addr[i] = 'A'+i;
        i++;
        addr[i] = 0;
        printf("writing to shared memory: %s\n", addr);
        sleep(1);
    }
    shmdt(addr); //删除共享内存
    return 0;
}

编译后如下：

在进程运行期间，我们通过ipcs -m观察挂载的共享内存，如下所示

• 这块共想内存的拥有者是root
• 大小为4096byte
• 当前连接了两个进程

信号量(semaphore)

信号量是一个计数器，用于多进程对共享数据的访问，信号量的意图在于进程间同步。
为了获得共享资源，进程需要执行下列操作：

1. 创建一个信号量：这要求调用者指定初始值，对于二值信号量来说，它通常是1，也可是0。
2. 等待一个信号量：该操作会测试这个信号量的值，如果小于0，就阻塞。也称为P操作。
3. 挂出一个信号量：该操作将信号量的值加1，也称为V操作。

为了正确地实现信号量，信号量值的测试及减1操作应当是原子操作。为此，信号量通常是在内核中实现的。Linux环境中，有三种类型：Posix（可移植性操作系统接口）有名信号量（使用Posix IPC名字标识）、Posix基于内存的信号量（存放在共享内存区中）、System V信号量（在内核中维护）。这三种信号量都可用于进程间或线程间的同步。

信号量与普通整型变量的区别：
（1）信号量是非负整型变量，除了初始化之外，它只能通过两个标准原子操作：wait(semap) , signal(semap) ; 来进行访问；
（2）操作也被成为PV原语（P来源于荷兰语proberen”测试”，V来源于荷兰语verhogen”增加”，P表示通过的意思，V表示释放的意思），而普通整型变量则可以在任何语句块中被访问；

信号量与互斥量之间的区别：
（1）互斥量用于线程的互斥，信号量用于线程的同步。这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。
互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。
在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源
（2）互斥量值只能为0/1，信号量值可以为非负整数。
也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。
（3）互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。

套接字(socket)

套接字是一种通信机制，凭借这种机制，客户/服务器（即要进行通信的进程）系统的开发工作既可以在本地单机上进行，也可以跨网络进行。也就是说它可以让不在同一台计算机但通过网络连接计算机上的进程进行通信。

套接字是支持TCP/IP的网络通信的基本操作单元，可以看做是不同主机之间的进程进行双向通信的端点，简单的说就是通信的两方的一种约定，用套接字中的相关函数来完成通信过程。

套接字特性

套接字的特性由3个属性确定，它们分别是：域、端口号、协议类型。

1. 套接字的域

   它指定套接字通信中使用的网络介质，最常见的套接字域有两种：

   一是AF_INET，它指的是Internet网络。当客户使用套接字进行跨网络的连接时，它就需要用到服务器计算机的IP地址和端口来指定一台联网机器上的某个特定服务，所以在使用socket作为通信的终点，服务器应用程序必须在开始通信之前绑定一个端口，服务器在指定的端口等待客户的连接。

   另一个域AF_UNIX，表示UNIX文件系统，它就是文件输入/输出，而它的地址就是文件名。

2. 套接字的端口号

   每一个基于TCP/IP网络通讯的程序(进程)都被赋予了唯一的端口和端口号，端口是一个信息缓冲区，用于保留Socket中的输入/输出信息，端口号是一个16位无符号整数，范围是0-65535，以区别主机上的每一个程序（端口号就像房屋中的房间号），低于256的端口号保留给标准应用程序，比如pop3的端口号就是110，每一个套接字都组合进了IP地址、端口，这样形成的整体就可以区别每一个套接字

3. 套接字协议类型

   因特网提供三种通信机制，

   • 流套接字，流套接字在域中通过TCP/IP连接实现，同时也是AF_UNIX中常用的套接字类型。流套接字提供的是一个有序、可靠、双向字节流的连接，因此发送的数据可以确保不会丢失、重复或乱序到达，而且它还有一定的出错后重新发送的机制。
   • 数据报套接字，它不需要建立连接和维持一个连接，它们在域中通常是通过UDP/IP协议实现的。它对可以发送的数据的长度有限制，数据报作为一个单独的网络消息被传输,它可能会丢失、复制或错乱到达，UDP不是一个可靠的协议，但是它的速度比较高，因为它并一需要总是要建立和维持一个连接。
   • 原始套接字，原始套接字允许对较低层次的协议直接访问，比如IP、 ICMP协议，它常用于检验新的协议实现，或者访问现有服务中配置的新设备，因为RAW SOCKET可以自如地控制Windows下的多种协议，能够对网络底层的传输机制进行控制，所以可以应用原始套接字来操纵网络层和传输层应用。比如，我们可以通过RAW SOCKET来接收发向本机的ICMP、IGMP协议包，或者接收TCP/IP栈不能够处理的IP包，也可以用来发送一些自定包头或自定协议的IP包。网络监听技术很大程度上依赖于SOCKET_RAW。

服务器端

1. 首先服务器应用程序用系统调用socket来创建一个套接字，它是系统分配给该服务器进程的类似文件描述符的资源，它不能与其他的进程共享。
2. 然后，服务器进程会给套接字起个名字，我们使用系统调用bind来给套接字命名。然后服务器进程就开始等待客户连接到这个套接字。
3. 接下来，系统调用listen来创建一个队列并将其用于存放来自客户的进入连接。
4. 最后，服务器通过系统调用accept来接受客户的连接。它会创建一个与原有的命名套接不同的新套接字，这个套接字只用于与这个特定客户端进行通信，而命名套接字（即原先的套接字）则被保留下来继续处理来自其他客户的连接（建立客户端和服务端的用于通信的流，进行通信）。

客户端

（1）客户应用程序首先调用socket来创建一个未命名的套接字，然后将服务器的命名套接字作为一个地址来调用connect与服务器建立连接。
（2）一旦连接建立，我们就可以像使用底层的文件描述符那样用套接字来实现双向数据的通信（通过流进行数据传输）。