进程间通信

最新推荐文章于 2024-07-22 09:38:37 发布

moon-hoo

最新推荐文章于 2024-07-22 09:38:37 发布

阅读量797

点赞数 16

文章标签： c++ linux

本文链接：https://blog.csdn.net/qq_58381894/article/details/135603111

版权

进程间通信

进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。
但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信(IPC)
进程间通信的目的：

数据传输：一个进程需要将它的数据发送给另一个进程。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。
进程控制：有些进程希望完全控制另一个进程的执行（如 Debug 进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux 操作系统支持的主要进程间通信的通信机制：

无名管道

管道也叫无名管道，它是是 UNIX 系统 IPC（进程间通信）的最古老形式，所有的 UNIX 系统都支持这种通信机制。
管道有如下特点：

半双工，数据在同一时刻只能在一个方向上流动。
数据只能从管道的一端写入，从另一端读出。
写入管道中的数据遵循先入先出的规则。
管道所传送的数据是无格式的，这要求管道的读出方与写入方必须事先约定好数据的格式，如多少字节算一个消息等。
管道不是普通的文件，不属于某个文件系统，其只存在于内存中。
管道在内存中对应一个缓冲区。不同的系统其大小不一定相同。
从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据。
管道没有名字，只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。
管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。

pipe函数

#include <unistd.h>
int pipe(int pipefd[2]);
功能：创建无名管道。

参数：
    pipefd : 为 int 型数组的首地址，其存放了管道的文件描述符 pipefd[0], pipefd[1]。
    当一个管道建立时，它会创建两个文件描述符 fd[0] 和 fd[1]。其中 fd[0] 固定用于读管道，而 fd[1] 固定用于写管道。一般文件 I/O的函数都可以用来操作管道(lseek() 除外)。

返回值：
    成功：0
    失败：-1

管道的读写特点

使用管道需要注意以下4种特殊情况（假设都是阻塞I/O操作，没有设置O_NONBLOCK标志）：

如果所有指向管道写端的文件描述符都关闭了（管道写端引用计数为0），而仍然有进程从管道的读端读数据，那么管道中剩余的数据都被读取后，再次read会返回0，就像读到文件末尾一样。
如果有指向管道写端的文件描述符没关闭（管道写端引用计数大于0），而持有管道写端的进程也没有向管道中写数据，这时有进程从管道读端读数据，那么管道中剩余的数据都被读取后，再次read会阻塞，直到管道中有数据可读了才读取数据并返回。
如果所有指向管道读端的文件描述符都关闭了（管道读端引用计数为0），这时有进程向管道的写端write，那么该进程会收到信号SIGPIPE，通常会导致进程异常终止。当然也可以对SIGPIPE信号实施捕捉，不终止进程。具体方法信号章节详细介绍。
如果有指向管道读端的文件描述符没关闭（管道读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道写端写数据，那么在管道被写满时再次write会阻塞，直到管道中有空位置了才写入数据并返回。

读管道：

管道中有数据，read返回实际读到的字节数。
管道中无数据：
- 管道写端被全部关闭，read返回0 (相当于读到文件结尾)
- 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)

写管道：

管道读端全部被关闭，进程异常终止(也可使用捕捉SIGPIPE信号，使进程终止)
管道读端没有全部关闭：
- 管道已满，write阻塞。
- 管道未满，write将数据写入，并返回实际写入的字节数。

设置为非阻塞的方法

// 获取原来的flags
int flags = fcntl(fd[0], F_GETFL);
// 设置新的flags
flag |= O_NONBLOCK;
// flags = flags | O_NONBLOCK;
fcntl(fd[0], F_SETFL, flags);

结论：如果写端没有关闭，读端设置为非阻塞，如果没有数据，直接返回-1

查看管道缓冲区函数

#include <unistd.h>
long fpathconf(int fd, int name);
功能：该函数可以通过name参数查看不同的属性值
参数：
    fd：文件描述符
    name：
        _PC_PIPE_BUF，查看管道缓冲区大小
        _PC_NAME_MAX，文件名字字节数的上限
返回值：
    成功：根据name返回的值的意义也不同。
    失败： -1

案例1

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<fcntl.h>

// ---- # 无名管道测试 ------ //
/*
 - 父进程向子进程传数据
*/

int main(){

	// 1. create pipe
	int fd[2];
	int ret = pipe(fd);
	if(ret < 0){
		perror("pipe error\n");
		return -1;
	}

	// 2. create child process
	pid_t pid = fork();
	if(pid < 0){
		perror("child error\n");
		return -1;
	}
	else if(pid > 0)
	{
		// close read（由于半双工的特性）
		close(fd[0]);
		sleep(5);
		std::cout<<"["<<getpid()<<"] 父进程向子进程传递数据...."<<std::endl;
		write(fd[1], "hello world", strlen("hello world"));
		wait(nullptr);
	}
	else if(pid == 0)
	{
		//  close write
		close(fd[1]);
		sleep(5);
		char buf[64];
		memset(buf, 0x00, sizeof(buf));
		int n = read(fd[0], buf, sizeof(buf));
		printf("[%d] children process read values is [%d], buf is [%s]\n", getpid(), n, buf);
	}
	return 0;

}

案例2

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<unistd.h>
#include<sys/wait.h>

// ---- # 使用管道在进程中采用exec系统调用 --------- //
//use pipe solve ps aux | grep bash opeating
int main()
{
	int fd[2];
	int ret = pipe(fd);
	if(ret < 0){
		perror("pipe error");
		return -1;
	}

	pid_t pid = fork();
	if(pid < 0){
		perror("fork error");
		return -1;
	}
	else if(pid > 0)
	{
		close(fd[0]);
		dup2(fd[1], STDOUT_FILENO);
		execlp("ps", "ps", "aux", nullptr);
	}
	else if(pid == 0)
	{
		close(fd[1]);
		dup2(fd[0], STDIN_FILENO);
		execlp("grep", "grep", "--color=auto", "bash", nullptr);
		perror("execlp error");
	}
	return 0;
}

命名管道

管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了命名管道（FIFO），也叫有名管道、FIFO文件。

命名管道（FIFO）不同于无名管道之处在于它提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，这样，即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。

命名管道（FIFO)和无名管道（pipe）有一些特点是相同的，不一样的地方在于：

FIFO 在文件系统中作为一个特殊的文件而存在，但 FIFO 中的内容却存放在内存中。
当使用 FIFO 的进程退出后，FIFO 文件将继续保存在文件系统中以便以后使用。
FIFO 有名字，不相关的进程可以通过打开命名管道进行通信。

通过函数创建有名管道

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

int mkfifo(const char *pathname, mode_t mode);
功能：
    命名管道的创建。
参数：
    pathname : 普通的路径名，也就是创建后 FIFO 的名字。
    mode : 文件的权限，与打开普通文件的 open() 函数中的 mode 参数相同。(0666)
返回值：
    成功：0   状态码
    失败：如果文件已经存在，则会出错且返回 -1。

有名管道读写操作

一旦使用mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件I/O函数都可用于fifo。如：close、read、write、unlink等。

FIFO严格遵循先进先出（first in first out），对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。

//进行1，写操作
int fd = open("my_fifo", O_WRONLY);  

char send[100] = "Hello Mike";
write(fd, send, strlen(send));

//进程2，读操作
int fd = open("my_fifo", O_RDONLY);//等着只写  

char recv[100] = { 0 };
//读数据，命名管道没数据时会阻塞，有数据时就取出来  
read(fd, recv, sizeof(recv));
printf("read from my_fifo buf=[%s]\n", recv);

有名管道注意事项

一个为只读而打开一个管道的进程会阻塞直到另外一个进程为只写打开该管道
一个为只写而打开一个管道的进程会阻塞直到另外一个进程为只读打开该管道

读管道：

管道中有数据，read返回实际读到的字节数。
管道中无数据：
- 管道写端被全部关闭，read返回0 (相当于读到文件结尾)
- 写端没有全部被关闭，read阻塞等待

写管道：

管道读端全部被关闭，进程异常终止(也可使用捕捉SIGPIPE信号，使进程终止)
管道读端没有全部关闭：
- 管道已满，write阻塞。
- 管道未满，write将数据写入，并返回实际写入的字节数。
  读命名管道

#include <iostream>
#include <cstring>
#include <fcntl.h>
#include <unistd.h>

/*
读命名管道
*/

int main() {
    const char* pipe_path = "./myfifo.txt";

    // 1. 打开命名管道以读取数据
    int pipe_fd = open(pipe_path, O_RDONLY);
    if (pipe_fd == -1) {
        perror("Failed to open named pipe for reading");
        return EXIT_FAILURE;
    }

    char buffer[256];
    ssize_t bytes_read = read(pipe_fd, buffer, sizeof(buffer));

    if (bytes_read == -1) {
        perror("Read from named pipe failed");
        close(pipe_fd);
        return EXIT_FAILURE;
    }

    std::cout << "Read " << bytes_read << " bytes from the named pipe: " << buffer << std::endl;

    // 关闭文件描述符
    close(pipe_fd);

    return 0;
}

写命名管道

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

// --- # 命名管道测试 ----- //
/*
创建命名管道，并且向命名管道中进行写数据操作
*/

int main()
{
	// 1. creat fifo
	int ret = access("./myfifo.txt", F_OK);  // 检查文件是否存在
	if(ret != 0)
	{
		ret = mkfifo("./myfifo.txt", 0777);
		if(ret < 0){
			perror("mkfifo error");
			return -1;
		}
	}

	// 2. open file
	int fd = open("./myfifo.txt", O_WRONLY);
	if(fd < 0){
		perror("open file error");
		return -1;
	}


	int i = 0;
	char buf[64];
	while(true)
	{
		memset(buf, 0x00, sizeof(buf));
		sprintf(buf, "%d:%s", i, "hello world\n");
		write(fd, buf, strlen(buf));
		sleep(1);
		i++;
	}
	close(fd);
	return 0;

}

共享存储映射

存储映射I/O使一个磁盘文件与存储空间中的一个缓冲区相映射。
共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式, 因为进程可以直接读写内存，而不需要任何数据的拷贝。

存储映射函数

mmap函数

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
功能:
    一个文件或者其它对象映射进内存
参数：
    addr :  指定映射的起始地址, 通常设为NULL, 由系统指定
    length：映射到内存的文件长度
    prot：  映射区的保护方式, 最常用的 :
        a) 读：PROT_READ
        b) 写：PROT_WRITE
        c) 读写：PROT_READ | PROT_WRITE
    flags：  映射区的特性, 可以是
        a) MAP_SHARED : 写入映射区的数据会复制回文件, 且允许其他映射该文件的进程共享。
        b) MAP_PRIVATE : 对映射区的写入操作会产生一个映射区的复制(copy - on - write), 对此区域所做的修改不会写回原文件。
    fd：由open返回的文件描述符, 代表要映射的文件。
    offset：以文件开始处的偏移量, 必须是4k的整数倍, 通常为0, 表示从文件头开始映射
返回值：
    成功：返回创建的映射区首地址
    失败：MAP_FAILED宏
            
// ------------------------------------------         
关于mmap函数的使用总结：
1)  第一个参数写成NULL
2)  第二个参数要映射的文件大小 > 0
3) 第三个参数：PROT_READ 、PROT_WRITE
4) 第四个参数：MAP_SHARED 或者 MAP_PRIVATE
5) 第五个参数：打开的文件对应的文件描述符
6) 第六个参数：4k的整数倍，通常为0

munmap函数

#include <sys/mman.h>
int munmap(void *addr, size_t length);
功能：
    释放内存映射区
参数：
    addr：使用mmap函数创建的映射区的首地址
    length：映射区的大小
返回值：
    成功：0
    失败：-1

注意事项

创建映射区的过程中，隐含着一次对映射文件的读操作。
当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
特别注意，当映射文件大小为0时，不能创建映射区。所以，用于映射的文件必须要有实际大小。mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
如果文件偏移量必须为4K的整数倍。
mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作

匿名映射实现父子进程通信

通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。

通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。可以直接使用匿名映射来代替。

其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。

使用MAP_ANONYMOUS (或MAP_ANON)。

    int *p = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);

size，该位置表示映射区大小。
MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义，可使用如下两步来完成匿名映射区的建立。

使用匿名映射实现进程间通信

#include <iostream>
#include <fstream>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <wait.h>


// --- # 使用mmap进行文件映射 ---- //、
void test1(){

    // 1. 打开文件
    int fd = open("myfifo.txt", O_RDWR);

    // 2. 获取文件的大小
    int len = lseek(fd, 0, SEEK_END);

    // 3. 将文件映射到内存
    void *ptr_data = mmap(nullptr, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(ptr_data == MAP_FAILED){
        perror("mmap failed");
        close(fd);
        return;
    }

    // 4. 在映射的内存中进行读写操作(等价于从文件中读取内容)
    std::cout<<"read file or memory content is : "<<std::endl;
    std::cout<<static_cast<char*>(ptr_data)<<std::endl;
    sprintf(static_cast<char*>(ptr_data), "i love you\n");
    std::cout << "Content after modification:\n"<< std::endl;
    std::cout<<static_cast<char*>(ptr_data)<<std::endl;
    // 5. 取消映射
    if(munmap(ptr_data, len) == -1){
        perror("mumap failed");
    }

    close(fd);
}

/* --- # 使用mmap 进程间的通信(使用MAP_ANONYMOUS进行匿名映射，无需借用文件) ----*/
void test2(){

    // 1. 设置共享内存大小
    const size_t mmap_memory_size = sizeof(int);

    // 2. 创建共享存储映射
    int *ptr_data = static_cast<int*>(mmap(nullptr, mmap_memory_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0));
    if(ptr_data == MAP_FAILED){
        perror("mmap failed");
        return;
    }

    // 3. 创建子进程并进行进程间的通信
    pid_t pid = fork();
    if(pid == -1){
        perror("fork failed");
        return;
    }
    else if(pid == 0){
        (*ptr_data) = 100;
        std::cout<<"child process set value is : "<<(*ptr_data)<<std::endl;
        
        // 子进程完成后取消映射
        if(munmap(ptr_data, mmap_memory_size) == -1){
            perror("munmap failed");
        }
    }
    else{
        waitpid(pid, nullptr, 0);
        std::cout<<"fathre process read value is : "<<(*ptr_data)<<std::endl;
        if(munmap(ptr_data, mmap_memory_size) == -1){
            perror("munmap failed");
        }
    }
}

int main(){
    test2();
    return 0;
}

信号量

信号量是用于进程间同步和互斥的一种通信方式，用于控制对共享资源的访问，防止多个进程同时访问共享资源导致的数据竞争和一致性问题。信号量通常作为一种计数器，在多个进程之间共享，用于管理对共享资源的访问。

semget

semget 函数是Unix类操作系统中的System V IPC（进程间通信）调用之一，用于创建新的信号量集或获取与现有信号量集相关联的信号量集标识符。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int num_sems, int sem_flags);

key：用作信号量集标识符的键。通常使用 ftok 函数生成该键。
nsems：信号量集中的信号量数量。在创建新的信号量集时使用此参数。
semflg：指示操作模式的标志（例如权限）。它是标志的按位或，通常包括 IPC_CREAT，如果要创建信号量集的话。
semget 的返回值是信号量集标识符（一个非负整数），成功时为正值，失败时为 -1。

// -----------------------------------
- 第一个参数key是整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget()函数并提供一个键，再由系统生成一个相应的信号标识符（semget()函数的返回值），只有semget()函数才直接使用信号量键，所有其他的信号量函数使用由semget()函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。
- 第二个参数num_sems指定需要的信号量数目，它的值几乎总是1。
- 第三个参数sem_flags是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT  | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。
- semget()函数成功返回一个相应信号标识符（非零），失败返回-1.

semop

semop 函数是 System V IPC（Inter-Process Communication，进程间通信）中用于进行信号量操作的系统调用。信号量是一种用于进程间同步和互斥的机制。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned int nsops);

semid：信号量集的标识符，由 semget 返回。
sops：指向 sembuf 结构数组的指针，每个结构描述一个信号量操作。
nsops：指定了 sops 数组中结构的数量。

struct sembuf {
    short sem_num;  // 信号量在信号量集中的索引
    short sem_op;   // 信号量操作，通常是 -1（P 操作）, 1（V 操作），或 0（等待为0）
    short sem_flg;  // 操作标志，通常设置为 SEM_UNDO
};

semop 允许对一个或多个信号量进行一系列操作。在多进程环境中，semop 是用于同步进程和实现互斥的关键工具。

semctl

semctl 函数是 System V IPC（Inter-Process Communication，进程间通信）中用于对信号量集进行控制操作的系统调用。它提供了对信号量集的各种管理和配置功能。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semctl(int semid, int semnum, int cmd, ...);

semid：信号量集的标识符，由 semget 返回。
semnum：指定信号量在信号量集中的索引，通常为 0（对整个信号量集进行操作）。
cmd：控制命令，用于指定要执行的操作。
semctl 的控制命令 cmd 可以是以下之一：
    IPC_STAT：获取信号量的状态信息，包括信号量的值、进程数等。
    IPC_SET：设置信号量的状态信息，通常与 sembuf 结构一起使用。
    IPC_RMID：删除整个信号量集。

// 自定义第四个参数，主要设置命令
union semun{
    int val;                //  SETVAL，设置信号量的值
    struct semid_ds *buf;
    unsigned short *array;
};
struct semid_ds {
    struct ipc_perm sem_perm;   // 信号量的权限
    time_t sem_otime;            // 最后一次操作的时间
    unsigned long sem_nsems;     // 信号量集中的信号量数量
};

案例

#include <iostream>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
#include <cstdlib>
#include <cstring>

// --- # 使用信号量进行进程间的通信 ---- //

// 推荐命令格式（semctl）
union semun{
    int val;                //  SETVAL，设置信号量的值
    struct semid_ds *buf;
    unsigned short *array;
};

// 初始化信号量
int init_sem(int semid, int sem_num, int init_val){
    union semun arg;
    arg.val = init_val;
    return semctl(semid, sem_num, SETVAL, arg);
}

// P操作，减小信号量操作
void sem_wait(int semid, int sem_num){
    struct sembuf sem_op = {sem_num, -1, SEM_UNDO};
    semop(semid, &sem_op, 1);
}

// V操作，增加信号量操作
void sem_signal(int semid, int sem_num){
    struct sembuf sem_op = {sem_num, 1, SEM_UNDO};
    semop(semid, &sem_op, 1);
}


int main(){

    // 1. 生成键
    key_t key = ftok("shmget_file", 'A');
    if (key == -1) {
        perror("ftok");
        return EXIT_FAILURE;
    }

    // 2. 创建信号量集
    int semid = semget(key, 1, IPC_CREAT | 0666);
     if (semid == -1) {
        perror("semget");
        exit(EXIT_FAILURE);
    }

    // 3. 初始化信号量集
    if(init_sem(semid, 0, 1) == -1){
        perror("init_sem");
        exit(EXIT_FAILURE);
    }

    // 4. 进程间通信
    pid_t pid = fork();
    if(pid == -1){
        perror("fork");
        exit(EXIT_FAILURE);
    }
    else if(pid == 0){
        sem_wait(semid, 0);    // 等待信号量
        std::cout << "Child process: Accessing shared resource." << std::endl;
        sleep(2);
        std::cout << "Child process: Done accessing shared resource." << std::endl;
        sem_signal(semid, 0);  // 释放信号量
    }
    else{
         // 父进程
        sem_wait(semid, 0);  // 等待信号量
        std::cout << "Parent process: Accessing shared resource." << std::endl;
        // 进行一些工作，模拟对共享资源的访问
        sleep(2);
        std::cout << "Parent process: Done accessing shared resource." << std::endl;
        sem_signal(semid, 0);  // 释放信号量
    }

    // 5. 删除信号量集
    if(semctl(semid, 0, IPC_RMID) == -1) {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    return 0;
}

共享内存

共享内存是一种允许多个进程共享同一块物理内存区域的IPC方式。相较于其他IPC方式，共享内存的优势在于速度快，因为进程可以直接读写共享内存而无需复制数据，但同时需要额外的同步机制来避免数据竞争和冲突。

shmget

shmget 函数是 System V IPC（Inter-Process Communication，进程间通信）中用于创建或获取共享内存段的系统调用。它返回一个标识符，该标识符用于后续的共享内存操作。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

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

key：一个键值，通常由 ftok 函数生成，用于标识共享内存段。
size：共享内存段的大小（以字节为单位）。
shmflg：标志，用于指定创建共享内存段时的选项，例如权限和创建标志。
返回值是共享内存标识符（非负整数）或 -1（表示失败）。

    // ---------------------------------------------------
- 第一个参数，与信号量的semget函数一样，程序需要提供一个参数key（非0整数），它有效地为共享内存段命名，shmget()函数成功时返回一个与key相关的共享内存标识符（非负整数），用于后续的共享内存函数。调用失败返回-1.
- 不相关的进程可以通过该函数的返回值访问同一共享内存，它代表程序可能要使用的某个资源，程序对所有共享内存的访问都是间接的，程序先通过调用shmget()函数并提供一个键，再由系统生成一个相应的共享内存标识符（shmget()函数的返回值），只有shmget()函数才直接使用信号量键，所有其他的信号量函数使用由semget函数返回的信号量标识符。
- 第二个参数，size以字节为单位指定需要共享的内存容量
- 第三个参数，shmflg是权限标志，它的作用与open函数的mode参数一样，如果要想在key标识的共享内存不存在时，创建它的话，可以与IPC_CREAT做或操作。共享内存的权限标志与文件的读写权限一样，举例来说，0644,它表示允许一个进程创建的共享内存被内存创建者所拥有的进程向共享内存读取和写入数据，同时其他用户创建的进程只能读取共享内存。

shmat

shmat 函数用于将共享内存段连接到调用进程的地址空间，返回共享内存段的起始地址。

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

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

shmid：共享内存标识符，由 shmget 返回。
shmaddr：指定将共享内存连接到进程地址空间的位置，通常设置为 NULL，由系统选择合适的位置。
shmflg：标志，通常设置为 0。
返回值是共享内存段的起始地址（void * 类型），或者在连接失败时返回 (void *) -1。

shmdt

shmdt 函数用于将共享内存段从调用进程的地址空间分离

#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);

shmaddr：指向共享内存段起始地址的指针。
返回值为 0 表示成功，-1 表示失败。

shmctl

shmctl 函数是 System V IPC（Inter-Process Communication，进程间通信）中用于对共享内存进行控制操作的系统调用。它提供了一系列的操作，包括获取共享内存的状态信息、设置权限、删除共享内存等。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

shmid：共享内存标识符，由 shmget 返回。
cmd：控制命令，用于指定要执行的操作。
    IPC_STAT：获取共享内存的状态信息。
    IPC_SET：设置共享内存的状态信息，需要提供 shmid_ds 结构。
    IPC_RMID：删除共享内存。
buf：指向 shmid_ds 结构的指针，用于传递或接收共享内存的状态信息。

struct shmid_ds {
    struct ipc_perm shm_perm;  // 共享内存的权限
    size_t          shm_segsz; // 共享内存的大小（字节数）
    time_t          shm_atime; // 上一次被连接的时间
    time_t          shm_dtime; // 上一次被分离的时间
    time_t          shm_ctime; // 上一次被修改的时间
    pid_t           shm_cpid;  // 创建共享内存的进程ID
    pid_t           shm_lpid;  // 上一次执行 `shmat` 或 `shmdt` 的进程ID
    unsigned short  shm_nattch; // 连接到共享内存的进程数
};

案例

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <cstring>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>


// --- # 共享内存测试 ---- //

// 设置共享内存数据结构
struct SharedData{
    std::mutex mutex;
    char message[1024];
};

// 用于写入数据到共享内存
void writeData(SharedData &sharedData, const char* message){
    std::lock_guard<std::mutex> lock(sharedData.mutex);
    std::strncpy(sharedData.message, message, sizeof(sharedData.message) -1);
}

// 用于从共享内存中读取数据
std::string readData(SharedData &sharedData){
    std::lock_guard<std::mutex> lock(sharedData.mutex);
    return sharedData.message;
}

int main(){

    // 1. 生成键
    // key_t key = ftok("sem_file", 'A');
    // if (key == -1) {
    //     perror("ftok");
    //     return EXIT_FAILURE;
    // }
    key_t key = 1234;

    // 2. 创建并获取共享内存段
    int shmid = shmget(key, sizeof(SharedData), IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        return EXIT_FAILURE;
    }

    // 3. 连接共享内存段
    void *shm_ptr = shmat(shmid, nullptr, 0);
    if(shm_ptr == (void*)(-1)){
        perror("shmat");
        return EXIT_FAILURE;
    }

    // 4. 创建共享内存数据结构对象
    SharedData* sharedData = static_cast<SharedData*>(shm_ptr);

    // 5. 启动写进程
    std::thread writer([&sharedData]{
        writeData(*sharedData, "writer process write data to shared memory");
    });

    // 6. 启动读进程
    std::thread reader([&sharedData]{
        std::this_thread::sleep_for(std::chrono::seconds(2));
        std::string message = readData(*sharedData);
        std::cout<<"reader process read data is : "<<message<<std::endl;
    });

    writer.join();
    reader.join();

    // 7. 分离共享内存段
    if(shmdt(shm_ptr) == -1){
        perror("shmdt");
        return EXIT_FAILURE;
    }
    return 0;
}

消息队列

消息队列是一种进程间通信（IPC）机制，允许不同进程之间通过发送和接收消息来进行通信。它提供了一种异步的通信方式，允许进程按照特定的消息格式发送和接收消息，无需直接关注目标进程的状态，从而实现解耦和高效的通信。

msgget

msgget 是 System V IPC 中用于创建或获取消息队列的系统调用。消息队列是一种进程间通信的机制，允许不同进程之间通过消息进行数据交换。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgget(key_t key, int msgflg);

key：一个键值，通常由 ftok 函数生成，用于标识消息队列。
msgflg：标志，用于指定创建消息队列时的选项，例如权限和创建标志。
返回值是消息队列标识符（非负整数）或 -1（表示失败）。
    
    // --------------------------
- 与其他的IPC机制一样，程序必须提供一个键来命名某个特定的消息队列。msgflg是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或操作，表示当key所命名的消息队列不存在时创建一个消息队列，如果key所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符。
- 它返回一个以key命名的消息队列的标识符（非零整数），失败时返回-1.

msgsnd

msgsnd 是 System V IPC 中用于向消息队列发送消息的系统调用。它允许一个进程将消息发送到指定的消息队列。

#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：消息队列标识符，由 msgget 返回。
msgp：指向包含消息数据的结构体的指针。
msgsz：消息数据的大小（字节数）。
msgflg：标志，用于指定发送消息的选项。
返回值是 0 表示成功，-1 表示失败。
    
    // -----------------------
msg_ptr是一个指向准备发送消息的指针，但是消息的数据结构却有一定的要求，指针msg_ptr所指向的消息结构一定要是以一个长整型成员变量开始的结构体，接收函数将用这个成员来确定消息的类型。
struct my_message {
    long int message_type;
    /* The data you wish to transfer */
};
- msg_sz 是msg_ptr指向的消息的长度，注意是消息的长度，而不是整个结构体的长度，也就是说msg_sz是不包括长整型消息类型成员变量的长度。
- msgflg 用于控制当前消息队列满或队列消息到达系统范围的限制时将要发生的事情。
- 如果调用成功，消息数据的一分副本将被放到消息队列中，并返回0，失败时返回-1.

msgrcv

msgrcv 是 System V IPC 中用于从消息队列接收消息的系统调用。它允许一个进程从指定的消息队列中接收消息

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

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

msqid：消息队列标识符，由 msgget 返回。
msgp：指向用于接收消息数据的结构体的指针。
msgsz：消息数据的大小（字节数）。
msgtyp：消息类型，指定要接收的消息的类型。如果为 0，则接收队列中的第一个消息。
msgflg：标志，用于指定接收消息的选项。
返回值是接收到的消息数据的大小，-1 表示失败。
    
    // -----------------------
- msgid, msg_ptr, msg_st 的作用也函数msgsnd()函数的一样。
- msgtype 可以实现一种简单的接收优先级。如果msgtype为0，就获取队列中的第一个消息。如果它的值大于零，将获取具有相同消息类型的第一个信息。如果它小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。
- msgflg 用于控制当队列中没有相应类型的消息可以接收时将发生的事情。
- 调用成功时，该函数返回放到接收缓存区中的字节数，消息被复制到由msg_ptr指向的用户分配的缓存区中，然后删除消息队列中的对应消息。失败时返回-1。

msgctl

msgctl 是 System V IPC 中用于控制消息队列的系统调用。它提供了一些功能，包括获取和设置消息队列的属性，以及删除消息队列等。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

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

msqid：消息队列标识符，由 msgget 返回。
cmd：命令，用于指定要执行的操作，如获取属性、设置属性、删除队列等。
buf：指向 msqid_ds 结构体的指针，用于传递或接收消息队列的属性。
返回值是根据命令的不同而有所变化，通常为 0 表示成功，-1 表示失败。
    以下是一些常用的 msgctl 命令：
        IPC_STAT：获取消息队列的属性。
        IPC_SET：设置消息队列的属性。
        IPC_RMID：删除消息队列。

案例

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <wait.h>


// --- # 使用消息队列进行进程通信 ---- //

// 存放数据的结构体
struct Message{
    long mtype; // message type
    char mtext[1024]; 
};

int main(){
    key_t key = 1234;

    // 1. 创建消息队列
    int msqid = msgget(key, IPC_CREAT | 0666);
    if (msqid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    // 2. 发送进程向队列发送消息
    pid_t pid = fork();
    if(pid == -1){
        perror("fork");
        exit(EXIT_FAILURE);
    }
    else if(pid == 0){
        
        // 设置message
        Message message;
        message.mtype = 1;
        std::strcpy(message.mtext, "sender send data");
        if(msgsnd(msqid, &message, sizeof(message.mtext), 0) == -1){
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }
        std::cout << "Message sent by sender." << std::endl;
        exit(EXIT_SUCCESS);  // 子进程退出
    }

    // 3. 接收进程从队列中接收消息
    Message message_recv;
    if(msgrcv(msqid, &message_recv, sizeof(message_recv.mtext), 1, 0) == -1){
        perror("msgrcv");
        exit(EXIT_FAILURE);
    }
    std::cout << "Received message: " << message_recv.mtext << std::endl;

    waitpid(pid, nullptr, 0);

    // 4. 删除消息队列
    if(msgctl(msqid, IPC_RMID, nullptr) == -1){
        perror("msgctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

信号

signal

#include <signal.h>

typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

用于设置对特定信号的处理函数。
signum：指定要处理的信号。
handler：是一个函数指针，指向用于处理信号的函数。
返回值：返回以前的信号处理函数的地址。

kill

#include <signal.h>

int kill(pid_t pid, int sig);

用于向指定进程发送信号。
pid：指定进程的ID。如果为正，表示具体的进程ID；如果为负，表示进程组ID；如果为0，表示发送给与调用进程属于同一进程组的所有进程；如果小于-1，表示发送给进程组ID为 abs(pid) 的所有进程。
sig：指定要发送的信号。

sigaction

#include <signal.h>

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

用于设置对特定信号的处理函数，提供更强大的信号处理机制。
signum：指定要处理的信号。
act：指定新的信号处理行为。
oldact：用于存储以前的信号处理行为。

案例

#include <iostream>
#include <csignal>
#include <unistd.h>
#include <sys/wait.h>

// 全局变量用于通信
volatile sig_atomic_t signalRecive = 0;

// 信号处理函数(子进程中断，先处理信号)
void signalHandler(int signum){
    if(signum == SIGUSR1){
        std::cout <<"["<<getpid()<<"]"<<" Received SIGUSR1 signal." << std::endl;
        signalRecive = 1;
    }
}

int main(){

    // 1. 设置信号处理函数
    signal(SIGUSR1, signalHandler);

    // 2. 创建子进程（接收信号），父进程发送信号
    pid_t pid = fork();

    if(pid == -1){
        perror("fork");
        return EXIT_FAILURE;
    }
    else if(pid == 0){
        
        // 等待父进程发送信号
        while(!signalRecive){
            usleep(100000);
        }
        std::cout<<"child pid is : "<<getpid()<<std::endl;
        std::cout <<"["<<getpid()<<"]"<<" Child process handling signal." << std::endl;  // 处理信号
        exit(EXIT_SUCCESS);
    }
    else{
        std::cout<<"father pid is : "<<getpid()<<std::endl;
        std::cout <<"["<<getpid()<<"]"<<" Parent process sending signal to child." << std::endl;
        kill(pid, SIGUSR1);
        waitpid(pid, nullptr, 0);
        std::cout << "Parent process exiting." << std::endl;
    }
    return 0;
}

moon-hoo

关注

16
点赞
踩
18

收藏

觉得还不错? 一键收藏
1
评论
进程间通信

进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信(IPC)
复制链接

扫一扫