Linux软件编程（8）—进程间通信（2）消息队列、共享内存、信号灯

最新推荐文章于 2025-11-23 18:41:31 发布

原创最新推荐文章于 2025-11-23 18:41:31 发布 · 739 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#开发语言 #进程 #线程 #通信

一、消息队列

1. IPC对象：

IPC对象可以理解为一种内存文件

IPC对象在操作系统关闭的情况下数据被回收掉

IPC对象可以通过文件系统来定位

每个IPC对象可以创建一个消息队列、一个共享内存、一个信号

2. IPC对象操作命令：

（1）查看IPC对象

ipcs

ipcs -q/m/s 查看消息队列/共享内存/信号灯

（2）删除IPC对象

ipcrm

ipcrm -q/m/s 消息队列/共享内存/信号灯的ID

ipcrm -Q/M/S IPC对象的Key值

（3）操作流程

创建/打开消息队列

向消息队列中发送消息

从消息队列中接收消息

（4）函数接口

①ftok

原型：key_t ftok(const char *pathname, int proj_id);
功能：
根据pathname和proj_id生成IPC对象名称
参数:
pathname:路径
proj_id:项目ID（8位）
返回值：
成功返回创建的IPC对象的名称
失败返回-1

②msgget

原型：int msgget(key_t key, int msgflg);
功能：
根据key值创建消息队列
参数：
key:IPC对象的名称
msgflg:创建标志
IPC_CREAT 不存在创建
IPC_EXCL 存在报错
返回值：
成功返回消息队列ID
失败返回-1

③msgsnd

原型：int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
功能：
向消息队列中发送消息
参数：
msqid:消息队列的ID号
msgp:发送消息内容空间的首地址
msgsz:发送消息内容的大小
msgflg:发送消息的标志
返回值：
成功返回0
失败返回-1

④msgrcv

原型：ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
功能：
从消息队列中接收消息
参数：
msgqid:消息队列的ID号
msgp:存放消息空间的首地址
msgsz:最多接收消息的大小
msgtyp:接收消息的类型
返回值：
成功返回实际拷贝到空间的字节数
失败返回-1

⑤msgctl

原型：int msgctl(int msqid, int cmd, struct msqid_ds *buf);
功能：
删除消息队列
参数：
msqid:消息队列的ID号
cmd:IPC_RMID 删除类型
buf:默认为NULL
返回值：
成功返回0
失败返回-1

#include "../head.h"

typedef struct message{
    long mtype;
    char mtext[256];
}message_t;

message_t recvmsg;
message_t sendmsg;
pthread_t tid1;
pthread_t tid2;
int msgid = 0;

void *thread1(void *arg)
{
    int ret = 0;
    char tmpbuff[4096] = {0};

    while(1)
    {
        sendmsg.mtype = 100L;
        m_fgets(sendmsg.mtext);
        ret = msgsnd(msgid, &sendmsg, sizeof(sendmsg) - sizeof(long), 0);
        if(-1 == ret)
        {
            perror("fail to msgsnd");
            return NULL;
        }
        if (0 == strcmp(sendmsg.mtext, ".quit"))
        {
            break;
        }
    }

    pthread_cancel(tid2);

    return NULL;
}

void *thread2(void *arg)
{
    ssize_t nret;

    while(1)
    {
        nret = msgrcv(msgid, &recvmsg, sizeof(recvmsg.mtext), 200L, 0);
        if(-1 == nret)
        {
            perror("fail to msgrcv");
            return NULL;
        }
        printf("RECV:%s\n", recvmsg.mtext);
        if (0 == strcmp(recvmsg.mtext, ".quit"))
        {
            break;
        }
    }

    pthread_cancel(tid1);

   return NULL;
}


int main(void)
{
    key_t key;
    int fd1 = 0;
    int fd2 = 0;

    key = ftok("/", 'a');
    if(-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }
    printf("IPC对象键值:%#x\n", key);

    msgid = msgget(key, IPC_CREAT | 0664);
    if(-1 == msgid)
    {
        perror("fail to msgget");
        return -1;
    }
    printf("消息队列的ID:%d\n", msgid);

    pthread_create(&tid1, NULL, thread1, NULL);
    pthread_create(&tid2, NULL, thread2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    msgctl(msgid, IPC_RMID, NULL);


    return 0;
}

二、共享内存

1.概念

进程空间是独立的，共享内存是开辟一段内核空间，进程都映射到这一片空间上，实现空间的共享

进程间通信最高效形式

2.操作方法

创建IPC对象名称

创建共享内存

将进程空间地址映射到共享内存空间中

读写共享内存空间实现进程间通信

解除共享内存映射

删除共享内存

3.函数接口

①ftok

②shmget

原型：int shmget(key_t key, size_t size, int shmflg);
功能：
创建共享内存
参数：
key:IPC对象的键值
size:共享内存空间大小
shmflg:IPC_CREAT 不存在创建
IPC_EXCL 存放报错
返回值：
成功返回共享内存的ID号
失败返回-1

③shmat

原型：void *shmat(int shmid, const void *shmaddr, int shmflg);
功能：
将进程空间中的地址映射到共享内存中
参数：
shmid:共享内存的ID号
shmaddr:
NULL:系统选择一个合适的地址进行映射
shmflg:
标志默认为0
返回值：
成功返回映射到共享内存空间中的地址
失败返回NULL

④shmdt

原型：int shmdt(const void *shmaddr);
功能：
解除映射
参数：
shmaddr:映射到共享内存空间中的地址
返回值：
成功返回0
失败返回-1

⑤shmctl

原型：int shmctl(int shmid, int cmd, struct shmid_ds *buf);
功能：
向共享内存发送命令
参数：
shmid:共享内存ID号
cmd:命令
IPC_RMID 删除共享内存
buf:
默认为NULL
返回值：
成功返回0
失败返回-1

#include "../head.h"

int main(void)
{
    key_t key;
    int shmid = 0;
    int ret = 0;
    char *pshmaddr = NULL;

    key = ftok("/", 'a');
    if(-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    shmid = shmget(key, 4096, IPC_CREAT | 0664);
    if(-1 == shmid)
    {
        perror("fail to shmget");
        return -1;
    }

    pshmaddr = shmat(shmid, NULL, 0);
    if(NULL == pshmaddr)
    {
        perror("fail to shamat");
        return -1;
    }

    while(1)
    {
        printf("pshmaddr = %s\n", pshmaddr);
        if(0 == strcmp(pshmaddr, ".quit"))
        {
            break;
        }
    }

    ret = shmdt(pshmaddr);
    if(-1 == ret)
    {
        perror("fail to shmdt");
        return -1;
    }

    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

三、信号灯

1.概念

搭配共享内存实现进程间通信

主要用于多进程任务间的同步

信号灯是一组信号量，即信号量的数组

用于线程间通信的信号量称为无名信号量，信号灯是有名信号量

2.信号灯操作

创建信号量数组

申请信号量

释放信号量

信号量的销毁

3.函数接口

①ftok

②semget

原型：int semget(key_t key, int nsems, int semflg);
功能：
创建信号量数组
参数：
key:IPC对象名称
nsems:信号量的个数
semflg:IPC_CREAT 不存在创建
IPC_EXCL 存在报错
返回值：
成功返回信号量数组的ID
失败返回-1

③semop

原型：int semop(int semid, struct sembuf *sops, size_t nsops);
功能：
完成对一个信号量的操作
参数：
semid:信号量数组的ID号
sops:对信号量进行操作的空间的首地址
nsops:对信号量进行操作的个数
返回值：
成功返回0
失败返回-1

④semctl

原型：int semctl(int semid, int semnum, int cmd, ...);
功能：
利用cmd实现对信号量的操作
参数：
semid:信号量数组的ID号
semnum:操作的信号量的下标
cmd:IPC_RMID 删除信号量
SETVAL 设置信号量的值
返回值：
成功返回0
失败返回-1
union semun {
int val; /* Value for SETVAL */
struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* Array for GETALL, SETALL */
struct seminfo *__buf; /* Buffer for IPC_INFO
(Linux-specific) */
};

#include "../head.h"

union semun{
    int              val;    
    struct semid_ds *buf;    
    unsigned short  *array;  
    struct seminfo  *__buf;
};                                                                                                  

int main(void)
{
    key_t key;
    int semid = 0;
    int ret = 0;
    union semun myun;
    struct sembuf mybuf;

    key = ftok("/", 'a');
    if(-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    semid = semget(key, 2, IPC_CREAT | 0664);
    if(-1 == semid)
    {
        perror("fail to semget");
        return -1;
    }

    myun.val = 0;
    ret = semctl(semid, 0, SETVAL, myun);
    if (-1 == ret)
    {
        perror("fail to semctl");
        return -1;
    }

    myun.val = 1;
    ret = semctl(semid, 1, SETVAL, myun);
    if (-1 == ret)
    {
        perror("fail to semctl");
        return -1;
    }

    mybuf.sem_num = 1;
    mybuf.sem_op = -1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if(-1 == ret)
    {
        perror("fail to semop");
        return -1;
    }

    printf("申请写信号量成功\n");

    mybuf.sem_num = 0;
    mybuf.sem_op = +1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if(-1 == ret)
    {
        perror("fail to semop");
        return -1;
    }

    printf("释放读信号量\n");

    mybuf.sem_num = 0;
    mybuf.sem_op = -1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if(-1 == ret)
    {
        perror("fail to semop");
        return -1;
    }

    printf("申请读信号量成功\n");

    mybuf.sem_num = 0;
    mybuf.sem_op = +1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if(-1 == ret)
    {
        perror("fail to semop");
        return -1;
    }

    printf("释放读信号量\n");

    semctl(semid, 0, IPC_RMID, NULL);
    semctl(semid, 1, IPC_RMID, NULL);

    return 0;
}