进程间的通信

进程间的通信
目录

一.进程间通信的介绍

1.1通信的目的

1.2进程间通信的分类

二.匿名管道

2.1概念

2.1.2使用步骤

2.2管道读写规则

2.3特点

2.4多进程派发任务的实现

2.5管道大小

三.命名管道

3.1概念

3.2命名管道的打开规则

3.3命名管道演示

3.3.1用命名管道实现serve&client通信

3.3.2用命名管道实现进程控制

3.4命名管道和匿名管道的区别

3.5命令行中的管道

四.system V进程间通信

4.1system V共享内存

4.1.1共享内存的建立与释放

4.1.2创建

4.1.3释放

4.1.4关联

4.1.5去关联

4.1.6用共享内存实现serve&client通信

4.1.7共享内存与管道进行对比

五.消息队列

六.System V信号量

一.进程间通信的介绍

概念：进程间通信简称IPC（Interprocess communication），进程间通信就是在不同进程之间传播或交换信息。

1.1通信的目的

数据传输：一个进程需要将它的数据发送给另一个进程。
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件，比如进程终止时需要通知其父进程。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

本质就是让不同的进程可以看到同一份资源。

每个进程都是独立的，各个进程之间若想实现通信，一定要借助第三方资源，这些进程就可以通过向这个第三方资源写入或是读取数据，进而实现进程之间的通信，这个第三方资源实际上就是操作系统提供的一段内存区域。

1.2进程间通信的分类

管道
- 匿名管道
- 命名管道
System V IPC
- System V 消息队列
- System V 共享内存
- System V 信号量
POSIX IPC
- 消息队列
- 共享内存
- 信号量
- 互斥量
- 条件变量
- 读写锁
二.匿名管道

管道是Unix中最古老的进程间通信的形式，我们把从一个进程连接到另一个进程的数据流称为一个“管道”。

2.1概念

匿名管道用于进程间通信，但仅限于本地父子进程之间的通信。使用匿名管道通信，可以让父子进程看到同一份资源，父子进程可以对其进行读写操作，从而实现通信。

如图：

补充：

1.这里父子进程看到的同一份资源是由操作系统维护的，父子进程对其进行读写操作时不会发生写时拷贝。

2.管道虽然用的是文件的方案，但操作系统不会把进程进行通信的数据刷新到磁盘当中，因为这样做有IO参与会降低效率。也就是说，这种文件是一批不会把数据写到磁盘当中的文件，换句话说，磁盘文件和内存文件不一定是一一对应的，有些文件只会在内存当中存在，而不会在磁盘当中存在。

创建匿名管道的函数：
```
int pipe(int pipefd[2]);
```
解释：pipe函数的参数是一个输出型参数，数组pipefd用于返回两个指向管道读端和写端的文件描述符。函数调用成功返回0，失败返回-1。

数组元素含义
pipefd[0] 管道读端的文件描述符
pipefd[1] 管道写端的文件描述符

2.1.2使用步骤

创建匿名管道实现父子进程间通信的过程中，需要pipe函数和fork函数搭配使用.

例如：

1.先由父进程调用pipe函数，创建管道。

2.父进程在创建子进程。

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

也可站在文件描述的角度来看待：

用代码进行演示：
```
#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
	int fd[2] = { 0 };
	if (pipe(fd) < 0){ //使用pipe创建匿名管道
		perror("pipe");
		return 1;
	}
	pid_t id = fork(); //使用fork创建子进程
	if (id == 0)
	{
	close(fd[0]); //子进程关闭读端
    char arr[20]="hello world";
		for(int i=0;i<5;i++)
		{	write(fd[1], arr, strlen(arr));	//子进程向管道写入数据
			sleep(1);
		}
		close(fd[1]); //子进程写入完毕，关闭文件
		exit(0);
	}
	close(fd[1]); //父进程关闭写端
	char buff[64];
	while (true)
	{
		ssize_t s = read(fd[0], buff, sizeof(buff));//父进程从管道读取数据
		if (s > 0){
			buff[s] = '\0';
			printf("child send to father:%s\n", buff);
            buff[0]='\0'
		}
		else if (s == 0){
			printf("read file end\n");
			break;
		}
		else{
			printf("read error\n");
			break;
		}
	}
    int status=0;
	close(fd[0]); //父进程读取完毕，关闭文件
    pid_t ret=waitpid(id,&status,0);
    if(ret>0)
    {
       printf("wait success, ret : %d, 我所等待的子进程的退出码: %d, 退出信号是: %d\n", 
                   ret, (status>>8)&0xFF, status&0x7F);
    }
	return 0;
}
```
结果：

2.2管道读写规则

pipe2函数：int pipe2(int pipefd[2], int flags);

解释：

pipe2函数的第二个参数用于设置选项。

1、当没有数据可读时：

O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来为止。
O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
2、当管道满的时候：

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

2.3特点

1.管道内部自带同步与互斥机制。

我们将一次只允许一个进程使用的资源，称为临界资源。管道在同一时刻只允许一个进程对其进行写入或是读取操作，因此管道也就是一种临界资源。

2.管道生命周期随进程结束而结束。

管道本质上是通过文件进行通信的，也就是说管道依赖于文件系统，那么当所有打开该文件的进程都退出后，该文件也就会被释放掉，所以说管道的生命周期随进程。

3.管道提供的是流式服务。

一个进程从管道取走的数据是任意的，这种被称为流式服务。

数据报服务：数据有明确的分割，拿数据按报文段。

4.管道是半双工通信

在数据通信中，数据在线路上的传送方式可以分为以下三种：

单工通信(Simplex Communication)：单工模式的数据传输是单向的。通信双方中，一方固定为发送端，另一方固定为接收端。
半双工通信(Half Duplex)：半双工数据传输指数据可以在一个信号载体的两个方向上传输，但是不能同时传输。
全双工通信(Full Duplex)：全双工通信允许数据在两个方向上同时传输，它的能力相当于两个单工通信方式的结合。全双工可以同时(瞬时)进行信号的双向传输。例如：

管道的四种特殊情况：

1.写端进程不写，读端进程一直读，那么此时会因为管道里面没有数据可读，对应的读端进程会被挂起，直到管道里面有数据后，读端进程才会被唤醒。
2.读端进程不读，写端进程一直写，那么当管道被写满后，对应的写端进程会被挂起，直到管道当中的数据被读端进程读取后，写端进程才会被唤醒。
3.写端进程将数据写完后将写端关闭，那么读端进程将管道当中的数据读完后，就会继续执行该进程之后的代码逻辑，而不会被挂起。
4.读端进程将读端关闭，而写端进程还在一直向管道写入数据，那么操作系统会将写端进程杀掉。

这里对第四种情况代码演示：
```
int main()
{
	int fd[2] = { 0 };
	if (pipe(fd) < 0){ //使用pipe创建匿名管道
		perror("pipe");
		return 1;
	}
	pid_t id = fork(); //使用fork创建子进程
	if (id == 0)
	{
	close(fd[0]); //子进程关闭读端
    char arr[20]="hello world";
		for(int i=0;i<5;i++)
		{	write(fd[1], arr, strlen(arr));	//子进程向管道写入数据
			sleep(1);
		}
		close(fd[1]); //子进程写入完毕，关闭文件
		exit(0);
	}
	close(fd[1]); //父进程关闭写端
	char buff[64];
//	while (true)
//	{
//		ssize_t s = read(fd[0], buff, sizeof(buff));//父进程从管道读取数据
//		if (s > 0){
//			buff[s] = '\0';
//			printf("child send to father:%s\n", buff);
//      buff[0]='\0';
//		}
//		else if (s == 0){
//			printf("read file end\n");
//			break;
//		}
//		else{
//			printf("read error\n");
//			break;
//		}
//	}
    int status=0;
	close(fd[0]); //父进程读取完毕，关闭文件
    pid_t ret=waitpid(id,&status,0);
    if(ret>0)
    {
       printf("wait success, ret : %d, 我所等待的子进程的退出码: %d, 退出信号是: %d\n", 
                   ret, (status>>8)&0xFF, status&0x7F);
    }
	return 0;
}
```
与上面的代码一样，只是将父进程读写都关闭了。

看结果：

可知：当情况4发生时，操作系统会向子进程发送第13号信号，将其终止掉。

2.4多进程派发任务的实现
```
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
using namespace std;
 
typedef void (*functor)();
 
vector functors; // 方法集合
unordered_map<uint32_t, string> info;
 
void f1()
{
    cout << "这是一个处理日志的任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
}
void f2()
{
    cout << "这是一个备份数据任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
}
void f3()
{
    cout << "这是一个处理网络连接的任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
}
 
void loadFunctor()
{
    info.insert({functors.size(), "处理日志的任务"});
    functors.push_back(f1);
 
    info.insert({functors.size(), "备份数据任务"});
    functors.push_back(f2);
 
    info.insert({functors.size(), "处理网络连接的任务"});
    functors.push_back(f3);
}
 
typedef std::pair<int32_t, int32_t> elem;
int processNum = 5;
 
void work(int blockFd)//blockFd:子进程对应管道的fd，从fd读取任务序号(0,1,2)
{
    cout << "进程[" << getpid() << "]" << " 开始工作" << endl;
    while (true)
    {
        uint32_t operatorCode = 0;
        ssize_t s = read(blockFd, &operatorCode, sizeof(uint32_t));
        if(s == 0) 
          break;
        assert(s == sizeof(uint32_t));
        (void)s;
 
 
        if(operatorCode < functors.size()) 
           functors[operatorCode]();//子进程执行任务
    }
    cout << "进程[" << getpid() << "]" << " 结束工作" << endl;
}
 
// [子进程的pid, 子进程的管道fd]
void blanceSendTask(const vector &processFds)
{
    srand((long long)time(nullptr));
    int n=5;
    while(n--)
    {
        sleep(1);
       
        uint32_t pick = rand() % processFds.size();//随机选取一个子进程
        uint32_t task = rand() % functors.size();//随机选取一个任务
        write(processFds[pick].second, &task, sizeof(task));//向对应子进程的管道fd写入任务序号
 
        cout << "父进程指派任务->" << info[task] << "给进程: " << processFds[pick].first << " 编号: " << pick << endl;
    }
}
 
int main()
{
    loadFunctor();
    vector assignMap;
    for (int i = 0; i < processNum; i++)
    {
 
        int pipefd[2] = {0};
        pipe(pipefd);//创建processNum个管道
        printf("创建管道成功，%d %d\n",pipefd[0],pipefd[1]);
        pid_t id = fork();//创建processNum个子进程
        if (id == 0)
        {
          
            close(pipefd[1]);//子进程关闭管道的写端
            work(pipefd[0]);//子进程工作代码
            close(pipefd[0]);//子进程关闭对应管道的读端
            exit(0);
        }
        close(pipefd[0]);//父进程关闭管道的读端
        elem e(id, pipefd[1]);//将子进程id和对应管道的写端描述符保存
        assignMap.push_back(e);
    }
    cout << "create all process success!" << std::endl;
    blanceSendTask(assignMap);//分派任务
 
    // 回收资源
    for(int i=0;i
    {
        close(assignMap[i].second);
        cout<<"关闭父进程对应文件描述符"<"成功"<
    }
   for(int i=0;i
    {      
       if (waitpid(assignMap[i].first, nullptr, 0) > 0)
         cout << "wait for: pid=" << assignMap[i].first << " wait success!"
             << "number: " << i << "\n";
    }
   
}
```
结果：
```
[LF@ecs-100710 lesson1]$ ./test
创建管道成功，3 4
创建管道成功，3 5
创建管道成功，3 6
创建管道成功，3 7
创建管道成功，3 8
create all process success!
进程[24382] 开始工作
进程[24383] 开始工作
进程[24379] 开始工作
进程[24380] 开始工作
进程[24381] 开始工作
父进程指派任务->处理网络连接的任务给进程: 24383 编号: 4
这是一个处理网络连接的任务, 执行的进程 ID [24383]执行时间是[1667992038]
 
父进程指派任务->备份数据任务给进程: 24381 编号: 2
这是一个备份数据任务, 执行的进程 ID [24381]执行时间是[1667992039]
 
父进程指派任务->处理网络连接的任务给进程: 24382 编号: 3
这是一个处理网络连接的任务, 执行的进程 ID [24382]执行时间是[1667992040]
 
父进程指派任务->处理网络连接的任务给进程: 24382 编号: 3
这是一个处理网络连接的任务, 执行的进程 ID [24382]执行时间是[1667992041]
 
父进程指派任务->备份数据任务给进程: 24383 编号: 4
关闭父进程对应文件描述符4成功
关闭父进程对应文件描述符5成功
关闭父进程对应文件描述符6成功
关闭父进程对应文件描述符7成功
关闭父进程对应文件描述符8成功
这是一个备份数据任务, 执行的进程 ID [24383]执行时间是[1667992042]
 
进程[24383] 结束工作
进程[24382] 结束工作
进程[24381] 结束工作
进程[24380] 结束工作
进程[24379] 结束工作
wait for: pid=24379 wait success!number: 0
wait for: pid=24380 wait success!number: 1
wait for: pid=24381 wait success!number: 2
wait for: pid=24382 wait success!number: 3
wait for: pid=24383 wait success!number: 4
 
```
2.5管道大小

管道的容量是有限的，如果管道满了。那么写端将阻塞或失败，那么管道的最大容量是多少?

代码测试：

结果：

在读端进程不读取的情况下，写端进程最多写65536字节的数据就被操作系统挂起，意思就是当前Linux版本中管道的最大容量为65536字节。也可用man手册去查看。

三.命名管道

3.1概念

概念：匿名管道只能用于具有共同祖先的进程（具有亲缘关系的进程）之间的通信，但若两个不相关之间的进程通信，可以使用命名管道来完成。命名管道就是一种特殊类型的文件，两个进程通过命名管道的文件名打开同一个管道文件，此时这两个进程也就看到了同一份资源，进而就可以进行通信了。命名管道和匿名管道一样，都是内存文件，只不过命名管道在磁盘有一个简单的映像，但这个映像的大小永远为0，因为命名管道和匿名管道都不会将通信数据刷新到磁盘当中。

int mkfifo(const char *pathname, mode_t mode);

参数解释：

mkfifo函数的第一个参数是pathname，表示要创建的命名管道文件。
- 若pathname以路径的方式给出，则将命名管道文件创建在pathname路径下。
- 若pathname以文件名的方式给出，则将命名管道文件默认创建在当前路径下。（注意当前路径的含义）
mkfifo函数的第二个参数是mode，表示创建命名管道文件的默认权限。会受到umask（文件默认掩码）的影响。

3.2命名管道的打开规则

1、如果当前打开操作是为读而打开FIFO时。

O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO。
O_NONBLOCK enable：立刻返回成功。

2、如果当前打开操作是为写而打开FIFO时。

O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO。
O_NONBLOCK enable：立刻返回失败，错误码为ENXIO。

3.3命名管道演示

3.3.1用命名管道实现serve&client通信

解释：实现服务端(server)和客户端(client)之间的通信之前，我们需要先让服务端运行起来，我们需要让服务端运行后创建一个命名管道文件，然后再以读的方式打开该命名管道文件，之后服务端就可以从该命名管道当中读取客户端发来的通信信息了。

代码示例：

共用头文件代码：
```
#include 
#include 
#include 
#include 
#include 
#include 
#define FILE_NAME "myfifo" //让客户端和服务端使用同一个命名管道
```
服务端代码：
```
#include "comm.h"
 
int main()
{
	umask(0); //将文件默认掩码设置为0
	if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
		perror("mkfifo");
		return 1;
	}
	int fd = open(FILE_NAME, O_RDONLY); //以读的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 2;
	}
	char msg[128];
	while (1){
		//从命名管道当中读取信息
		ssize_t s = read(fd, msg, sizeof(msg)-1);
		if (s > 0){
			msg[s] = '\0'; //手动设置'\0'，便于输出
			printf("client# %s\n", msg); //输出客户端发来的信息
		}
		else if (s == 0){
			printf("client quit!\n");
			break;
		}
		else{
			printf("read error!\n");
			break;
		}
	}
	close(fd); //通信完毕，关闭命名管道文件
  printf("客户端退出了，我服务端也退出了\n");
  unlink(FILE_NAME);
	return 0;
}
```
客户端代码：
```
#include "comm.h"
 
int main()
{
	int fd = open(FILE_NAME, O_WRONLY); //以写的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 1;
	}
	char msg[128];
	while (1){
		printf("Please Enter# "); //提示客户端输入
		fflush(stdout);
		//从客户端的标准输入流读取信息
		ssize_t s = read(0, msg, sizeof(msg)-1);
		if (s > 0){
			msg[s - 1] = '\0';
			//将信息写入命名管道
			write(fd, msg, strlen(msg));
		}
	}
	close(fd); //通信完毕，关闭命名管道文件
	return 0;
}
```
结果：

3.3.2用命名管道实现进程控制

只需要更改下客户端的代码即可：
```
       while (1){
		//从命名管道当中读取信息
		ssize_t s = read(fd, msg, sizeof(msg)-1);
		if (s > 0){
			msg[s] = '\0'; //手动设置'\0'，便于输出
			printf("client# %s\n", msg); //输出客户端发来的信息
      if (fork() == 0)
	  {
				//child
				execlp(msg, msg, NULL); //进程程序替换
				exit(1);
			}
			waitpid(-1, NULL, 0); //等待子进程
		}
```
结果：

3.4命名管道和匿名管道的区别
- 匿名管道由pipe函数创建并打开。
- 命名管道由mkfifo函数创建，由open函数打开。
- FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在于它们创建与打开的方式不同，一旦这些工作完成之后，它们具有相同的语义
3.5命令行中的管道

匿名管道只能用于有亲缘关系的进程之间的通信，而命名管道可以用于两个毫不相关的进程之间的通信，所以我们可以先看看命令行当中用管道（“|”）连接起来的各个进程之间是否具有亲缘关系。

它们的父进程都是25187，可知 | 是匿名管道。

四.system V进程间通信

概念：而system V IPC是操作系统特地设计的一种通信方式，本质也是让不同进程看到同一份资源。

system V IPC提供的通信方式有以下三种：

system V共享内存
system V消息队列
system V信号量
其中，system V共享内存和system V消息队列是以传送数据为目的的，而system V信号量是为了保证进程间的同步与互斥而设计的，虽然system V信号量和通信好像没有直接关系，但属于通信范畴。

4.1system V共享内存

原理：共享内存让不同进程看到同一份资源的方式就是，在物理内存当中申请一块内存空间，然后将这块内存空间分别与各个进程各自的页表之间建立映射，再在虚拟地址空间当中开辟空间并将虚拟地址填充到各自页表的对应位置，使得虚拟地址和物理地址之间建立起对应关系，至此这些进程便看到了同一份物理内存，这块物理内存就叫做共享内存。

创建共享内存，操作系统一定要对其进行管理，所以共享内存除了在内存当中真正开辟空间之外，系统一定还要为共享内存维护相关的内核数据结构。

其数据结构：
```
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 */
};
```
当在内存中创建一块共享内存后，为了让要实现通信的进程能够看到同一个共享内存，因此每一个共享内存被申请时都有一个key值，这个key值用于标识系统中共享内存的唯一性。

struct ipc_perm shm_perm结构体中存有key值，其对应数据结构：
```
struct ipc_perm{
	__kernel_key_t  key;
	__kernel_uid_t  uid;
	__kernel_gid_t  gid;
	__kernel_uid_t  cuid;
	__kernel_gid_t  cgid;
	__kernel_mode_t mode;
	unsigned short  seq;
};
```
4.1.1共享内存的建立与释放
共享内存的建立大致包括以下两个过程：
1. 在物理内存当中申请共享内存空间。
2. 将申请到的共享内存挂接到地址空间，即建立映射关系。
共享内存的释放大致包括以下两个过程：
1. 将共享内存与地址空间去关联，即取消映射关系。
2. 释放共享内存空间，即将物理内存归还给系统。
4.1.2创建

创建共享内存我们需要用shmget函数：

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

函数参数说明：
- 第一个参数key，表示待创建共享内存在系统当中的唯一标识。
- 第二个参数size，表示待创建共享内存的大小。
- 第三个参数shmflg，表示创建共享内存的方式。
函数返回值说明
- shmget调用成功，返回一个有效的共享内存标识符（用户层标识符）。
- shmget调用失败，返回-1。
我们把具有标定某种资源能力的东西叫做句柄，而这里shmget函数的返回值实际上就是共享内存的句柄，这个句柄可以在用户层标识共享内存，当共享内存被创建后，我们在后续使用共享内存的相关接口时，可以通过这个句柄对指定共享内存进行各种操作。

key值的获取

可通过函数key_t ftok(const char *pathname, int proj_id)进行获取。

ftok函数的作用就是，将一个已存在的路径名pathname和一个整数标识符proj_id转换成一个key值，称为IPC键值

参数解释：1.pathname:是已经存在的文件路径名。2.一个指定的整数。

注意：
1. 使用ftok函数生成key值可能会产生冲突，此时可以对传入ftok函数的参数进行修改。
2. 需要进行通信的各个进程，在使用ftok函数获取key值时，都需要采用同样的路径名和和整数标识符，进而生成同一种key值，然后才能找到同一个共享资源。
shmflg的组合方式有两种

若使用第一种组合方式，会返回共享内存中的标识符，但不能确定该共享内存是已存在，还是新创建的。使用第二种方式，返回共享内存中的标识符，说明创建成功，且该共享内存是新创建的。若已存在，则会出错返回。

代码演示：
```
#include 
#include  
#include  
#include  
#include 
#define PATHNAME  "/home/LF/if/Linux/lesson2/tt.c" //路径名
#define PROJ_ID 0x22//整数标识符
#define SIZE 4096 //共享内存的大小
 
int main()
{
	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
	if (key < 0){
    printf("key失败\n");
		perror("ftok");
		return 1;
	}
	int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL); //创建新的共享内存
	if (shm < 0){
		perror("shmget");
		return 2;
	}
	printf("key: %x\n", key); //打印key值
	printf("shm: %d\n", shm); //打印句柄
	return 0;
}
```
结果查看：

解释：

ipcs命令：

会默认列出消息队列、共享内存以及信号量相关的信息，若只想查看它们之间某一个的相关信息，可以选择携带以下选项：
- -q：列出消息队列相关信息。
- -m：列出共享内存相关信息。
- -s：列出信号量相关信息
ipcs命令输出的每列信息的含义如下：

注意： key是在内核层面上保证共享内存唯一性的方式，而shmid是在用户层面上保证共享内存的唯一性，key和shmid之间的关系类似于fd和FILE*之间的的关系.

4.1.3释放

我们的进程运行完毕后，申请的共享内存依旧存在，并没有被操作系统释放。实际上，管道的生命周期是随进程的，而共享内存的生命周期是随内核的。即使对应的进程退出了，但是曾经创建的共享内存不会随着进程的退出而释放。

如果进程不主动删除创建的共享内存，那么共享内存就会一直存在，直到关机重启（system V IPC都是如此），同时也说明了IPC资源是由内核提供并维护的。

释放共享内存的方法：

1.可以使用ipcrm -m shmid命令释放指定id的共享内存资源。

例如：

2.使用程序释放共享内存;

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

函数的参数说明：
- 第一个参数shmid，表示所控制共享内存的用户级标识符。
- 第二个参数cmd，表示具体的控制动作。
- 第三个参数buf，用于获取或设置所控制共享内存的数据结构。
shmctl函数的返回值说明：
- shmctl调用成功，返回0。
- shmctl调用失败，返回-1。
shmctl函数的第二个参数传入的常用的选项有以下三个：

代码演示：
```
int main()
{
	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
	if (key < 0){
    printf("key失败\n");
		perror("ftok");
		return 1;
	}
	int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL); //创建新的共享内存
	if (shm < 0){
		perror("shmget");
		return 2;
	}
	printf("key: %x\n", key); //打印key值
	printf("shm: %d\n", shm); //打印句柄
 
  sleep(3);
  shmctl(shm, IPC_RMID, NULL); //释放共享内存
  sleep(3);
	return 0;
}
```
结果：用一段脚本监控查看过程：while :; do ipcs -m;echo "###################################";sleep 1;done

4.1.4关联

共享内存连接到进程地址空间我们需要用shmat函数：

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

函数的参数说明：
- 第一个参数shmid，表示待关联共享内存的用户级标识符。
- 第二个参数shmaddr，指定共享内存映射到进程地址空间的某一地址，通常设置为NULL，表示让内核自己决定一个合适的地址位置。
- 第三个参数shmflg，表示关联共享内存时设置的某些属性。
函数的返回值说明：
- shmat调用成功，返回共享内存映射到进程地址空间中的起始地址。
- shmat调用失败，返回(void*)-1。
shmat函数的第三个参数传入的常用的选项有以下三个。

4.1.5去关联

取消共享内存与进程地址空间之间的关联我们需要用shmdt函数：

int shmdt(const void *shmaddr);

函数的参数说明：
- shmaddr：待去关联共享内存的起始地址，即调用shmat函数时得到的起始地址。
函数的返回值说明：
- shmdt调用成功，返回0。
- shmdt调用失败，返回-1。
代码演示：
```
#define PATHNAME  "/home/LF/if/Linux/lesson2/tt.c" //路径名
 
#define PROJ_ID 0x22//整数标识符
#define SIZE 4096 //共享内存的大小
 
int main()
{
	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
	if (key < 0){
    printf("key失败\n");
		perror("ftok");
		return 1;
	}
	int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL); //创建新的共享内存
	if (shm < 0){
		perror("shmget");
		return 2;
	}
  printf("创建共享内存成功\n");
	printf("key: %x\n", key); //打印key值
	printf("shm: %d\n", shm); //打印句柄
 sleep(2);
 
   char* p=shmat(shm,NULL,0);//关联共享内存
   if(p==(void*)-1)
   {
     perror("shmat");
		return 1;
   }
  printf("关联成功\n");
  sleep(2);
 
  int k= shmdt(p);//去关联
  if(k==-1)
   return 1;
  printf("去关联成功\n");
  sleep(2);
 
 int u= shmctl(shm, IPC_RMID, NULL); //释放共享内存
 if(u==-1)
   return 1;
 printf("释放共享内存成功\n");
  sleep(2);
 
	return 0;
}
```
结果：

shmat函数出现了问题：它是去将进程与关联共享起来的。原因是我们使用shmget函数创建共享内存时，并没有对创建的共享内存设置权限，所以创建出来的共享内存的默认权限为0，即什么权限都没有，因此进程没有权限关联该共享内存。

perm为权限

int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL | 0666); //创建权限为0666的共享内存

将代码调整后：

用脚本查看：
```
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
 
###################################
 
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x220123c5 8          LF         666        4096       0                       
 
###################################
 
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x220123c5 8          LF         666        4096       0                       
 
###################################
 
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x220123c5 8          LF         666        4096       1                       
 
###################################
 
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x220123c5 8          LF         666        4096       1                       
 
###################################
 
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x220123c5 8          LF         666        4096       0                       
 
###################################
 
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x220123c5 8          LF         666        4096       0                       
 
###################################
 
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
 
###################################
```
4.1.6用共享内存实现serve&client通信

服务端负责创建共享内存，创建好后将共享内存和服务端进行关联.后让其死循环，查看是否成功。

客户端只需要直接和服务端创建的共享内存进行关联即可，之后也进入死循环，便于观察客户端是否挂接成功。

代码演示：

serve.c代码：
```
#include"comm.h"
int main()
{
	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
	if (key < 0){
    printf("key失败\n");
		perror("ftok");
		return 1;
	}
	int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL|0666); //创建新的共享内存
	if (shm < 0){
		perror("shmget");
		return 2;
	}
  printf("创建共享内存成功\n");
	printf("key: %x\n", key); //打印key值
	printf("shm: %d\n", shm); //打印句柄
 sleep(2);
 
   char* p=shmat(shm,NULL,0);//关联共享内存
   if(p==(void*)-1)
   {
     perror("shmat");
		return 1;
   }
  printf("关联成功\n");
  sleep(2);
 while(1){
      printf("%s\n", p);
      sleep(2);
  }
 
  int k= shmdt(p);//去关联
  if(k==-1)
   return 1;
  printf("去关联成功\n");
  sleep(2);
 
 int u= shmctl(shm, IPC_RMID, NULL); //释放共享内存
 if(u==-1)
   return 1;
 printf("释放共享内存成功\n");
  sleep(2);
 
	return 0;
}
```
client代码：
```
#include"comm.h"
int main()
{
	key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
	if (key < 0){
    printf("key失败\n");
		perror("ftok");
		return 1;
	}
	int shm = shmget(key, SIZE, IPC_CREAT); //创建新的共享内存
	if (shm < 0){
		perror("shmget");
		return 2;
	}
  printf("创建共享内存成功\n");
	printf("key: %x\n", key); //打印key值
	printf("shm: %d\n", shm); //打印句柄
 sleep(2);
 
   char* p=shmat(shm,NULL,0);//关联共享内存
   if(p==(void*)-1)
   {
     perror("shmat");
		return 1;
   }
  printf("关联成功\n");
  sleep(2);
  while(1)
{
        printf("Please Enter# ");
        fflush(stdout);
        ssize_t s = read(0, p, SIZE);
        if(s > 0)
        {
            p[s] = '\0';
        }
}  
 
  int k= shmdt(p);//去关联
  if(k==-1)
   return 1;
  printf("去关联成功\n");
  sleep(2);
 
 int u= shmctl(shm, IPC_RMID, NULL); //释放共享内存
 if(u==-1)
   return 1;
 printf("释放共享内存成功\n");
  sleep(2);
 
	return 0;
}
```
头文件代码：
```
[LF@ecs-100710 lesson2]$ cat comm.h
#include 
#include 
#include 
#include 
#include 
#include 
#define PATHNAME  "/home/LF/if/Linux/lesson2/tt.c" //路径名
#define PROJ_ID 0x22//整数标识符                           
 #define SIZE 4096 //共享内存的大小
```
4.1.7共享内存与管道进行对比

共享内存创建好后，通信就可以不用到系统调用的接口。而管道创建好后仍需要read、write等系统接口进行通信。实际上，共享内存是所有进程间通信方式中最快的一种通信方式。

再看共享内存的通信：

注意：管道是自带同步与互斥机制的，但是共享内存并没有提供任何的保护机制，包括同步与互斥。

五.消息队列

概念：

消息队列实际上就是在系统当中创建了一个队列，队列当中的每个成员都是一个数据块，这些数据块是由类型和信息组成，两个互相通信的进程可以通过某种方式看到同一个消息队列，这两个进程向对方发数据时，都在消息队列的队尾添加数据块，这两个进程获取数据块时，都在消息队列的队头取数据块。

六.System V信号量

信号量相关概念:
由于进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系叫做进程互斥。
系统中某些资源一次只允许一个进程使用，称这样的资源为临界资源或互斥资源。
在进程中涉及到临界资源的程序段叫临界区。
IPC资源必须删除，否则不会自动删除，因为system V IPC的生命周期随内核。

保护临界资源的本质是保护临界区，我们把进程代码中访问临界资源的代码称之为临界区，信号量就是用来保护临界区的，信号量分为二元信号量和多元信号量。
相关阅读:
使用Ubuntu虚拟机离线部署RKE2高可用集群
 语法练习：front_back
json的数据类型有哪些？json数据类型介绍
 docker上面部署nginx-waf 防火墙“modsecurity”，使用CRS规则，搭建WEB应用防火墙
 Py之yellowbrick：yellowbrick的简介、安装、使用方法之详细攻略
 扬帆际海：shopee店铺关键词广告怎么获得流量?
如何为微服务选择正确的消息队列
 29.5.2 备份数据
 Linux 编译链接那些事儿（02）C++链接库std::__cxx11::basic_string和std::__1::basic_string链接问题总结
 流浪动物救助小程序|基于微信小程序的流浪动物救助系统设计与实现(源码+数据库+文档)
原文地址：https://blog.csdn.net/m0_64397669/article/details/127628201

数组元素	含义
pipefd[0]	管道读端的文件描述符
pipefd[1]	管道写端的文件描述符

一.进程间通信的介绍

1.1通信的目的

1.2进程间通信的分类

二.匿名管道

2.1概念

2.1.2使用步骤

2.2管道读写规则

2.3特点

2.4多进程派发任务的实现

2.5管道大小

三.命名管道

3.1概念

3.2命名管道的打开规则

3.3命名管道演示

3.3.1用命名管道实现serve&client通信

3.3.2用命名管道实现进程控制

3.4命名管道和匿名管道的区别

3.5命令行中的管道

四.system V进程间通信

4.1system V共享内存

4.1.1共享内存的建立与释放

4.1.2创建

4.1.3释放

4.1.4关联

4.1.5去关联

4.1.6用共享内存实现serve&client通信

4.1.7共享内存与管道进行对比

五.消息队列

六.System V信号量