内存映射与内存锁详解

Linux内存映射相关系统调用详解

内存映射是Linux系统中高效管理内存和文件的核心机制之一。通过将文件或设备直接映射到进程的虚拟地址空间，程序可以像访问内存一样操作数据，避免了频繁的用户态与内核态切换。本文将详细介绍与内存映射相关的系统调用，包括其功能、参数及使用细节。

1. mmap()：创建内存映射

功能：将文件或匿名内存区域映射到进程的虚拟地址空间，支持文件I/O（共享文件映射）、共享内存（共享匿名映射）、动态内存（私有匿名映射）分配等场景。

函数声明：

#include <sys/mman.h>  
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);  

参数详解：
• addr：建议映射的起始地址，通常设为NULL由内核自动分配。
• length：映射区域的长度，需按页大小对齐（通常4KB）。
• prot：内存保护标志，通过位或组合以下宏：
• PROT_READ：可读。
• PROT_WRITE：可写。
• PROT_EXEC：可执行。
• PROT_NONE：不可访问。
• flags：映射类型和属性，常用宏包括：
• MAP_PRIVATE：私有映射，修改仅对当前进程可见（写时复制），不同进程使用时各自copy一份，若是私有文件映射则不会被写入磁盘。
• MAP_SHARED：直接使用，无需copy，与私有映射二选一。
• MAP_ANONYMOUS：匿名映射，不关联文件，内容初始化为零，当然默认是文件映射。
• MAP_FIXED：强制使用指定地址，可能导致现有映射被覆盖。
• fd：文件描述符，匿名映射时设为-1。
• offset：文件映射的起始偏移量，需为页大小的整数倍。

返回值：
• 成功返回映射区域的起始地址。
• 失败返回MAP_FAILED，并设置errno（如EACCES权限不足、ENOMEM内存不足）。

2. munmap()：解除内存映射

功能：删除指定虚拟地址范围内的内存映射，释放相关资源。

函数声明：

#include <sys/mman.h>  
int munmap(void *addr, size_t length);  

参数说明：
• addr：映射区域的起始地址，必须与mmap()返回的地址一致。
• length：需解除映射的区域长度，无需严格对齐，但内核按页对齐处理。

返回值：
• 成功返回0。
• 失败返回-1，并设置errno（如EINVAL无效地址或长度）。

3. mprotect()：修改内存保护权限

功能：调整已映射内存区域的访问权限（如将只读区域改为可写）。

函数声明：

#include <sys/mman.h>  
int mprotect(void *addr, size_t len, int prot);  

参数说明：
• addr和len：需调整的地址范围，必须对齐页大小。
• prot：与mmap()的prot参数相同，支持PROT_READ、PROT_WRITE等组合。

返回值：
• 成功返回0。
• 失败返回-1，并设置errno（如EACCES权限冲突）。

4. msync()：同步内存与文件内容

功能：将映射内存的修改同步到文件，确保数据持久化。

函数声明：

#include <sys/mman.h>  
int msync(void *addr, size_t length, int flags);  

参数说明：
• addr和length：需同步的内存区域。
• flags：同步模式，可选宏：
• MS_SYNC：同步写入磁盘，调用阻塞直到完成。
• MS_ASYNC：异步写入，仅将数据排队到写入队列。
• MS_INVALIDATE：使其他进程的映射缓存失效。

返回值：
• 成功返回0。
• 失败返回-1，并设置errno（如EIO写入错误）。

5. madvise()：提供内存访问建议（高级优化）

功能：向内核提供内存访问模式的提示，以优化页面缓存和预读策略。

函数声明：

#include <sys/mman.h>  
int madvise(void *addr, size_t length, int advice);  

参数说明：
• addr和length：目标内存区域。
• advice：建议类型，常用选项包括：
• MADV_NORMAL：默认策略，适度预读。
• MADV_RANDOM：随机访问，禁用预读。
• MADV_SEQUENTIAL：顺序访问，积极释放已访问页。
• MADV_DONTNEED：提示内核可释放相关物理页。

返回值：
• 成功返回0。
• 失败返回-1，并设置errno。

总结

Linux内存映射系统调用提供了灵活的内存管理能力，涵盖从映射创建（mmap）、权限控制（mprotect）、数据同步（msync）到资源释放（munmap）的全生命周期操作。合理使用这些接口可显著提升文件I/O效率，简化进程间通信，并优化内存利用率。开发者需特别注意参数的对齐要求和标志位的组合逻辑，以避免潜在错误。

Linux内存锁相关系统调用详解

内存锁定（Memory Locking）是Linux系统中用于确保关键内存页常驻物理内存的核心机制，可避免被交换到磁盘，从而提升实时性、安全性及性能稳定性。以下是与内存锁相关的系统调用详解，包含功能、参数、宏定义及返回值的完整说明。

1. mlock()：锁定指定内存区域

功能：将进程虚拟地址空间中指定范围的物理内存页锁定在物理内存中，防止被交换到交换分区。

函数声明：

#include <sys/mman.h>  
int mlock(const void *addr, size_t len);  

参数说明：
• addr：需锁定的内存区域起始地址，必须按页对齐（通常4KB）。
• len：需锁定的内存区域长度，需为页大小的整数倍。

返回值：
• 成功返回0。
• 失败返回-1，并设置errno，常见错误包括：
• ENOMEM：系统内存不足或地址范围超出进程地址空间。
• EPERM：进程无权限（非特权用户需CAP_IPC_LOCK能力）。
• EINVAL：参数非法（如len=0或地址未对齐）。

2. munlock()：解除内存锁定

功能：解锁由mlock()锁定的内存区域，允许内核重新管理其换入换出。

函数声明：

#include <sys/mman.h>  
int munlock(const void *addr, size_t len);  

参数说明：
• addr和len：需解锁的内存区域，必须与mlock()调用时的范围完全一致。

返回值：
• 成功返回0。
• 失败返回-1，错误码与mlock()类似。

3. mlockall()：锁定进程全部内存

功能：锁定当前或未来进程地址空间的所有内存页，常与实时性要求高的应用结合使用。

函数声明：

#include <sys/mman.h>  
int mlockall(int flags);  

参数说明：
• flags：锁定模式，通过位或组合以下宏：
• MCL_CURRENT：锁定当前已分配的所有内存页。
• MCL_FUTURE：锁定未来新分配的内存页（如堆、栈增长）。
• MCL_ONFAULT（Linux特有）：仅锁定已触发缺页异常的页。

返回值：
• 成功返回0。
• 失败返回-1，错误码包括EPERM（权限不足）或ENOMEM（资源耗尽）。

4. munlockall()：解除全部内存锁定

功能：解除由mlockall()锁定的所有内存页。

函数声明：

#include <sys/mman.h>  
int munlockall(void);  

返回值：
• 成功返回0。
• 失败返回-1，通常因权限问题（EPERM）。

5. mseal()：密封内存权限（新增系统调用）

功能：锁定指定内存区域的权限（如禁止修改为可执行或调整映射范围），防止攻击者利用内存漏洞篡改权限。

函数声明：

#include <linux/mseal.h>  
int mseal(void *addr, size_t len, unsigned long flags);  

参数说明：
• addr和len：需密封的内存区域。
• flags：密封类型，常用宏包括：
• SEAL_PROT：禁止修改内存保护权限（如PROT_EXEC）。
• SEAL_MAP：禁止调整映射范围（如munmap或mremap）。
• SEAL_SHRINK：禁止缩小映射区域。

返回值：
• 成功返回0。
• 失败返回-1，错误码包括EACCES（权限不足）或EINVAL（参数无效）。

核心机制与限制

1. 实现原理：
   • 内存锁定通过设置VMA（虚拟内存区域）的VM_LOCKED标记实现，内核在页面回收（Page Reclaim）时跳过锁定页。
   • 锁定页会被移出LRU链表，加入unevictable_list，避免被扫描回收。
2. 资源限制：
   • 用户可通过ulimit -l查看和调整锁定内存上限，默认值通常为64KB。
   • 超限时mlock()返回ENOMEM。
3. 安全性与性能：
   • 特权进程（CAP_IPC_LOCK）可绕过限制，但过度锁定可能导致系统资源耗尽。
   • mseal通过固化内存权限提升安全性，尤其适用于浏览器JIT编译等高风险场景。

总结

内存锁相关系统调用为关键应用提供了物理内存驻留和权限控制的底层支持。mlock/mlockall适用于实时性场景，mseal则针对新型内存攻击提供主动防御。开发者需权衡性能与资源消耗，结合ulimit和权限管理避免系统稳定性问题。

System V 信号量与共享内存技术解析

一、System V 信号量

System V 信号量与共享内存是 Linux 系统中用于进程间通信（IPC）的重要机制。以下是关于信号量创建部分的详细解析：

1. semctl - 信号量的创建

声明：

int semget(key_t key, int nsems, int semflg);

参数详解：

1. key：
   信号量集的键值，通常通过 ftok 函数生成，用于唯一标识信号量集。可以使用 IPC_PRIVATE 来创建一个新的、唯一的信号量集。
2. nsems：
   信号量集中信号量的数量。如果只是访问已存在的信号量集，可以将其设为 0。
3. semflg：
   标志位，用于指定信号量集的创建和访问权限。常用的标志包括：
   • IPC_CREAT：如果信号量集不存在，则创建它。
   • IPC_EXCL：与 IPC_CREAT 一起使用，如果信号量集已存在，则返回错误。
   • 权限模式：如 0666，表示所有用户可读写。

返回值：
• 成功返回信号量集的标识符，失败返回 -1。

2. semctl - 控制信号量集（通常用于初始化或查看信号量集合状态）

声明：

int semctl(int semid, int semnum, int cmd, ... /* union semun arg */);

参数详解：

1. semid：
   信号量集的标识符，由 semget 返回。需确保进程对该信号量集有操作权限（如 IPC_RMID 需要所有者或超级用户权限）。
2. semnum：
   信号量在集合中的索引（从 0 开始）。仅对单信号量操作命令（如 SETVAL、GETVAL）有效；若 cmd 作用于整个集合（如 IPC_RMID），此参数可设为 0。

3. cmd：
   控制命令，决定操作类型及 arg 参数用途：
   • IPC_STAT：获取信号量集状态信息，arg 需指向 struct semid_ds 结构体。该结构包含内核维护的元数据：

   struct semid_ds {
       struct ipc_perm sem_perm;  // 权限与所有者信息
       time_t sem_otime;         // 最后一次 semop() 成功的时间（初始为0）
       time_t sem_ctime;         // 信号量集创建/修改时间
       struct sem *sem_base;     // 指向信号量数组
       unsigned short sem_nsems; // 信号量数量
   };

   关键字段：
   ◦ sem_otime：首次创建时初始化为0，仅通过成功执行的 semop() 更新为非零值
   ◦ sem_ctime：记录信号量集的创建或配置修改时间
   • IPC_SET：修改信号量集权限，需 struct semid_ds 指针更新 sem_perm 字段
   • IPC_RMID：立即删除信号量集
   • SETVAL/GETVAL：设置或获取单个信号量的值

4. arg（共用体 union semun）：
   需用户自定义的联合体，根据 cmd 选择成员：

   union semun {
       int val;                // SETVAL/GETVAL 的值
       struct semid_ds *buf;   // IPC_STAT/IPC_SET 的状态缓冲区
       unsigned short *array;  // GETALL/SETALL 的数组指针
   };

多进程竞争防护策略：
在信号量集创建与初始化过程中，需防范以下竞争场景：
进程A调用 semget 创建信号量后未完成初始化，进程B获取同一信号量并修改值，随后被进程A的初始化覆盖

解决方案：利用sem_otime 同步机制只让一个进程创建并初始化信号量集合
• 创建者进程：初始化后执行一次空操作（sem_op=0）的 semop()，强制更新 sem_otime 为非零值
• 其他进程：循环检查 sem_otime 是否为0，若为0则等待至其变为非零：

struct semid_ds ds;
union semun arg = {.buf = &ds};
do {
    semctl(semid, 0, IPC_STAT, arg);
    if (ds.sem_otime != 0) break;  // 确认初始化完成
    usleep(1000);  // 避免忙等待
} while (1);

3. semop - 执行原子操作（PV 操作）

声明：

int semop(int semid, struct sembuf *sops, size_t nsops);

参数：
• semid：信号量标识符。
• sops：指向 sembuf 结构数组的指针，每个结构定义一次操作：

struct sembuf {
    unsigned short sem_num;  // 信号量索引
    short sem_op;            // 操作值（负数：P 操作；正数：V 操作）
    short sem_flg;           // 标志（如 `IPC_NOWAIT` 非阻塞，`SEM_UNDO` 防死锁）
};

• nsops：操作数组的长度。

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

二、System V 共享内存

共享内存允许多进程直接读写同一物理内存区域，无需内核介入，是最高效的 IPC 方式。核心系统调用如下：

1. shmget - 创建/获取共享内存段

声明：

#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

参数：
• key：共享内存标识键，规则同信号量。
• size：共享内存大小（单位：字节），实际分配按页对齐。
• shmflg：标志位，如 IPC_CREAT、IPC_EXCL 及权限模式。

返回值：
• 成功返回共享内存标识符，失败返回 -1。

生命周期管理：
共享内存段的生命周期由内核维护，即使所有进程解除映射，仍需显式调用 shmctl 的 IPC_RMID 命令删除。

2. shmat - 映射共享内存到进程地址空间

声明：

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

参数：
• shmid：共享内存标识符。
• shmaddr：建议映射地址（通常设为 NULL，由系统自动分配）。
• shmflg：标志位，如 SHM_RDONLY（只读映射）。

返回值：
• 成功返回映射后的虚拟地址指针，失败返回 (void*) -1。

注意点:
• 共享内存在每个使用它的进程的附加位置(可以理解为挂载点)不同，因此若共享内存中存储了指针，若希望存储（也只能指向）共享内存的另一处位置，该指针不能存储绝对地址，而是只能存储到目标位置的偏移量。

3. shmdt - 解除映射

声明：

int shmdt(const void *shmaddr);

参数：
• shmaddr：shmat 返回的地址指针。

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

4. shmctl - 控制共享内存段

声明：

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

参数：
• shmid：共享内存标识符。
• cmd：控制命令：
• IPC_STAT：获取状态信息到 buf。
• IPC_SET：修改权限或所有者。
• IPC_RMID：标记删除（当所有进程解除映射后实际释放）。
• buf：指向 shmid_ds 结构体的指针，用于存储或修改状态。

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

三、关键注意事项与优化策略

1. 同步机制选择：
   • 信号量类型：二元信号量（互斥锁）适用于独占资源访问；多元信号量（如连接池）可控制资源数量。
   • 性能排序：互斥锁 > POSIX 信号量 > System V 信号量 > 文件锁。
2. 资源泄漏防护：
   • 显式调用 semctl/shmctl 删除 IPC 对象，避免因进程崩溃导致资源残留。
   • 使用 ipcs 和 ipcrm 命令检查与清理未释放的资源。
3. 错误处理与调试：
   • 所有系统调用需检查返回值，捕获 EACCES（权限不足）、EINVAL（无效参数）等错误。
   • 通过 semctl 的 GETNCNT/GETZCNT 监控信号量等待队列，优化锁粒度。

四、总结

通过合理组合 System V 信号量与共享内存，可实现高效且安全的进程间协作。信号量的原子操作与共享内存的直接内存访问特性，使其在数据库连接池、实时数据处理等高并发场景中表现卓越。开发者需重点关注多进程初始化的竞争防护、资源生命周期管理及错误处理机制，以确保系统稳定性和性能。

深入理解pthread互斥量与条件变量的使用

在多线程编程中，线程同步是一个关键问题。为了避免多个线程同时访问共享资源导致的数据竞争和不一致，POSIX线程库（pthread）提供了互斥量（Mutex）和条件变量（Condition Variable）两种重要的同步机制。本文将详细介绍它们的使用方法，并通过代码示例帮助读者更好地理解。

1. 互斥量（Mutex）

互斥量是一种简单的同步机制，用于保护共享资源，确保同一时间只有一个线程可以访问该资源。互斥量的基本操作包括初始化、加锁、解锁和销毁。

1.1 互斥量的初始化

互斥量可以通过静态或动态方式初始化。静态初始化使用宏PTHREAD_MUTEX_INITIALIZER，而动态初始化使用pthread_mutex_init函数。

// 静态初始化
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// 动态初始化
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);

1.2 互斥量的加锁与解锁

线程在访问共享资源前需要加锁，访问完成后解锁。如果互斥量已被其他线程锁定，当前线程会被阻塞，直到互斥量被解锁。

pthread_mutex_lock(&mutex);
// 访问共享资源
pthread_mutex_unlock(&mutex);

1.3 互斥量的销毁

当互斥量不再需要时，应调用pthread_mutex_destroy函数销毁它，以释放系统资源。

pthread_mutex_destroy(&mutex);

2. 条件变量（Condition Variable）

条件变量用于生产者-消费者模型中，防止消费者拿到互斥量后的忙等待。它允许线程在某个条件未满足时进入等待状态并释放互斥锁，并在条件满足时被唤醒并请求互斥锁。条件变量通常与互斥量一起使用。

2.1 条件变量的初始化

条件变量也可以通过静态或动态方式初始化。

// 静态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

// 动态初始化
pthread_cond_t cond;
pthread_cond_init(&cond, NULL);

2.2 条件变量的等待与通知

线程在等待条件变量时，会释放持有的互斥量，并在条件满足时重新获得互斥量。其他线程可以通过pthread_cond_signal或pthread_cond_broadcast唤醒等待的线程。

// 等待条件变量
pthread_mutex_lock(&mutex);
while (condition == false) { //一定要将循环检查共享资源，防止被唤醒后共享资源被没有被生产者生产
    pthread_cond_wait(&cond, &mutex);
}
pthread_mutex_unlock(&mutex);

// 通知条件变量
pthread_mutex_lock(&mutex);
condition = true;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);

2.3 条件变量的销毁

当条件变量不再需要时，应调用pthread_cond_destroy函数销毁它。

pthread_cond_destroy(&cond);

3. 示例代码

以下是一个使用互斥量和条件变量的简单示例，展示了如何实现线程间的同步。

#include <pthread.h>
#include <stdio.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int ready = 0;

void *thread_function(void *arg) {
    pthread_mutex_lock(&mutex);
    while (ready == 0) {
        pthread_cond_wait(&cond, &mutex);
    }
    printf("Thread condition met, proceeding\n");
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t thread_id;
    pthread_create(&thread_id, NULL, thread_function, NULL);

    pthread_mutex_lock(&mutex);
    printf("Main thread signaling condition variable\n");
    ready = 1;
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);

    pthread_join(thread_id, NULL);
    return 0;
}

在这个示例中，主线程通过条件变量唤醒等待的线程，确保线程在条件满足时继续执行。

4. 总结

互斥量和条件变量是多线程编程中常用的同步机制。互斥量用于保护共享资源，而条件变量用于防止线程的忙等待，协调生产者与消费者线程。通过合理使用这两种机制，可以有效地避免数据竞争和死锁问题，提高多线程程序的稳定性和性能。

希望本文能帮助你更好地理解和使用pthread互斥量与条件变量。如果你有任何问题或需要进一步的帮助，请随时留言！

System V 消息队列总结：

前言

消息队列是一种面向消息的ipc机制，即内核会保证进程对消息队列IO时数据块（消息）的整体性。且其是双工的，任何进程都可以往里放消息，同时任何进程都可以往里读消息（甚至读到其自己的）。

1. msgget - 创建消息队列/获取已有消息队列的标识符

#include <sys/msg.h>

int msgget(key_t key, int msgflg);

• 参数：
• key：消息队列的唯一键值（通常由 ftok 生成），或使用 IPC_PRIVATE 创建私有队列。
• msgflg：标志位（如 IPC_CREAT 创建队列，IPC_EXCL 配合 IPC_CREAT 确保队列不存在时新建）。
• 返回值：成功返回消息队列标识符（msqid），失败返回 -1。

2. msgsnd - 发送消息

#include <sys/msg.h>

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

• 参数：
• msqid：消息队列标识符。
• msgp：指向消息结构体的指针（需自定义，见下文）。
• msgsz：消息内容（mtext）的字节数（不包括 mtype 字段）。
• msgflg：标志位（如 IPC_NOWAIT 非阻塞发送，队列满时立即返回错误）。
• 返回值：成功返回 0，失败返回 -1。

注意：就算多进程/线程同时非阻塞地调用该函数，内核依旧会保证消息之间地独立性。因为内核并不是依靠其阻塞来保证独立性的。

3. msgrcv - 接收消息

#include <sys/msg.h>

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

• 参数：
• msqid：消息队列标识符。
• msgp：接收消息的缓冲区指针（需自定义消息结构体）。
• msgsz：缓冲区中 mtext 部分的最大容量。
• msgtyp：指定接收消息的类型（见下文规则）。
• msgflg：标志位（如 IPC_NOWAIT 非阻塞接收，MSG_NOERROR 允许截断过长消息）。
• 返回值：成功返回实际接收的 mtext 字节数，失败返回 -1。

4. msgctl - 控制消息队列

#include <sys/msg.h>

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

• 参数：
• msqid：消息队列标识符。
• cmd：控制命令（常用值）：

◦ **`IPC_STAT`**：获取队列元数据到 `buf`。
◦ **`IPC_SET`**：通过 `buf` 修改队列元数据（如权限、容量限制）。
◦ **`IPC_RMID`**：立即删除队列（`buf` 可设为 `NULL`）。

• buf：指向 struct msqid_ds 的指针（用于读写元数据）。
• 返回值：成功返回 0，失败返回 -1。

关键数据结构

消息结构体（需自定义）

struct msgbuf {
    long mtype;     // 消息类型（必须 > 0）
    char mtext[];  // 消息内容（实际长度由 `msgsz` 指定，这里的字符数组表示就是一块内存，可以是各种数据的组合）
};

队列元数据结构体（struct msqid_ds）

提取自内核维护的msg_ids数据结构的对应entries指针指向的结构。

struct msqid_ds {
    struct ipc_perm msg_perm;  // 权限信息（所有者、读写权限等）
    time_t          msg_stime; // 最后发送时间
    time_t          msg_rtime; // 最后接收时间
    time_t          msg_ctime; // 最后修改时间
    unsigned long   msg_cbytes; // 当前队列中的字节数
    msgqnum_t       msg_qnum;   // 当前队列中的消息数
    msglen_t        msg_qbytes; // 队列最大容量（字节数）
    pid_t           msg_lspid;  // 最后发送消息的进程PID
    pid_t           msg_lrpid;  // 最后接收消息的进程PID
};

核心原理

1. 消息类型（mtype）：
   • 用于分类消息，接收时可指定类型过滤（如 msgtyp > 0 匹配特定类型，msgtyp = 0 接收任意类型，msgtyp < 0 接受mtype小于msgtyp绝对值的mtype最小的消息）。
   • 类型为 long 类型，必须为正整数。
2. 内核管理：
   • 消息队列以内核对象形式存在，独立于进程生命周期（需显式调用 msgctl(IPC_RMID) 删除）。
   • 消息以链表形式存储，保证先进先出（FIFO），但可通过 msgtyp 实现优先级读取。
3. 同步与原子性：
   • msgsnd 和 msgrcv 是原子操作：单次调用发送或接收一条完整消息。
   • 若队列满或空，默认阻塞进程（除非指定 IPC_NOWAIT）。

示例代码片段

// 定义消息结构体（实际使用需动态分配 mtext 大小）
struct my_msg {
    long mtype;
    char mtext[100];
};

// 发送消息
struct my_msg msg_send = {1, "Hello"};
msgsnd(msqid, &msg_send, strlen(msg_send.mtext), 0);

// 接收消息
struct my_msg msg_recv;
msgrcv(msqid, &msg_recv, sizeof(msg_recv.mtext), 1, 0);

总结

• 适用场景：需要类型过滤、原子性操作或异步通信的进程间交互（如任务分发、事件通知）。
• 缺点：依赖内核资源，需手动管理队列生命周期；跨平台支持较弱（推荐优先考虑 POSIX 消息队列或套接字）。