Linux进程间通讯（IPC）

已于 2024-07-09 08:37:28 修改
阅读量807 收藏 28
点赞数 22
分类专栏： Linux系统编程 文章标签： linux 信号处理 信息与通信
于 2024-07-09 08:36:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53333929/article/details/140262415
版权

前言

进程间通信（Inter-Process Communication，简称IPC）是指在不同进程之间传播或交换信息的机制和技术。在现代操作系统中，同时运行着多个进程，它们可能需要相互协作、共享数据或进行通信来完成特定任务。进程间通信允许进程在同一台计算机上或不同计算机上进行交流和协作，从而提高系统的效率、可靠性、并发性和扩展性。以下是关于进程间通信的思维导图：

一、管道（Pipes）

1.命名管道(FIFO)

原理 

命名管道（FIFO，First In, First Out）是Linux系统中一种特殊的文件类型，用于实现进程间通信（IPC）。其实现原理可以归纳如下：

1. 文件系统中的表示

  • 文件形式存储：FIFO文件作为一种特殊的文件存放在文件系统中，它并不在磁盘上占用数据块来存储数据，而是仅仅用来标识内核中一条通道的存在。
  • 路径名关联：与匿名管道（pipe）不同，FIFO提供一个路径名与之关联，这使得任何能够访问该路径的进程都可以通过FIFO进行通信，而不仅仅是具有亲缘关系的进程。

2. 内核管理

  • 内核缓冲区：FIFO在内核空间中创建相应的内核缓冲区（buf），用于暂存数据。当数据被写入FIFO时，它实际上是被写入这个内核缓冲区；当数据被读取时，则是从这个缓冲区中取出。
  • 通信机制：当一个进程以读（r）的方式打开FIFO文件，而另一个进程以写（w）的方式打开该文件时，内核会在这两个进程之间建立一条管道，使得它们可以通过这条管道进行数据的传递。

3. 先进先出原则

  • 队列数据结构：FIFO的名称来源于其数据传递的先进先出（First In, First Out）原则，即最早写入的数据会最先被读出，从而保证了信息交流的顺序性。

4. 创建与操作

  • 创建：通过mkfifo命令或mkfifo函数可以创建FIFO文件。一旦创建，就可以像操作普通文件一样使用open、read、write、close等系统调用来打开、读写、关闭FIFO。
  • 读写操作：写模式的进程向FIFO文件中写入数据，而读模式的进程从FIFO文件中读出数据。需要注意的是，如果FIFO为空且没有进程在读，则写入操作会阻塞，直到有进程打开FIFO进行读操作为止；同样，如果FIFO为满且没有进程在写，则读取操作也会阻塞。

5. 生命周期

  • 持久性：当进程对FIFO的使用结束后，FIFO文件仍然存在于文件系统中，除非对其进行删除操作，否则该FIFO文件不会自行消失。

创建命名管道

1.发送者（write.c）

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <unistd.h>  
#include <fcntl.h>  
#include <sys/stat.h> 
#include <errno.h> 
  
int main(int argc , const char* argv[]) 
{  
    int fd;  
    char *myfifo = "/tmp/myfifo";  
  
    // 确保管道存在  
    if (mkfifo(myfifo, 0666) == -1) 
    {  
        if(errno != EEXIST)  // 检查错误类型是否是文件已存在
        {  
            perror("mkfifo");  
            exit(EXIT_FAILURE);  
        }  
    }  
  
    // 打开管道以写入  
    fd = open(myfifo, O_WRONLY);  
    if(fd == -1) 
    {  
        perror("open");  
        exit(EXIT_FAILURE);  
    }  
  
    // 写入数据到管道  
    char *message = "Hello from writer!";  
    write(fd, message, strlen(message) + 1);  
  
    close(fd); // 关闭管道文件
    
    unlink(myfifo); // 删除管道文件
    
    return 0;  
}

2.接收者（reader.c） 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <fcntl.h>  
#include <string.h>  
  
int main(int argc , const char* argv[]) 
{  
    int fd;  
    char buffer[1024];  
    char *myfifo = "/tmp/myfifo";  
  
    // 打开管道以读取  
    fd = open(myfifo, O_RDONLY);  
    if(fd == -1) 
    {  
        perror("open");  
        exit(EXIT_FAILURE);  
    }  
  
    // 从管道读取数据  
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);  
    if(bytes_read == -1) 
    {  
        perror("read");  
        exit(EXIT_FAILURE);  
    }  
  
    buffer[bytes_read] = '\0'; // 确保字符串正确终止  
    printf("Received: %s\n", buffer);  
  
    close(fd);  
    return 0;  
}

编译和运行 

1.编译这两个程序：

gcc writer.c -o writer  
gcc reader.c -o reader

2.创建一个有名管道（或者确保mkfifo /tmp/myfifo已经运行）

mkfifo /tmp/myfifo

3.首先启动接收者（reader）：

./reader

4.然后，在另一个终端或窗口中启动发送者（writer）：

./writer

你应该在启动reader的终端中看到“Received: Hello from writer!”的消息。

2.匿名管道 

主要特点

  1. 半双工通信：匿名管道是半双工的，意味着在同一时间内，数据只能在一个方向上流动。这意味着它不能像全双工管道那样同时支持双向通信。
  2. 单向数据流：数据只能从管道的一端写入，从另一端读出。写入管道的数据遵循先进先出的原则，即先写入的数据先被读出。
  3. 基于内存：匿名管道不是普通的文件，不属于任何文件系统，而是仅存在于内存中。这使得匿名管道具有较快的通信速度，因为数据直接在内存中进行传输，减少了磁盘I/O操作。
  4. 固定大小的缓冲区：匿名管道在内存中对应一个缓冲区，不同系统的缓冲区大小可能不同。这个缓冲区采用环形队列的机制来管理数据，以实现生产者和消费者之间的数据交换。
  5. 阻塞与非阻塞：默认情况下，从管道中读数据是阻塞操作。如果管道中没有数据可读，读操作将等待直到有数据到来或管道被关闭。然而，通过特定的设置或调用，可以实现非阻塞的读操作。类似地，当管道满时，写操作也会阻塞，直到管道中有足够的空间来容纳新的数据。
  6. 无格式的数据传输：匿名管道传输的数据是无格式的，这要求通信双方必须事先约定好数据的格式，如数据的长度、类型等。否则，接收方可能无法正确解析发送方发送的数据。
  7. 生命周期与进程绑定：匿名管道的生命周期与进程紧密相关。当所有指向管道的文件描述符都被关闭时，管道的生命周期也随之结束。这意味着匿名管道只能用于具有公共祖先的进程之间（如父进程与子进程）的通信。
  8. 面向字节流：匿名管道通信是面向字节流的，即数据以字节为单位进行传输。这使得匿名管道可以传输各种类型的数据，包括文本、二进制文件等。
  9. 同步与互斥：匿名管道本身具有一定的同步与互斥效果。由于管道的缓冲区大小有限，当缓冲区满时，写操作会阻塞，直到缓冲区中有空间可写；当缓冲区空时，读操作会阻塞，直到缓冲区中有数据可读。这种机制有助于实现进程间的同步与互斥。
  10. 局限性：匿名管道只能用于具有血缘关系的进程之间的通信（如父子进程），这限制了它的使用范围。对于需要跨网络或在不同用户空间下运行的进程之间的通信，需要使用其他机制（如套接字、命名管道等）。

 创建匿名管道

以下是一个基于C语言的简单示例，该示例展示了如何使用匿名管道在父进程和子进程之间进行通信。在这个例子中，父进程将向管道中写入数据，而子进程将从管道中读取这些数据。 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <string.h>  
#include <sys/types.h>  
#include <sys/wait.h>  
  
int main() {  
    int pipefd[2]; // 管道文件描述符数组  
    pid_t pid;  
    char buf[1024];  
    int nread;  
  
    // 创建管道  
    if (pipe(pipefd) == -1) {  
        perror("pipe");  
        exit(EXIT_FAILURE);  
    }  
  
    // 创建子进程  
    pid = fork();  
    if (pid == -1) {  
        perror("fork");  
        exit(EXIT_FAILURE);  
    }  
  
    if (pid == 0) {  
        // 子进程  
        close(pipefd[1]); // 关闭写端  
  
        // 读取父进程发送的数据  
        memset(buf, 0, sizeof(buf));  
        nread = read(pipefd[0], buf, sizeof(buf) - 1);  
        if (nread == -1) {  
            perror("read");  
            exit(EXIT_FAILURE);  
        }  
        printf("Child received: %s\n", buf);  
  
        close(pipefd[0]); // 关闭读端  
        exit(EXIT_SUCCESS);  
    } else {  
        // 父进程  
        close(pipefd[0]); // 关闭读端  
  
        // 写入数据到管道  
        const char *msg = "Hello from parent!";  
        write(pipefd[1], msg, strlen(msg) + 1);  
  
        close(pipefd[1]); // 关闭写端  
  
        // 等待子进程结束  
        wait(NULL);  
    }  
  
    return 0;  
}

程序说明

  1. 管道创建：使用pipe()函数创建一个管道，该函数返回两个文件描述符，pipefd[0]用于读取数据，pipefd[1]用于写入数据。

创建完管道之后处理文件描述符 

  1. 进程创建：通过fork()创建一个子进程。fork()的返回值在父进程中是子进程的PID，在子进程中是0，如果失败则返回-1。

  1. 文件描述符操作：

    • 在子进程中，关闭管道的写端（pipefd[1]），然后读取数据。
    • 在父进程中，关闭管道的读端（pipefd[0]），然后写入数据。

  1. 数据交换：父进程向管道写入字符串"Hello from parent!"，子进程从管道读取这个字符串并打印出来。

  2. 关闭文件描述符：在数据交换完成后，关闭相应的文件描述符以避免资源泄露。

  3. 等待子进程：父进程使用wait(NULL)等待子进程结束，以确保所有资源都被正确释放

3.匿名管道与FIFO的区别 

  • 匿名管道：仅存在于内存中，通常用于父子进程或兄弟进程之间的通信。它通过pipe()系统调用创建，并返回两个文件描述符，一个用于读，一个用于写。匿名管道是半双工的，即数据只能单向流动。
  • 命名管道（FIFO）：具有持久性，以文件的形式存在于文件系统中，允许无亲缘关系的进程之间进行通信。它使用mkfifo()或mknod()函数创建，创建后会在文件系统中生成一个特殊类型的文件，可以通过文件I/O操作来读取和写入数据。命名管道遵循先进先出（FIFO）的原则。

二、XSI进程间通讯

1.共享内存

共享内存是一种允许多个进程访问同一块内存区域的方式。这种方式通常比较高效，因为数据不需要在进程间复制，但需要处理进程间的同步和互斥问题。共享内存通过映射同一块物理内存到不同进程的地址空间来实现。 

原型

#include <sys/shm.h>
// 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
int shmget(key_t key, 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);

 编程模型

进程A代码如下（示例）： 

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
int shmid;
char *shm;
//收到通知并读取数据
void sighander(int num)
{
	printf("接收到信号: %s\n", shm);  
	if(strcmp("quit", shm) == 0)
	{
		printf("通讯结束\n");	

		//取消映射
		if(shmdt(shm))
		{
			perror("shmdt");	
		}
		usleep(1000); //等待对方取消映射
		//删除共存内存
		if(shmctl(shmid, IPC_RMID, NULL))
		{
			perror("shmctl");
		}
		exit(0);
	}
}
int main(int argc , const char* argv[])
{
	//注册信号处理函数
	signal(SIGRTMIN, sighander);
	//创建共享内存
	int shmid = shmget(ftok(".", 110), 4096, IPC_CREAT | 0664);
	if(shmid < 0)
	{
		perror("shmget");	
		return -1;
	}

	//映射共享内存
	shm = shmat(shmid, NULL, 0);
	if(shm == (void *)-1)
	{
		perror("shmat");	
		shmctl(shmid, IPC_RMID, NULL);
		return -1;
	}
	
	pid_t pid = 0;
	printf("当前进程ID：%d\n", getpid());
	printf("输入要通讯进程ID：");
	scanf("%u", &pid);

	//写数据并通知其他进程
	while(1)
	{
		printf(">>>");	
		scanf("%s", shm);
		kill(pid, SIGRTMIN); // 通知其他进程
		if(strcmp("quit", shm) == 0)
		{
			printf("通讯结束\n");	
			break;
		}
	}
	
	//取消映射
	if(shmdt(shm))
	{
		perror("shmdt");	
		return -1;
	}
	usleep(1000);


	//删除共享内存
	if(shmctl(shmid, IPC_RMID, NULL))
	{
		perror("shmctl");	
		return -1;
	}
	return 0; 
}

 进程B代码如下（示例）：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <sys/ipc.h>  
#include <sys/shm.h>  
#include <signal.h>  
#include <unistd.h>  
  
#define SHM_SIZE 4096  
 
char *shm;  
  
// 信号处理函数  
void sighander(int num)  
{  
    printf("接收到信号: %s\n", shm);  
	if(strcmp("quit", shm) == 0)
	{
		printf("通讯结束\n");	

		//取消映射
		if(shmdt(shm))
		{
			perror("shmdt");	
		}
		usleep(1000); //等待对方取消映射
		exit(0);
	}
}  
  
int main(int argc, const char *argv[])  
{  
	/*if(argc < 2) 
    {  
        fprintf(stderr, "Usage: %s <shm_key>\n", argv[0]);  
        exit(EXIT_FAILURE);  
    }  
  
    key_t shm_key = atoi(argv[1]); // 从命令行参数获取共享内存键  */
    
	// 注册信号处理函数  
    signal(SIGRTMIN, sighander); // 监听来自进程A的信号
    
    printf("当前进程ID：%d\n", getpid());
  	
  	key_t shm_key = ftok(".", 110);
    // 获取共享内存  
    int shmid = shmget(shm_key, SHM_SIZE, IPC_CREAT);  
    if(shmid < 0) 
    {  
        perror("shmget");  
        exit(EXIT_FAILURE);  
    }  
  
    // 映射共享内存  
    shm = shmat(shmid, NULL, 0);  
    if(shm == (char *)-1) 
    {  
        perror("shmat");  
        shmctl(shmid, IPC_RMID, NULL); // 如果映射失败，则删除共享内存  
        exit(EXIT_FAILURE);  
    }  
    
    pid_t pid = 0;
    printf("输入要通讯进程ID：");
	scanf("%u", &pid); 
  
    // 主循环（这里我们简单地等待信号，不执行持续读写）  
    while(1) 
    {   
    	printf(">>>");	
		scanf("%s", shm);
		kill(pid, SIGRTMIN);
		if(strcmp("quit", shm) == 0)
		{
			printf("通讯结束\n");	
			break;
		}
    }  
  
    // 取消映射  
    if(shmdt(shm) == -1) 
    {  
        perror("shmdt");  
        exit(EXIT_FAILURE);  
    }    
    return 0;   
}

编译运行 

 1.在终端输入如下命令进行编译

gcc processA.c -o a
gcc processB.c -o b

2.运行进程A

./a

运行结果，得到当前进程的进程号 

 3.在新的终端中运行进程B

./b

 

4.在进程A的运行终端输入进程B的进程号后回车

5.在进程B的运行终端输入进程A的进程号后回车

2.消息队列

 消息队列是消息的链表，存放在内核中并由消息队列标识符标识。它克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点，支持异步通信、多对多通信和数据持久化等。

原型

int msgget(key_t key, int msgflg);
    功能：创建\获取消息队列
    key：IPC键值
    msgflg：
        IPC_CREAT  消息队列已存在则获取，否则创建
        IPC_EXCL   消息队列已存在则返回错误
        注意：如果创建需要提供权限
    返回值：IPC标识符，失败-1

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
    功能：向消息队列发送消息包
    msqid：IPC标识符
    msgp：要发送的消息包的首地址
        struct msgbuf {
           long mtype;      //  消息类型
           char mtext[n];   //  数据
           ...
        };
    msgsz：数据的字节数，不包含消息类型
    msgflg：
        阻塞发送一般给0
        IPC_NOWAIT 当消息队列满，不等待立即返回
    返回值：成功返回0，失败返回-1

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
    功能：从消息队列中接收对应消息包的数据
    msqid：IPC标识符
    msgp：存储消息包的内存首地址
    msgsz：存储数据的内存字节数(尽量大些)
    msgtyp：消息类型(按照类型获取，不按照顺序)
        >0 读取消息类型=msgtyp的消息
        =0 读取消息队列中第一条消息
        <0 读取消息类型小于abs(msgtyp)的消息，如果有多个则读值最小的
    msgflg
        IPC_NOWAIT 消息队列都不符合时不阻塞，立即返回
        MSG_EXCEPT 如果msgtyp>0，则读取第一条不等于msgtyp的消息
        MSG_NOERROR 如果不包含此标志，如果实际发送过来的数据字节数>接收的字节数，则返回失败，如果包含此标志，那么就只读取接收的字节数，一定会成功
    返回值：成功读取到数据的字节数

int msgctl(int msqid,int cmd,struct msqid_ds *buf);
    功能：获取\修改消息队列的属性、删除队列
    msqid：IPC标识符
    cmd：
        IPC_STAT   获取消息队列属性 buf输出型参数
        IPC_SET    设置消息队列属性 buf输入型参数
        IPC_RMID   删除消息队列     NULL

 编程模型

进程A的代码如下（示例）： 

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>
#include "message.h"

int main(int argc , const char* argv[])
{
	// 创建消息队列
	int msgid = msgget(ftok(".", 120), IPC_CREAT | 0664);		
	if(msgid < 0)
	{
		perror("msgget");	
	}

	Msg msg = {};

	while(1)
	{
		msg.type = 1;
		printf(">>>");
		scanf("%s", msg.data);

		// 发送消息类型为1的消息
		if(msgsnd(msgid, &msg, strlen(msg.data), IPC_NOWAIT) == -1)
		{
			perror("msgsnd");	
			return -1;
		}

		if(strcmp("quit", msg.data) == 0)
		{
			break;
		}

		// 获取消息类型为2的消息
		if(msgrcv(msgid, &msg, MSGMAX, 2, 0) <= 0)
		{
			perror("msgrcv");	
			break;
		}

		printf("recv:%s\n", msg.data);
		if(strcmp("quit", msg.data) == 0) break;
	}

	printf("通讯结束!\n");
	usleep(1000);
	
	// 删除消息队列
	if(msgctl(msgid, IPC_RMID, NULL))
	{
		perror("msgctl");	
		return -1;
	}

	return 0; 
}

 进程B的代码如下（示例）：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>
#include "message.h"

int main(int argc , const char* argv[])
{
	// 创建消息队列
	int msgid = msgget(ftok(".", 120), 0);		
	if(msgid < 0)
	{
		perror("msgget");	
	}

	Msg msg = {};

	while(1)
	{
		// 获取消息类型为1的消息 接收失败阻塞
		if(msgrcv(msgid, &msg, MSGMAX, 1, 0) == 0)
		{
			perror("msgrcv");	
			break;
		}
		printf("recv:%s\n", msg.data);
		if(strcmp("quit", msg.data) == 0) break;
		
		msg.type = 2;
		printf(">>>");
		scanf("%s", msg.data);

		// 发送消息类型为2的消息 发送失败不阻塞直接返回
		if(msgsnd(msgid, &msg, strlen(msg.data), IPC_NOWAIT) == -1)
		{
			perror("msgsnd");	
			return -1;
		}

		if(strcmp("quit", msg.data) == 0)
		{
			break;
		}
	}

	printf("通讯结束!\n");
	usleep(1000);

	return 0; 
}

发送信息的结构体类型 （定义在mssage.h中）

#ifndef MESSAGE_H
#define MESSAGE_H

#define MSGMAX 256

typedef struct Msg
{
	long type;      //  消息类型
    char data[MSGMAX];   //  数据 	
} Msg;

#endif// MESSAGE_H

 编译运行

与上述共享内存模型测试相同 ，分别编译生成可执行文件，任何先运行A进程再运行B进程。

3.信号量

 信号量是一个计数器，用于控制多个进程对共享资源的访问。它主要用于进程间同步和互斥，避免死锁，限制资源访问数量，以及实现进程间通知。

基本特点：由内核管理的一个"全局变量"，用于记录共享资源的数量，限制进程对共享资源的访问使用
    信号量是一种数据操作锁，本身是不具备数据交互功能，而是通过控制其他的通信资源从而配合实现进程间通信
    1、如果信号量的值大于0，说明可以使用资源，使用时需要信号量-1，然后再使用
    2、如果信号量的值等于0，说明没有资源可使用，此时进程进入休眠，直到信号量的值大于0，进程会被唤醒，执行步骤1
    3、当资源使用完毕，把信号量的值+1，正在休眠的进程就会被唤醒 

原型 

int semget(key_t key, int nsems, int semflg);
    功能：创建\获取信号量
    key:IPC键值
    nsems：信号量的数量 一般写1
    semflg：IPC_CREAT  信号量已存在则获取，否则创建
            IPC_EXCL   信号量已存在则返回错误
            注意：如果创建需要提供权限
    返回值：IPC标识符 失败-1

int semctl(int semid, int semnum, int cmd, ...);
    功能：删除、控制信号量
    semid：IPC标识符
    semnum：要操作的第几个信号量，从0开始，下标
    cmd：
        IPC_STAT   获取信号量属性 buf输出型参数
        IPC_SET    设置信号量属性 buf输入型参数
        IPC_RMID   删除信号量     NULL
        SETVAL     设置某个信号量的值
        SETALL     设置所有信号量的值
        GETVAL     获取某个信号量的值
        GETALL     获取所有信号量的值
        GETNCNT    获取等待拿资源的进程数量

int semop(int semid,struct sembuf *sops,size_t nsops);
    功能：对信号量进行加减操作
    semid：IPC标识符
    sembuf{
        unsigned short sem_num;  // 信号量的下标
        short          sem_op;   //
                1 信号量+1
                -1 信号量-1 如果不能减，则默认阻塞
        short          sem_flg;  //
                IPC_NOWAIT 不阻塞
                SEM_UNDO 如果进程终止没有手动还资源，系统会自动还
    }
    nsops：表示sops指向多少个结构体数量 一般写1

有关POXSI信号量的内容参考下面这篇文章：

http://t.csdnimg.cn/t9LWW

三、网络进程间通讯——（socket套接字） 

有关网络进程通讯参考博主的另外几篇文章 

http://t.csdnimg.cn/LVbMS socket介绍，使用socket在同一计算机中的进程间通信

http://t.csdnimg.cn/McAEq  基于TCP协议的网络通信模型

 http://t.csdnimg.cn/LlSe1 基于UDP通信协议的网络通信编程模型 

linux进程间通讯指南-打通IPC大门,高效沟通无阻
w风雨无阻w的专栏
06-06 1907
所谓IPC(Inter-Process Communication)，就是指允许进程之间传递数据或进行通信控制的机制。在Linux下，主要的IPC工具包括管道(Pipe)、FIFO、消息队列(Message Queue)、共享内存(Shared Memory)、信号(Signal)等。数据传输工具：如管道、消息队列等，用于在进程间传递数据。同步工具：信号量、文件锁等同步工具，则控制对共享资源的访问顺序，避免竞争条件。
Linux 进程间通信（IPC）
清欢Allen的技术博客
08-22 833
进程间通信（ipc), 指不同进程之间的信息传输或交换。
linux IPC
10-15
linux IPC example
Linux IPC总结（全）
热门推荐
大象大象啥模样。。。
08-02 1万+
IPC进程间通信(Inter-Process Communication)就是指多个进程之间相互通信，交换信息的方法。Linux IPC基本上都是从Unix平台上继承而来的。主要包括最初的Unix IPC，System V IPC以及基于Socket的IPC。另外，Linux也支
【Linux】进程间通信（IPC）---万字详解
最新发布
2302_80026357的博客
03-11 1320
【Linux】进程间通信（IPC）---万字详解
【Linux】IPC
JKins的博客
04-13 361
通信方式 作用范围 特点 信号 亲缘/非亲缘 自身 管道 亲缘 命名管道FIFO 亲缘/非亲缘 共享内存 亲缘/非亲缘 最快的IPC，无需内存拷贝 信号量semaphore 亲缘/非亲缘/线程间 不做数据传输 套接字 还没学 消息队列 还没学 流程 管道 pipe一个fd fork 处理父子进程的fd[0] fd[1] 使用（printf可以...
Linux系统下的进程间通信（IPC）
weixin_45402928的博客
02-08 1371
通信作用： 数据传输 资源共享 事件通知 进程控制 通信方式： 1/早期unix系统的ipc 管道 数据传输 信号 事件通知 fifo 数据传输 2/Sytem -V ipc System -V 消息队列 数据传输+进程控制 System -V 心信号量 资源共享+进程控制 System -V 共享内存 数据传输（这里的数据传输相对于其他的ipc读写效率高很多） 3/socket ipc 4/poisx ipc poisx 消息队列 poisx 心信号量 poisx 共享内存 ...
linux下的进程间通信(IPC)
baiduren__的博客
05-30 2023
进程间通信(IPC）一、进程间通信(IPC)是什么？二、四种通信方式1.管道-PIPE（1）管道分类（2）接口（3）特性总结（4）管道符的实现（5）管道总结2. 共享内存（1）特性（2）速度快（3）本质原理（4）操作流程（5）共享内存总结3.消息队列（1）本质（2）特性4.信号量（1）本质（2）作用（3）如何实现保护操作（4）信号量实现同步与互斥原理 一、进程间通信(IPC)是什么？ 操作系统为用户提供的几种用于进程间进行通信的方式。 (管道,共享内存,消息队列,信号量) 目的:进程具有独立性。 (每个进
linux 进程间通讯IPC 讲解PPT 对IPC做出详细讲解，是学习必备ppt www.zmemb.com 交大志盟
04-01
Linux中的进程间通信（IPC，Inter-Process Communication）是一种机制，允许不同的进程之间交换数据和协调执行。在本篇讲解中，我们将重点关注三种System V IPC机制：信号量、共享内存和消息队列。 1. 信号量...
Linux进程间通讯视频教程
06-29
在本"Linux进程间通讯视频教程"中，你将学习如何创建和管理这些通信机制，包括如何设置、使用以及避免潜在的问题。对于初学者而言，理解这些基本概念和操作是至关重要的，因为它们是构建复杂、并发系统的基础。通过...
linux进程间通信（IPC）
u010306832的博客
09-19 502
1.进程通信概念 进程用户空间是相互独立的，一般而言是不能相互访问的。但很多情况下进程间需要互相通信，来完成系统的某项功能。进程通过与内核及其它进程之间的互相通信来协调它们的行为。 每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程A把数据从用户空间拷到内核缓冲区，进程B再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信。 2.进程通信的方式 3.进程通信-pipe 管道分为有名管道和无名管道； 无名
Linux系统编程之进程间通信（IPC）
Mount姚的博客
07-22 387
进程间的通信方式IPC
Linux下Socket通信（IPC）
LoveZhangjia521的专栏
08-17 377
1、Linux下的Socket通信是一种基于文件的IPC通信，也可以是基于其他设备的IPC通信。它可以在本机内不同进程间实现通信，也可以在实现不同主机之间的通信。 2、Socket是一种进程间通信模式： 对等模式（P2P）：一对一：UDP 客户服务器模式（C/S）：一对多：TCP 3、基本创建步骤 （1）通过socket()函数创建socket （2）通过bind函数绑定socket于...
Linux进程间通信（IPC）
gogoingad的博客
01-14 709
进程间通信： 进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。 IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中Socket和Streams支持不同主机上的两个进程IPC。 一、管道 管道，通常指无名管道，是UNIX系统IPC最古老的形式。 1、特点： ①是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。 ②只能用于具有亲缘关系的进程之间的通信（父子进程或者兄弟进程之间
Linux中的IPC机制
zero_ko的博客
08-16 1298
文章目录Linux中的IPC机制**管道****信号****信号量****消息队列****共享内存****套接字** Linux中的IPC机制 Linux中主要的IPC机制有：管道（pipe）、信号（sinal）、信号量（semophore）、消息队列（Message）、共享内存（Share Memory）、套接字（Socket）等。 管道 管道是Unix中最古老的进程间通信的形式，我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。其本质是内核中固定大小的缓冲区。就是在内存中创建一个共享文件，从
linux中ipc机制,IPC机制
weixin_42284052的博客
05-14 303
仅做个人学习记录什么是IPC？inter-process-communication 进程间通信(跨进程通信)，两个进程间进行数据交互的过程。什么是线程？什么是进程？两者的关系？线程：是CUP调度的最小单元，同时是一种有限的系统资源。进程：一般指一个执行单元，在PC或移动设备上表示为一个程序或者应用。一个进程中可以包含过个线程，一个或多个线程系统的组成就是一个程序。IPC是Android独有的吗？...
Linux进程间通信(Linux IPC)
Peerless__的博客
06-04 7043
在Linux下由很多种进程间通信的方式，在下面主要介绍七种，分别是：匿名管道(PIPE)、命名管道(FIFO)、信号、共享内存映射、共享内存、消息队列、信号量、UNIX域套接字。
Linux：进程间通信（IPC）
田怼怼的博客
03-28 182
进程间通信 1、进程间通信的概念 进程间通信是操作系统为用户提供的几种通信方式。 进程间因为每一个进程都有一个虚拟地址空间，在保证了进程独立性的同时，却使得进程间无法直接通信，因此需要操作系统来提供进程间通信方式，并且因为通信的场景不同，所以提供的方式也有多种。 2、进程间通信的目的 数据传输：一个进程需要将它的数据发送给另一个进程 资源共享：多个进程之间共享同样的资源。 通知事件：一个进程需...
Linux——进程间通信（IPC）
qq_46036601的博客
07-26 303
进程间通信（IPC）是指在不同进程间进行传播或交换信息。 进程间通信的方式主要有管道（包括无名管道和命名管道）、消息队列、共享内存、信号量等。 一、管道 管道通常指无名管道，是Unix系统IPC最古老的形式。 1.特点： 1.管道是单向的，有固定的写段和读端 2.只能用于具有亲缘关系的进程之间的通信 3.只存在于内存之中，是一种特殊文件，可使用普通的read、write等函数 4、管道中不储存数据，数据读完之后就没了 ...
Linux进程间通讯三种方法实验参考代码
标题中提到的“linux进程间通讯实验参考代码”指的是提供给开发者的一套示例代码，用于演示和学习在Linux环境下实现进程间通信的三种不同方法。由于给出的信息中没有具体的代码片段，以下将从概念上对Linux下进程间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值