system v IPC进程通信 5.17

最新推荐文章于 2024-05-14 21:28:38 发布
最新推荐文章于 2024-05-14 21:28:38 发布
阅读量539 收藏
点赞数
分类专栏： IO进程管理 文章标签： java 网络 服务器 unix
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45241469/article/details/130736091
版权
本文介绍了SystemVIPC中的三种主要通信机制：共享内存、消息队列和信号灯集。通过示例代码展示了如何使用shmget创建和操作共享内存，msgget和msgsnd/msgrcv用于消息队列的发送和接收，以及semget和semop用于信号灯集的控制。这些机制允许不同进程间高效地交换数据。
摘要由CSDN通过智能技术生成

进程间通信

system v IPC对象

共享内存，消息队列，信号灯集

  1. 相关操作命令：
1.查询系统所有ipc对象：ipcs

2.查询系统共享内存：ipcs -m

3.查询系统消息队列：ipcs -q

4.查询系统信号灯集：ipcs -s

5.删除系统ipc对象：iprm [-m -q -s] ID

共享内存

  1. 共享内存：
1.是进程间通信，效率最高的一种方式
2.内核专门留出的一块内存区域，要使用的用户进程 直接映射到自己的地址空间
3.用户进程就能直接对这块内存区域进程读写操作，而不需要进行数据拷贝，效率就会提高

共享内存操作步骤
1.创建或打开共享内存
2.映射：将共享内存首地址 映射到进程地址空间，方便访问使用
3.解除映射
4.删除共享内存

shmget()

所需头文件
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
函数原型
int shmget(key_ t key, int size, int shmflg);
函数参数
key: IPC_ PRIVATE或ftok的返回值
size:共享内存区大小
shmflg:同open函 数的权限位，也可以用8进制表示法
函数返回值
成功:共享内存段标识符
出错: -1

ftok()

所需头文件
#include <sys/types.h>

#include <sys/ipc.h>

函数原型
key_ t ftok(const char *pathname, int proj_ id);
函数参数
const char *pathname:文件路径名
int proj_ id: 子序号
函数返回值
成功:返回生成的key值
出错: -1

shmat()

所需头文件
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
函数原型
void * shmat(int shmid, const void *shmaddr; int shmflg);
函数参数
shmid:要映射的共享内存区标识符
shmaddr:将共享内存映射到指定地址(若为NULL,则表示由系统自动完成映射)
shmflg :
SHM_ RDONLY:共享内存只读
默认0:共享内存可读写
函数返回值
成功:映射后的地址
出错: -1

shmdt()

所需头文件
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
函数原型
int shmdt(const void *shmaddr);
函数参数
shmaddr:共享内存映射后的地址
函数返回值
成功: 0
出错: -1

shmctl()

所需头文件
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
函数原型
int shmctl(int shmid, int cmd, struct shmid_ ds *buf);
函数参数
shmid:要操作的共享内存标识符
cmd: IPC_ STAT (获取对象属性)
IPC_ SET (设置对象属性)
IPC_ RMID (删除对象)
buf:指定IPC_ STAT/IPC _SET时用以保存/设置属性
函数返回值
成功: 0
出错: -1

/*===============================================
*   文件名称：shareMemory.c
*   创 建 者：memories 
*   创建日期：2023年05月17日
*   描    述：
================================================*/


在有亲缘关系的父子进程之间的shareMemory通信


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[])
{ 
    //1.创建或者打开共享内存
   int shmid =  shmget(IPC_PRIVATE,64,0600);
    if(shmid<0)
    {
        perror("shmget");
        return -1;
    }
    printf("shmid=%d\n",shmid);
    system("ipcs -m");//执行字符串的命令，属于系统调用
    //2.映射共享内存首地址到用户进程空间
    char *p = shmat(shmid,NULL,0);
    if(p==(char *)-1)
    {
        perror("shmat");
        goto end2;
    }

    pid_t pid=fork();
    if(pid<0)
    {
        perror("fork");
        goto end1;
    }
    else if(pid==0)
    {
        while(1)
        {
            fgets(p,32,stdin);
            if(strncmp(p,"quit",4)==0)
                break;
        }
        exit(0);
    }
    else
    {
        while(1)
        {
            printf("p=%s\n",p);
            if(strncmp(p,"quit",4)==0)
                break;
            sleep(3);
        }
end1:
    //3.解除映射
    if(shmdt(p)<0)
    {
        perror("shmdt");
    }
    printf("删除映射成功\n");


end2:
    //4.删除共享内存
    if(shmctl(shmid,IPC_RMID,NULL)<0)
    {
        perror("shmctl");
        char cmd[32]={0};
        sprintf(cmd,"ipcrm -m %d",shmid);
        system(cmd);
    }
    printf("删除共享内存成功\n");
    system("ipcs -m");
    }
    return 0;
} 


/*===============================================
*   文件名称：shareMemory_read.c
*   创 建 者：memories 
*   创建日期：2023年05月17日
*   描    述：
================================================*/

在不同进程非亲缘关系间的进程shareMemory通信

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[])
{ 
    key_t key=ftok(".",3);
    if(key==-1)
    {
        perror("key");
        return -1;
    }
    printf("key=%d\n",key);
    //1.创建或者打开共享内存
   int shmid =  shmget(key,64,0600|IPC_CREAT);
    if(shmid<0)
    {
        perror("shmget");
        return -1;
    }
    printf("shmid=%d\n",shmid);
    system("ipcs -m");//执行字符串的命令，属于系统调用
    //2.映射共享内存首地址到用户进程空间
    char *p = shmat(shmid,NULL,0);
    if(p==(char *)-1)
    {
        perror("shmat");
        goto end2;
    }

        while(1)
        {
            printf("p=%s\n",p);
            if(strncmp(p,"quit",4)==0)
                break;
            sleep(3);
        }

end1:
    //3.解除映射
    if(shmdt(p)<0)
    {
        perror("shmdt");
    }
    printf("删除映射成功\n");


end2:
    //4.删除共享内存
    if(shmctl(shmid,IPC_RMID,NULL)<0)
    {
        perror("shmctl");
        char cmd[32]={0};
        sprintf(cmd,"ipcrm -m %d",shmid);
        system(cmd);
    }
    printf("删除共享内存成功\n");
    system("ipcs -m");
    
    return 0;
} 


/*===============================================
*   文件名称：shareMemory_write.c
*   创 建 者：memories 
*   创建日期：2023年05月17日
*   描    述：
================================================*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[])
{ 
    //根据文件名或路径，子序号生成key
    key_t key=ftok(".",3);
    if(key==-1)
    {
        perror("key");
        return -1;
    }
    printf("key=%d\n",key);
    //1.创建或者打开共享内存
   int shmid =  shmget(key,64,0600|IPC_CREAT);
    if(shmid<0)
    {
        perror("shmget");
        return -1;
    }
    printf("shmid=%d\n",shmid);
    system("ipcs -m");//执行字符串的命令，属于系统调用
    //2.映射共享内存首地址到用户进程空间
    char *p = shmat(shmid,NULL,0);
    if(p==(char *)-1)
    {
        perror("shmat");
        goto end2;
    }

        while(1)
        {
            fgets(p,32,stdin);
            if(strncmp(p,"quit",4)==0)
                break;
        }
        exit(0);
end1:
    //3.解除映射
    if(shmdt(p)<0)
    {
        perror("shmdt");
    }
    printf("删除映射成功\n");


end2:
    //4.删除共享内存
    if(shmctl(shmid,IPC_RMID,NULL)<0)
    {
        perror("shmctl");
        char cmd[32]={0};
        sprintf(cmd,"ipcrm -m %d",shmid);
        system(cmd);
    }
    printf("删除共享内存成功\n");
    system("ipcs -m");
    
    return 0;
}

消息队列

​ 在内核中创建的队列，该队列由 消息队列ID来唯一标识。
​ 消息队列就是一个消息的列表，用户可以 添加消息、读取消息。
​ 消息队列 必须按照消息的类型 来进行 添加和读取。

msgget()

​ 1、打开或者创建信息队列
​ int msgget(key_t key, int msgflg);
​ 头文件：
​ #include <sys/types.h>
​ #include <sys/ipc.h>
​ #include <sys/msg.h>
​ 参数：
​ key ：同 shmget函数的key值一样
​ msgflg ：消息队列的权限，同 open一样
​ 返回值：
​ 成功：消息队列的 msgid
​ 失败：-1

msgsnd()

​ 2、添加消息
​ int msgsnd(int msqid, const void *msgp, size_t size, int flag);
​ 参数：
​ msqid ：消息队列的 ID
​ msgp ：存储消息的结构体首地址
​ size ：添加的本条消息的正文长度
​ flag ：0阻塞等待添加成功才返回， IPC_NOWAIT：非阻塞
​ 返回值：
​ 成功：0
​ 失败：-1
​ 注意：
​ 消息结构体需要用户自行定义
​ struct msgbuf{
​ long type; //存储当前消息的类型
​ char text[N]; //存储当前消息的正文
​ };
​ ***每发送一条消息，都必须指定该条消息的类型

msgrcv()

3、读取消息
int msgrcv(int msgid, void * msgp, size_t size, long msgtype, int flag);
参数：
msqid ：消息队列的 ID
msgp ：存储消息的结构体首地址
size ：要读取的消息正文长度
msgtype ：要读取的消息的类型
flag ：0阻塞，IPC_NOWAIT：非阻塞
返回值：
成功：接受的消息的长度
失败：-1
注意：
消息结构体需要用户自行定义
struct msgbuf{
long type; //存储当前消息的类型
char text[N]; //存储当前消息的正文
};
要读取一条消息时，必须指定接收哪种类型的消息

/*===============================================
*   文件名称：messageQueue_read.c
*   创 建 者：memories 
*   创建日期：2023年05月17日
*   描    述：
================================================*/


在不同进程非亲缘关系间的进程messagequeue通信

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

#define  N 64
typedef struct{
    long mtype;
    char mtex[N]; 
}msgbuf;

int main(int argc, char *argv[])
{ 
    //创建key值
    key_t key=ftok(".",3);
    if(key==-1)
    {
        perror("key");
        return -1;
    }
    printf("key=%d\n",key);
    //创建消息队列
    int msqid=msgget(key,0600|IPC_CREAT);
    if(msqid<0)
    {
        perror("msgget");
        return -1;
    }
    printf("msqid=%d\n",msqid);
    system("ipcs -q");
    //发送消息
        while(1)
        {
            //定义结构体变量
            msgbuf msg;
            msgrcv(msqid,&msg,sizeof(msg),1,0);
            printf("rcv=%s\n",msg.mtex);
            if(strncmp(msg.mtex,"quit",4)==0)
                break;
            sleep(3);
        }

        //删除消息队列
        if((msgctl(msqid,IPC_RMID,NULL))<0)
        {
            perror("msgctl");
        }
        system("ipcs -q");
    return 0;
} 


/*===============================================
*   文件名称：messageQueue_write.c
*   创 建 者：memories 
*   创建日期：2023年05月17日
*   描    述：
================================================*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>

#define  N 64
typedef struct{
    long mtype;
    char mtex[N]; 
}msgbuf;

int main(int argc, char *argv[])
{ 
    //创建key值
    key_t key=ftok(".",3);
    if(key==-1)
    {
        perror("key");
        return -1;
    }
    printf("key=%d\n",key);
    //创建消息队列
    int msqid=msgget(key,0600|IPC_CREAT);
    if(msqid<0)
    {
        perror("msgget");
        return -1;
    }
    printf("msqid=%d\n",msqid);
    system("ipcs -q");
    //发送消息
        while(1)
        {
            //定义结构体变量
            msgbuf msg;
            //设置本条消息的类型
            msg.mtype = 1;
            //从标准输入流中获取一行前32字节到msg结构体的mtex中
            fgets(msg.mtex,32,stdin);
            //将消息添加到消息队列中
            msgsnd(msqid,&msg,sizeof(msg)-sizeof(long),0);

            if(strncmp(msg.mtex,"quit",4)==0)
                break;
            sleep(3);
        }

        //删除消息队列
        if((msgctl(msqid,IPC_RMID,NULL))<0)
        {
            perror("msgctl");
        }
        system("ipcs -q");
    return 0;
}

信号灯集

​ 信号灯的种类：
​

	有名信号灯
	无名信号灯（基于内存的信号灯）
	 system v IPC 信号灯集

​

信号灯：分为两类
二值信号灯：信号量的数值只能是 0或者1，类似于互斥
计数信号灯：信号量的数值在 0到 n

semget()

1、创建或者打开信号灯集
int semget(key_t key, int nsems, int semflg);
功能：
打开或者创建打开信号灯集，设置集合中信号灯的个数和权限
头文件：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
参数：
key ：同 shmget函数一致
nsems ：设置集合中信号灯的 数量
semflg ：同open函数一样，权限8进制和 IPC_CREAT
返回值：
成功：信号灯集的ID号
失败：-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) */
};

函数：
int semctl(int semid, int semnum, int cmd, union semnu val);
功能：
设置灯集中某个编号的信号灯的数值
参数：
semid： 信号灯集的ID号
semnu： 设置的信号灯的编号
cmd ： SETVAL 设置数值
val ： 联合体变量，存储要设置的信号灯数值
返回值：
成功：0
失败：-1

semop()

2、信号灯集的操作
int semop( int semid, struct sembuf *opsptr, size_t nops);
功能：
设置灯集中某个信号灯的 操作为 p还是v
参数：
semid ：信号灯集的ID号
opsptr : 结构体首地址
nops ：操作的信号灯个数
返回值：
成功：0
失败：-1
struct sembuf {
short sem_num; // 要操作的信号灯的编号
short sem_op; // 0 : 等待，直到信号灯的值变成0
// 1 : 释放资源，V操作
// -1 : 分配资源，P操作
short sem_flg; // 0, IPC_NOWAIT, SEM_UNDO
};

semctl()

3、信号灯集的控制函数
int semctl ( int semid, int semnum, int cmd…/*union semun arg */);
参数：
semid ：信号灯集ID
semnum : 要修改的信号灯编号
cmd : GETVAL：获取信号灯的值 SETVAL：设置信号灯的值 IPC_RMID：从系统中删除信号灯集合
返回值：
成功：0
失败：-1

/*===============================================
 *   文件名称：semaphore.c
 *   创 建 者：memories 
 *   创建日期：2023年05月17日
 *   描    述：
 ================================================*/


利用semaphore 实现子父进程之间的通信，当子进程输入数据时，父进程等待，父进程输出数据到终端时，子进程阻塞等待


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
#include <sys/sem.h>


//使用semctl必须在程序中定义联合体
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) */
};



int main(int argc, char *argv[])
{ 
    //1.创建或者打开共享内存
    int shmid =  shmget(IPC_PRIVATE,64,0600);
    if(shmid<0)
    {
        perror("shmget");
        return -1;
    }
    printf("shmid=%d\n",shmid);
    system("ipcs -m");//执行字符串的命令，属于系统调用
    //2.映射共享内存首地址到用户进程空间
    char *p = shmat(shmid,NULL,0);
    if(p==(char *)-1)
    {
        perror("shmat");
        goto end2;
    }
    //创建或打开信号灯集，设置灯集中信号灯的个数，以及集合的权限
    int semid = semget(IPC_PRIVATE,2,IPC_CREAT|0600);
    if(semid < 0)
    {
        perror("semget");
        return -1;
    }

    //设置灯集中，每个信号灯的初始值（初始化灯集）
    //定义联合体变量，给成员val赋值为1
    union semun val1 ={1};
    //设置灯集中编号 0 的信号灯的数值为val1
    semctl(semid,0,SETVAL,val1);

    union semun val2 = {0};
    //设置灯集中编号为1的信号灯的数值为val2
    semctl(semid,1,SETVAL,val2);

    pid_t pid=fork();
    if(pid<0)
    {
        perror("fork");
        goto end1;
    }
    else if(pid==0)
    {
        while(1)
        {
            //p(0)
            struct sembuf buf = {
                .sem_num = 0,//指定要操作的信号灯标号
                .sem_op = 1,//设置要执行的操作 p操作（1）
                .sem_flg = 0//设置当前操作为阻塞模式
            };
            semop(semid,&buf,1);//进行p操作
            fgets(p,32,stdin);
            //v(1)
            buf.sem_num = 1;//设置要操作的信号灯编号
            buf.sem_op = -1;//设置要执行的操作v操作（-1）
            buf.sem_flg = 0;//设置当前操作为阻塞模式
            semop(semid,&buf,1);//进行v 操作
            if(strncmp(p,"quit",4)==0)
                break;
        }
        exit(0);
    }
    else
    {
        while(1)
        {
            //p(1)
            struct sembuf buf = {
                .sem_num = 1,//指定要操作的信号灯标号
                .sem_op = 1,//设置要执行的操作 p操作（1）
                .sem_flg = 0//设置当前操作为阻塞模式
            };
            semop(semid,&buf,1);//进行p操作
            printf("%s\n",p);
            //v(0)
            buf.sem_num = 0;//设置要操作的信号灯编号
            buf.sem_op = -1;//设置要执行的操作v操作（-1）
            buf.sem_flg = 0;//设置当前操作为阻塞模式
            semop(semid,&buf,1);//进行v 操作
            if(strncmp(p,"quit",4)==0)
                break;
        }
    }
end1:
        //3.解除映射
        if(shmdt(p)<0)
        {
            perror("shmdt");
        }
        printf("删除映射成功\n");


end2:
        //4.删除共享内存
        if(shmctl(shmid,IPC_RMID,NULL)<0)
        {
            perror("shmctl");
            char cmd[32]={0};
            sprintf(cmd,"ipcrm -m %d",shmid);
            system(cmd);
        }
        printf("删除共享内存成功\n");
        system("ipcs -m");
    
    return 0;
}
孤独memories
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
IPC之三：使用 System V 消息队列进行进程间通信的实例
whowin
08-08 385
IPC 是 Linux 编程中一个重要的概念，IPC 有多种方式，本文主要介绍消息队列(Message Queues)，消息队列可以完成同一台计算机上的进程之间的通信，相比较管道，消息队列要复杂一些，但使用起来更加灵活和方便，本文针对 System V 消息队列，并给出了多个具体的实例，每个实例均附有完整的源代码；本文所有实例在 Ubuntu 20.04 上编译测试通过，gcc版本号为：9.4.0；本文适合 Linux 编程的初学者阅读。
进程间通信（IPC）介绍
MRDOCMAN的博客
05-26 4541
进程间通信（IPC）介绍
linux详细入门教程（十六）------进程间通信（2）
重生之我是泰勒
07-19 187
linux详细入门教程（十六）------进程间通信（2）
System V IPC 共享内存详解
lirendada的博客
02-23 737
​ 这里我们介绍的这种通信方式也就是 system V IPC在我们后面的使用和日常见到的其实并不多，但是包括其中的，我们如果了解共享内存其原理的话，能够更好的帮助我们了解之前我们学过的进程地址空间的概念！​ 至于信号量，我们后面讲多线程的时候会再次讲，我们只引入一些概念如互斥等等，而消息队列我们就只说说其原理，不会细讲！
System-V IPC与 Posix IPC
xhwy123的博客
06-05 1304
今天在看野火的Linux基础与应用开发实战指南时 产生了一个Posix IPC信号量和System-V IPC信号量的问题 ，找了不少资料，于是就有了下文。
System V IPC（进程间通信）机制详解
最新发布
无敌岩雀的博客
05-14 1154
在共享内存模型中，进程A和进程B都可以直接访问同一块物理内存区域（即“共享区”）。这意味着数据不需要通过系统调用或其他中间层进行复制或传输，从而减少了数据传输的开销。共享内存通过允许进程直接访问同一块物理内存区域，减少了数据传输和I/O操作的开销，降低了延迟，从而提高了进程间通信的效率。当A进程需要与B进程通信时，只需要把共享区的虚拟地址与物理地址的映射写入两进程的页表中。因此，进程A可以对该物理地址直接进行写入；而B进程则是通过页表的映射关系，从该物理地址直接进行读取。
第4章 System V的进程间通信1
08-03
System V进程间通信（IPC，Inter-Process Communication）机制是UNIX和类UNIX系统中用于不同进程之间交换信息的一种方法。System V IPC主要包括三种主要机制：消息队列、信号量和共享主存，这些机制提供了进程间高效...
理解Linux环境下SYSTEM V进程间通信.pdf
09-07
在Linux操作系统中，System V进程间通信（IPC）是一种古老且强大的进程通信机制，它源自UNIX平台，并在Linux中得到广泛的应用。System V IPC主要包括三种形式：消息队列、信号灯和共享内存。这些机制允许不同进程...
msgq:System V消息队列（IPC）Python扩展
05-15
ftok：将路径名和项目标识符转换为System V IPC密钥 msgget：获取消息队列标识符 msgsnd：将消息发送到队列 msgrcv：从队列接收消息 msgctl：消息控制操作 有关系统调用的更多信息，请访问您的手册页。 这个想法是...
Linux中System V进程通信机制及访问控制技术的改进.pdf
09-07
在Linux操作系统中，System V进程通信机制是一种古老而强大的进程间通信（IPC）方式，它提供了消息队列、共享内存和信号量三种主要的通信工具。这些机制允许不同进程之间交换数据，协同工作，实现复杂任务的同步和...
SYSV IPC-共享内存
Edidaughter的博客
10-18 921
占位
System V IPC相关介绍
qq_57611608的博客
03-06 744
System V IPC 总的包括：消息队列，共享内存、信号量。 IPC的使用注意： 1.IPC资源仅在本机中使用，不能够跨网络使用。 2.IPC的资源生存周期与内核相同。除非删除，不然会与系统的生存周期相同。 3.（重要）每个IPC都有一个关键字key。每个IPC资源都有唯一的整型标识符，进程可以使用id对此资源进行访问。 4.在IPC资源中又会有一个结构体Xid_ds进行其属性的记录。其中X可以是sem(信号量)、shm（共享内存）、msg(消息队列)。 5.有两个命令可以方便我们查看.
system V IPC进程间通信机制一网打尽
小杰312的博客
04-27 6341
system V IPC进程间通信机制一网打尽
Linux-C 进程通信之system-V IPC
Genven_Liang的博客
08-24 2158
Linux-C 进程通信之system-V IPC 一、简述 记--简单的system-VIPC 例子。其中包括消息队列、共享内存、信号量。 多进程间使用IPC对象进行通信。有一个key值唯一标识这个IPC对象。 使用命令：ipcs -a 来查看所有IPC对象 或者使用:ipcs -q 查看消息队列...
SYSTEM V IPC 基本概念
最实用的Linux博客
08-26 1682
发信人: ben (ben), 信区: Linux标 题: LPG 6.4.1 SYSTEM V IPC 基本概念发信站: 逸仙时空 Yat-sen Channel (Sat Dec 25 02:23:46 1999), 站内信件6.4.1 基本概念 在SYSTEM V,AT&T中引入的IPC(交互进程
linux进程通信IPC之IPC_PRIVATE与ftok比较
热门推荐
enockipp的小'码'头
11-18 1万+
在linux中，可以使用IPC对象来进行进程间通信。IPC对象存在于内核中，多进程可以操作同一个IPC对象。 每个IPC对象都有一个唯一的编号，该编号是由系统分配的。那么不同的进程如何知道这个编号，进而通过它进行通信呢？下面以共享内存为例，进行分析。 方法一：通过ftok函数，产生相同的键值。 假设，进程p1创建了共享内存。可以在创建时，调用ftok函数，得到一个key值，调用s
SystemV中ftok()应该注意的问题
笑面虎的专栏
04-14 1747
    今天看到同事写的代码，在多进程之间做互斥时，使用semget()获取信号量的值。其中的变量key通过ftok()获得。    以上的操作都是符合逻辑的，也没有问题。    但是他怕信号量文件被删掉，在ftok()之前，查看了该文件是否存在，并且当文件不存在时，创建文件。    一切看上去都是那么合理。但是ftok()这么使用存在很大的风险。即便是同样的文件名称、路径，也可能会生
linux 内核 SysV IPC sem信号量实现
hanxb的专栏
05-01 488
linux 可靠的进程间锁： 文件锁 system_v_sem https://blog.csdn.net/Morphad/article/details/9141509
Linux：进程间通信IPC（SysV IPC）之消息队列
桔子
04-25 1699
想要有顺序地学习Linux，入口在这里哦： Linux：目录索引 消息队列的结构 0.消息队列、消息缓存块和通道 在学习“进程之间是如何使用消息队列进行通信”之前，先要知道： 什么消息队列 什么是消息缓存块 什么是通道 ①消息队列：一种数据结构，即队列，其详细内容暂不讨论 ②消息缓冲块：一种数据结构，用于存储信息，进程之间通信的方法之一，代码结构如下： st...
System V IPC：进程间通信机制探索
实验旨在让读者理解System V IPC的工作原理，并熟练掌握使用这些通信方式来实现进程间的同步和通信。" System V的进程间通信（IPC）是操作系统提供的一种机制，使得不同进程之间可以有效地交换数据和协调执行。这一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

孤独memories

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值