进程间通信方式

2025-08-15 20:31:09 世界杯瑞典 5256

进程间通信

进程间通信方式：管道通信、信号、消息队列、共享内存、信号量组

一.管道通信

管道通信分为匿名管道以及有名管道（命名管道），匿名管道用于父进程与子进程之间(具有亲缘的进程之间)。命名管道可以用于非亲缘进程之间进行通信。

匿名管道（pipe）

特点：没有名称，所以无法使用open()来创建打开，但是支持read()和write()。pipe函数有一个参数pipefd（是一个数组类型，数组中有两个值）pipefd[0]记录管道读取端的文件描述符pipefd[1]记录管道写入端的文件描述符。当用户将数据写入管道时，数据是暂存在内核的缓冲区的（默认为4M大小）。

匿名管道读取写入实例

/*********************************************************************************

* @Description : 用于创建匿名管道并进行父子进程间的通信

* @Note :

* @retval : 程序退出状态码

* @Author : ice_cui

* @Date : 2025-05-11 21:12:32

* @Email : Lazypanda_ice@163.com

* @LastEditTime : 2025-05-11 21:34:25

* @Version : V1.0.0

**********************************************************************************/

#include

int main(int argc,char const *argv[])

{

int fd[2];//管道文件描述符 fd[0]读，fd[1]写

int ret = pipe(fd);//创建管道

if(ret == -1){

fprintf(stderr,

"pipe error,errno:%d,%s\n",

errno,strerror(errno));

return -1;

}

pid_t pid = fork();//创建子进程

if(pid == -1){

fprintf(stderr,

"fork error,errno:%d,%s\n",

errno,strerror(errno));

return -1;

}

if(pid == 0){//子进程

close(fd[1]);//关闭写端

char buf[20] = {0};

int len = read(fd[0],buf,sizeof(buf));//从管道中读取数据

if(len == -1){

fprintf(stderr,

"read error,errno:%d,%s\n",

errno,

strerror(errno));

return -1;

}

printf("child read:%s\n",buf);

close(fd[0]);//关闭读端

}

else{//父进程

close(fd[0]);//关闭读端

char *str = "hello world";

int len = write(fd[1],str,strlen(str));//向管道中写入数据

if(len == -1){

fprintf(stderr,

"write error,errno:%d,%s\n",

errno,strerror(errno));

return -1;

}

close(fd[1]);//关闭写端

wait(NULL);//等待子进程结束

}

return 0;

}

运行效果

gec@gec-virtaul machine:~/process$ ./pipe_test

child read:hello world

命名管道（fifo）

特点：命名管道有自己的名称，可以被open，同时也支持read/write，但管道无法进行指定位操作，即无法使用lseek操作。同匿名管道不同的是，没有亲缘关系的进程之间可以通过命名管道进行通信，并可以支持多路同时写入。

使用setTime.c获取当前系统时间并将数据写入命名管道

/*********************************************************************************

* @Description : 用于获取当前时间并向命名管道写入时间字符串。

* @Note :

* @retval : 程序退出状态码

* @Author : ice_cui

* @Date : 2025-05-11 15:45:02

* @Email : Lazypanda_ice@163.com

* @LastEditTime : 2025-05-11 22:04:49

* @Version : V1.0.0

**********************************************************************************/

#include

#define FIFO "/tmp/fifo"

int main(int argc, char const *argv[])

{

int ret = mkfifo(FIFO,0666);

if(ret == -1){

fprintf(stderr,"mkfifo error,errno=%d,%s\n",errno,strerror(errno));

return -1;

}

int fifo_fd = open(FIFO,O_RDWR);//打开管道

if(fifo_fd == -1){

fprintf(stderr,"open fifo error,errno=%d,%s\n",errno,strerror(errno));

return -1;

}

while (1)

{

time_t rawtime; // 用于存储当前时间的秒数

struct tm * timeinfo; // 用于存储转换后的时间结构

char time_str[40]; // 用于存储格式化后的时间字符串

// 获取当前时间

time(&rawtime);

timeinfo = localtime(&rawtime);

strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S\n", timeinfo); // 格式化时间

write(fifo_fd,time_str,strlen(time_str));//写入时间

sleep(1);

}

close(fifo_fd);//关闭管道

return 0;

}

使用getTime.c读取命名管道中的数据然后存入到log.txt文件中

/*********************************************************************************

* @Description : 用于从管道读取数据并写入日志文件

* @Note :

* @retval : 程序退出状态码

* @Author : ice_cui

* @Date : 2025-05-11 15:44:42

* @Email : Lazypanda_ice@163.com

* @LastEditTime : 2025-05-11 20:49:24

* @Version : V1.0.0

**********************************************************************************/

#include

#define FIFO "/tmp/fifo"

#define LOG_PATH "/tmp/log.txt"

int main(int argc, char const *argv[])

{

int log_fd = open(LOG_PATH,O_RDWR|O_CREAT,0666);//打开日志文件

if(log_fd == -1){

fprintf(stderr,"open log.txt error,errno=%d,%s\n",errno,strerror(errno));//打印错误信息

return -1;

}

int fifo_fd = open(FIFO,O_RDWR);//打开管道

if(fifo_fd == -1){

fprintf(stderr,"open fifo error,errno=%d,%s\n",errno,strerror(errno));//打印错误信息

return -1;

}

char time_buf[256] = {0};//定义一个缓冲区

while(1){

read(fifo_fd,time_buf,sizeof(time_buf));//读取管道中的数据

write(log_fd,time_buf,sizeof(time_buf));//写入数据

bzero(time_buf,sizeof(time_buf)); //清空缓冲区

sleep(1);

}

close(log_fd);//关闭日志文件

close(fifo_fd);//关闭管道

return 0;

}

运行效果

在/tmp目录下生成一个名为fifo的有名管道和一个log.txt文件打开文件里面生成如下内容

2025-05-18 14:40:25

2025-05-18 14:40:26

2025-05-18 14:40:27

2025-05-18 14:40:28

2025-05-18 14:40:29

2025-05-18 14:40:30

2025-05-18 14:40:31

2025-05-18 14:40:32

2025-05-18 14:40:33

2025-05-18 14:40:34

2025-05-18 14:40:35

2025-05-18 14:40:36

2025-05-18 14:40:37

二.信号

1.基本概念

信号：是一种异步通信机制，用于在操作系统中实现进程间的事件通知和简单控制。它是操作系统向进程发送的软件中断，用于指示某种事件（如程序错误、用户输入中断、定时器超时等）发生。

特点：

轻量级：仅传递事件类型（信号编号），不传递具体数据。

异步性：信号的发送和处理不具有严格的时序关系。

可靠性：早期 UNIX 信号（如 POSIX 前的信号）不可靠（可能丢失或重复），现代 POSIX 信号已改进可靠性。

2.信号的生命周期与处理流程

信号从产生到处理的完整流程如下：

信号产生：

由系统内核自动生成（如除零错误触发SIGFPE）。

由其他进程通过kill()函数发送（如kill -信号编号进程PID）。

由终端输入触发（如Ctrl+C触发SIGINT）。

信号传递：

内核将信号记录到目标进程的信号队列中（对于可靠信号，会维护多个相同信号；对于不可靠信号，可能合并或丢失）。

信号处理：

进程在特定时机（如从内核态返回用户态时）检测信号并执行对应处理动作。

处理动作有三种选择：

默认处理：由系统预设的行为（如终止进程、忽略信号等）。

忽略信号：进程不响应该信号（SIGKILL和SIGSTOP不可忽略）。

自定义处理函数：通过signal()或sigaction()函数注册信号处理函数。

3.关键函数与系统调用

1. kill()函数：发送信号

#include

int kill(pid_t pid, int sig);

参数：

pid：目标进程的 PID（若为0，则发送给同一进程组的所有进程）。

sig：要发送的信号编号（如SIGINT）或0（用于检测进程是否存在）。

返回值：

成功返回0，失败返回-1。

2. signal()函数：设置信号处理函数（简单接口）

#include

typedef void (*sighandler_t)(int);

sighandler_t signal(int sig, sighandler_t handler);

参数：

sig：信号编号。

handler：处理函数指针（如SIG_IGN表示忽略，SIG_DFL表示使用默认处理）。

注意：

该接口在 POSIX 标准中已被sigaction()取代，部分系统可能存在兼容性问题。

3. sigaction()函数：设置信号处理函数（推荐接口）

#include

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

参数：

sig：信号编号。

act：指向新处理动作的结构体指针。

oldact：指向存储旧处理动作的结构体指针（可设为NULL）。

struct sigaction结构体：

struct sigaction {

void (*sa_handler)(int); // 信号处理函数（或sa_sigaction）

void (*sa_sigaction)(int, siginfo_t *, void *); // 带参数的处理函数（用于可靠信号）

sigset_t sa_mask; // 处理信号时阻塞的其他信号集合

int sa_flags; // 标志位（如SA_RESTART、SA_SIGINFO等）

};

优势：支持可靠信号（传递额外信息）、信号掩码设置和更灵活的标志位控制。

4. alarm()与pause()函数：定时器与阻塞

alarm(unsigned int seconds)：设置定时器，到期后发送SIGALRM信号。

pause()：使进程阻塞直至收到信号（通常与alarm()配合使用）。

4.示例代码-自定义信号处理

#include

// 信号处理函数

void sig_handler(int signo) {

if (signo == SIGUSR1) {

printf("Received SIGUSR1!\n");

} else if (signo == SIGINT) {

printf("Caught SIGINT, exiting...\n");

_exit(0); // 避免标准IO缓冲区未刷新

}

int main() {

// 注册信号处理函数

signal(SIGUSR1, sig_handler);

signal(SIGINT, sig_handler);

printf("Process PID: %d\n", getpid());

printf("Wait for signals...\n");

while (1) {

sleep(1); // 阻塞并等待信号

}PID

return 0;

}

测试运行

1.运行程序，使用ipcs指令查看当前进程PID并记录 PID。

2.发送自定义信号：kill -SIGUSR1 ，程序将输出Received SIGUSR1!。

3.发送中断信号：kill -SIGINT 或按下Ctrl+C，程序将退出。

总结：信号是进程间通信中最轻量级的机制，适用于事件通知和简单控制，但不适合大数据量传输。在使用时需注意信号的可靠性、阻塞机制和异步安全问题，合理利用sigaction()等接口实现健壮的信号处理逻辑。

5.信号屏蔽（Signal Masking）详解

信号屏蔽是操作系统中用于控制信号处理时机的机制，允许进程暂时阻塞某些信号的传递和处理。这在需要保证关键代码段不被中断的场景中尤为重要。

1.基本概念

信号掩码（Signal Mask）

每个进程都有一个信号掩码（本质是一个位图），用于指定哪些信号当前被阻塞。

被掩码的信号不会被进程立即处理，而是在掩码解除后才被处理（如果期间信号被发送多次，通常只处理一次）。

阻塞 vs 忽略

阻塞：信号被暂时挂起，不立即处理，但仍会记录信号的到达。

忽略：信号被直接丢弃，不会被处理（通过 signal(SIGXXX, SIG_IGN) 设置）。

2.核心函数

1. 设置信号掩码：sigprocmask()

#include

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

参数：

how：操作类型，可选：

SIG_BLOCK：将 set 中的信号添加到当前掩码。

SIG_UNBLOCK：从当前掩码中移除 set 中的信号。

SIG_SETMASK：用 set 替换当前掩码。

set：指向信号集的指针（通过 sigemptyset()/sigfillset() 等函数初始化）。

oldset：用于保存旧的信号掩码（可设为 NULL）。

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

2. 初始化信号集：sigemptyset()/sigfillset()

#include

int sigemptyset(sigset_t *set); // 清空信号集（所有位为0）

int sigfillset(sigset_t *set); // 填充信号集（所有位为1）

int sigaddset(sigset_t *set, int signum); // 添加单个信号

int sigdelset(sigset_t *set, int signum); // 删除单个信号

int sigismember(const sigset_t *set, int signum); // 检查信号是否在集合中

3. 检查和获取挂起的信号：sigpending()

#include

int sigpending(sigset_t *set);

作用：将当前被阻塞（挂起）的信号集存入 set 中。

3.典型应用场景

1.保护关键代码段

在执行不可中断的操作（如共享资源的修改）时，暂时阻塞某些信号。

2.避免竞态条件

在信号处理函数和主程序之间同步时，防止信号在不适当的时机到达。

3.资源清理阶段

在释放重要资源（如文件锁、内存）时，确保不会被信号中断。

4.示例代码：信号屏蔽的基本用法

#include

void signal_handler(int signo) {

printf("Caught signal %d\n", signo);

}

int main() {

sigset_t new_mask, old_mask, pending_mask;

// 注册信号处理函数

signal(SIGINT, signal_handler); // Ctrl+C

signal(SIGUSR1, signal_handler); // 自定义信号

// 初始化信号集，添加SIGINT和SIGUSR1

sigemptyset(&new_mask);

sigaddset(&new_mask, SIGINT);

sigaddset(&new_mask, SIGUSR1);

// 阻塞SIGINT和SIGUSR1

if (sigprocmask(SIG_BLOCK, &new_mask, &old_mask) == -1) {

perror("sigprocmask failed");

return 1;

}

printf("SIGINT and SIGUSR1 are now blocked. Try sending them...\n");

printf("PID: %d\n", getpid());

sleep(10); // 在此期间发送的SIGINT和SIGUSR1会被阻塞

// 检查挂起的信号

if (sigpending(&pending_mask) == -1) {

perror("sigpending failed");

return 1;

}

if (sigismember(&pending_mask, SIGINT)) {

printf("SIGINT is pending (blocked but not processed).\n");

}

if (sigismember(&pending_mask, SIGUSR1)) {

printf("SIGUSR1 is pending (blocked but not processed).\n");

}

// 解除阻塞

if (sigprocmask(SIG_SETMASK, &old_mask, NULL) == -1) {

perror("sigprocmask failed");

return 1;

}

printf("SIGINT and SIGUSR1 are no longer blocked.\n");

printf("Sleeping for another 10 seconds...\n");

sleep(10); // 在此期间发送的信号会被立即处理

return 0;

}

5.注意事项

1.不可屏蔽的信号

SIGKILL 和 SIGSTOP 无法被屏蔽或忽略，用于确保系统能强制终止进程。

2.信号处理函数中的屏蔽

当信号处理函数执行时，该信号会自动被添加到进程的信号掩码中（防止递归调用）。

3.恢复旧掩码

使用 sigprocmask 时，建议保存旧掩码并在适当时候恢复，避免意外阻塞其他信号。

4.原子性操作

在解除信号屏蔽的同时检查信号是危险的，可使用 sigwait() 等函数实现原子操作。

6.高级技巧：安全地处理信号

使用 sigprocmask 和 sigwait() 实现信号的同步处理：

#include

int main() {

sigset_t mask;

int signo;

// 阻塞SIGINT和SIGUSR1

sigemptyset(&mask);

sigaddset(&mask, SIGINT);

sigaddset(&mask, SIGUSR1);

if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {

perror("sigprocmask failed");

return 1;

}

printf("Waiting for SIGINT or SIGUSR1...\n");

// 原子性地等待信号

while (1) {

if (sigwait(&mask, &signo) == -1) {

perror("sigwait failed");

return 1;

}

switch (signo) {

case SIGINT:

printf("Caught SIGINT via sigwait(). Exiting...\n");

return 0;

case SIGUSR1:

printf("Caught SIGUSR1 via sigwait(). Continuing...\n");

break;

default:

printf("Unexpected signal %d\n", signo);

}

三.消息队列

消息队列（Message Queue）是一种经典的进程间通信（IPC）方式，允许不同进程通过发送和接收消息进行数据交换。它以队列形式存储消息，具备以下特点：

异步通信：发送方和接收方无需同时运行，消息可在队列中暂存。

消息类型：每条消息带有类型标签，接收方可以按类型选择性读取（而非先进先出）。

系统管理：由操作系统内核维护，独立于进程存在（进程退出后队列可保留）。

1.核心概念与原理

1.消息结构

消息由类型（long）和数据（正文）组成，通常通过结构体定义：

struct msgbuf {

long mtype; // 消息类型（必须 > 0）

char mtext[XXX]; // 消息正文（消息类型自定义、长度自定义）

};

2.内核中的消息队列

操作系统通过内核数据结构管理消息队列，每个队列包含：

1.队列 ID（唯一标识）

2.消息计数、队列字节数

3.访问权限（类似文件权限，控制读写权限）

2.消息队列的操作流程（Linux 系统）

在 Linux 中，消息队列通过 System V IPC 接口实现，主要函数包括：

msgget()、msgsnd()、msgrcv()、msgctl()。

创建 / 打开消息队列：msgget()

#include

int msgget(key_t key, int msgflg);

参数：

key：唯一键值（通常由 ftok() 函数生成，用于标识队列）。

ftok()第一个参数是文件路径，第二个参数是项目ID（1-255）

msgflg：标志位（如 IPC_CREAT 表示创建新队列，0666 表示权限）。

返回值：成功返回队列 ID，失败返回 -1。

示例：

key_t key = ftok("/tmp/myfile", 'A'); // 生成唯一键值

int msqid = msgget(key, 0666 | IPC_CREAT); // 创建队列（权限 0666）

发送消息：msgsnd()

#include

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

参数：

msqid：队列 ID。

msgp：指向消息结构体的指针（需包含 mtype 和 mtext）。

msgsz：消息正文的字节数（不包含 mtype 的长度）。

msgflg：标志位（如 IPC_NOWAIT 表示非阻塞发送）。

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

示例：

struct msgbuf msg = {

.mtype = 1, // 消息类型为 1

.mtext = "Hello, Message Queue!"

};

msgsnd(msqid, &msg, sizeof(msg.mtext), 0); // 阻塞发送消息

接收消息：msgrcv()

#include

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

参数：

mtype：期望接收的消息类型，可取值：

等于0：接收任意类型的第一条消息。

大于0：接收类型等于 mtype 的第一条消息。

小于0：接收类型小于等于 abs(mtype) 的最小类型消息。

msgflg：标志位（如 IPC_NOWAIT 表示非阻塞接收，MSG_EXCEPT 表示接收类型不等于 mtype 的消息）。

返回值：成功返回消息正文长度，失败返回 -1。

示例：

struct msgbuf msg;

msgrcv(msqid, &msg, sizeof(msg.mtext), 1, 0); // 阻塞接收类型为 1 的消息

printf("Received: %s\n", msg.mtext);

控制队列：msgctl()

#include

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

常用 cmd：

IPC_STAT：获取队列状态（存储于 buf 中）。

IPC_SET：设置队列属性（如权限）。

IPC_RMID：删除队列（buf 可为 NULL）。

示例：删除队列

msgctl(msqid, IPC_RMID, NULL); // 立即标记队列 for deletion（无进程使用时真正删除）

3.示例：简单的消息队列通信

发送方（sender.c）

#include

struct msgbuf {

long mtype;

char mtext[100];

};

int main() {

key_t key = ftok("msgq.c", 'A');

int msqid = msgget(key, 0666 | IPC_CREAT);

struct msgbuf msg = {.mtype = 1, .mtext = "Hello from sender!"};

msgsnd(msqid, &msg, strlen(msg.mtext), 0);

printf("Message sent: %s\n", msg.mtext);

return 0;

}

接收方（receiver.c）

#include

struct msgbuf {

long mtype;

char mtext[100];

};

int main() {

key_t key = ftok("msgq.c", 'A');

int msqid = msgget(key, 0666);

struct msgbuf msg;

msgrcv(msqid, &msg, sizeof(msg.mtext), 1, 0);

printf("Received: %s\n", msg.mtext);

// 清理队列（仅演示，实际中按需保留）

msgctl(msqid, IPC_RMID, NULL);

return 0;

}

编译与运行：

gcc sender.c -o sender

gcc receiver.c -o receiver

./sender & # 后台运行发送方

./receiver # 前台运行接收方（输出消息）

4.注意事项

消息大小限制：

Linux 中单个消息最大为 MSGMAX（通常为 8192 字节），队列总大小为 MSGMNB（通常为 16384 字节），可通过 sysctl kernel.msgmax 等命令查看 / 修改。

阻塞与非阻塞：

未指定 IPC_NOWAIT 时，msgsnd() 和 msgrcv() 会阻塞等待（队列满或无消息时）。

内存泄漏：

主动调用 msgctl(IPC_RMID) 删除不再使用的队列，避免内核资源泄漏。

权限问题：

确保进程对队列有读写权限（通过 msgget 的权限参数或 chmod 调整）。

四.共享内存

共享内存是一种高效的进程间通信（IPC）机制，允许多个进程直接访问同一块物理内存区域。这种方式避免了数据在进程间的复制，显著提高了通信效率。

1.核心概念

工作原理:

内核创建一块物理内存区域，并将其映射到多个进程的虚拟地址空间中。

进程通过各自的虚拟地址直接读写共享内存，无需通过内核中转。

关键特点

高效性：避免了用户空间与内核空间之间的数据拷贝（相比管道、消息队列等方式）。

同步问题：需要额外的同步机制（如信号量、互斥锁）来协调对共享内存的访问。

生命周期：独立于进程存在，需手动释放（除非设置为随最后一个进程自动销毁）。

2.共享内存的实现方式

1. POSIX 共享内存（推荐）

POSIX 标准提供了更现代、更灵活的共享内存接口，推荐优先使用。

1. 创建 / 打开共享内存对象：shm_open()

#include

int shm_open(const char *name, int oflag, mode_t mode);

参数：

name：共享内存对象名称（以/开头，如"/my_shm"）。

oflag：标志位（如O_CREAT | O_RDWR表示创建并读写）。

mode：权限位（如0666表示所有用户可读可写）。

返回值：成功返回文件描述符，失败返回-1。

示例：

int fd = shm_open("/my_shared_memory", O_CREAT | O_RDWR, 0666);

2. 删除共享内存对象：shm_unlink()

#include

int shm_unlink(const char *name);

作用：标记共享内存对象待删除（实际删除发生在所有进程解除映射后）。

示例：

shm_unlink("/my_shared_memory");

3. 设置共享内存大小：ftruncate()

#include

int ftruncate(int fd, off_t length);

参数：

fd：shm_open()返回的文件描述符。

length：共享内存大小（字节）。

示例：

ftruncate(fd, 4096); // 设置为4KB

4. 内存映射：mmap()

#include

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

参数：

addr：映射地址（通常设为NULL，由系统自动分配）。

length：映射长度（需与ftruncate设置一致）。

prot：保护权限（如PROT_READ | PROT_WRITE）。

flags：标志位（如MAP_SHARED表示修改对其他进程可见）。

fd：文件描述符。

offset：偏移量（通常为0）。

返回值：成功返回映射区域的起始地址，失败返回MAP_FAILED。

示例：

char *data = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

5. 解除映射：munmap()

#include

int munmap(void *addr, size_t length);

作用：解除内存映射，但不删除共享内存对象。

示例：

munmap(data, 4096);

函数使用流程：

#include

// 创建或打开共享内存对象

int shm_open(const char *name, int oflag, mode_t mode);

// 删除共享内存对象（实际释放需等所有进程解除映射）

int shm_unlink(const char *name);

// 映射内存区域

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

// 解除映射

int munmap(void *addr, size_t length);

1、创建或打开共享内存对象（shm_open）。

2、设置对象大小（ftruncate）。

3、将内存映射到进程的地址空间（mmap）。

4、读写共享内存。

5、解除映射（munmap）并删除对象（shm_unlink）。

2. System V 共享内存（传统方式）

System V 标准提供的传统共享内存接口，兼容性强但使用较复杂。

1. 创建 / 获取共享内存段：shmget()

#include

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

参数：

key：唯一键值（由ftok()生成或使用IPC_PRIVATE）。

size：共享内存大小（字节）。

shmflg：标志位（如IPC_CREAT | 0666）。

返回值：成功返回共享内存 ID，失败返回-1。

示例：

key_t key = ftok("/tmp/myfile", 'A');

int shmid = shmget(key, 4096, IPC_CREAT | 0666);

2. 附加共享内存：shmat()

#include

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

参数：

shmid：共享内存 ID。

shmaddr：映射地址（通常设为NULL）。

shmflg：标志位（如SHM_RDONLY表示只读）。

返回值：成功返回映射地址，失败返回(void*)-1。

示例：

char *data = shmat(shmid, NULL, 0);

3. 分离共享内存：shmdt()

#include

int shmdt(const void *shmaddr);

作用：断开进程与共享内存的连接。

示例：

shmdt(data);

4. 控制共享内存：shmctl()

#include

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

常用cmd：

IPC_RMID：删除共享内存段（实际删除发生在所有进程分离后）。

IPC_STAT：获取共享内存状态。

示例：

shmctl(shmid, IPC_RMID, NULL);

函数使用流程：

#include

// 创建或获取共享内存段

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

// 连接共享内存段到进程地址空间

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

// 断开共享内存连接

int shmdt(const void *shmaddr);

// 控制共享内存段（如删除）

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

1、创建或获取共享内存段（shmget）。

2、将内存段附加到进程地址空间（shmat）。

3、读写共享内存。

4、分离内存段（shmdt）。

5、删除共享内存段（shmctl）。

3.POSIX vs System V 共享内存

特性

POSIX 共享内存

System V 共享内存

接口风格

基于文件描述符（更现代）

基于 ID（传统）

创建方式

通过名称（如"/my_shm"）

通过键值（ftok()或IPC_PRIVATE）

删除时机

立即标记删除（所有进程解除映射后生效）

需显式调用shmctl(IPC_RMID)

同步支持

需配合信号量或互斥锁

需配合信号量

可移植性