在本文中，我们将给您介绍关于linuxftok的详细内容，并且为您解答函数--多进程IPC之共享内存的相关问题，此外，我们还将为您提供关于c/c++linux进程间通信系列4，使用共享内存、IPC之共
在本文中，我们将给您介绍关于linux ftok的详细内容，并且为您解答函数 -- 多进程 IPC 之共享内存的相关问题，此外，我们还将为您提供关于c/c++ linux 进程间通信系列 4，使用共享内存、IPC之共享内存、IPC进程间通信---共享内存、Linux --进程间通信--共享内存的知识。
本文目录一览：- linux ftok（）函数 -- 多进程 IPC 之共享内存（linux进程间共享内存）
- c/c++ linux 进程间通信系列 4，使用共享内存
- IPC之共享内存
- IPC进程间通信---共享内存
- Linux --进程间通信--共享内存
linux ftok（）函数 -- 多进程 IPC 之共享内存（linux进程间共享内存）
系统建立 IPC 通讯（如消息队列、共享内存时）必须指定一个 ID 值。通常情况下，该 id 值通过 ftok 函数得到。
ftok 原型如下：
key_t ftok( char * fname, int id )
fname 就时你指定的文件名 (该文件必须是存在而且可以访问的)，id 是子序号，虽然为 int，但是只有 8 个比特被使用 (0-255)。
当成功执行的时候，一个 key_t 值将会被返回，否则 -1 被返回。
在一般的 UNIX 实现中，是将文件的索引节点号取出，前面加上子序号得到 key_t 的返回值。如指定文件的索引节点号为 65538，换算成 16 进制为 0x010002，而你指定的 ID 值为 38，换算成 16 进制为 0x26，则最后的 key_t 返回值为 0x26010002。
查询文件索引节点号的方法是： ls -i
以下为测试程序：
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#define IPCKEY 0x11
int main( void )
{
int i=0;
for ( i = 1; i < 256; ++ i )
printf( "key = %x\n", ftok( "/tmp", i ) );
return 0;
}
在成功获取到 key 之后，就可以使用该 key 作为某种方法的进程间通信的 key 值，例如 shmget 共享内存的方式。
shmget 的函数原型为
int shmget( key_t, size_t, flag);
在创建成功后，就返回共享内存的描述符。在 shmget 中使用到的 key_t 就是通过 ftok 的方式生成的
实例:
#include <sys/shm.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#define SIZE 1024
extern int errno;
int main()
{
int shmid;
char *shmptr;
// 创建共享内存
if((shmid = shmget(IPC_PRIVATE, SIZE, 0600)) < 0)
{
printf("shmget error:%s\n", strerror(errno));
return -1;
}
// 将共享内存连接到 可用地址上
if((shmptr = (char*)shmat(shmid, 0, 0)) == (void*)-1)
{
printf("shmat error:%s\n", strerror(errno));
return -1;
}
memcpy(shmptr, "hello world", sizeof("hello world"));
printf("share memory from %lx to %lx, content:%s\n",(unsigned long)shmptr, (unsigned long)(shmptr + SIZE), shmptr);
// 拆卸共享内存
if((shmctl(shmid, IPC_RMID, 0) < 0))
{
printf("shmctl error:%s\n", strerror(errno));
return -1;
}
}
多进程之间共享内存情况:
#include <sys/shm.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#define SIZE 1024
extern int errno;
int main()
{
int shmid;
char *shmptr;
key_t key;
pid_t pid;
if((pid = fork()) < 0)
{
printf("fork error:%s\n", strerror(errno));
return -1;
}
else if(pid == 0)
{
sleep(2);
if((key = ftok("/dev/null", 1)) < 0)
{
printf("ftok error:%s\n", strerror(errno));
return -1;
}
if((shmid = shmget(key, SIZE, 0600)) < 0)
{
printf("shmget error:%s\n", strerror(errno));
exit(-1);
}
if((shmptr = (char*)shmat(shmid, 0, 0)) == (void*)-1)
{
printf("shmat error:%s\n", strerror(errno));
exit(-1);
}
//memcpy(shmptr, "hello world", sizeof("hello world"));
printf("child:pid is %d,share memory from %lx to %lx, content:%s\n",getpid(), (unsigned long)shmptr, (unsigned long)(shmptr + SIZE
), shmptr);
printf("child process sleep 2 seconds\n");
sleep(2);
if((shmctl(shmid, IPC_RMID, 0) < 0))
{
printf("shmctl error:%s\n", strerror(errno));
exit(-1);
}
exit(0);
}
//parent
else
{
if((key = ftok("/dev/null", 1)) < 0)
{
printf("ftok error:%s\n", strerror(errno));
return -1;
}
if((shmid = shmget(key, SIZE, 0600|IPC_CREAT|IPC_EXCL)) < 0)
{
printf("shmget error:%s\n", strerror(errno));
exit(-1);
}
if((shmptr = (char*)shmat(shmid, 0, 0)) == (void*)-1)
{
printf("shmat error:%s\n", strerror(errno));
exit(-1);
}
memcpy(shmptr, "hello world", sizeof("hello world"));
printf("parent:pid is %d,share memory from %lx to %lx, content:%s\n",getpid(),(unsigned long)shmptr, (unsigned long)(shmptr + SIZE
), shmptr);
printf("parent process sleep 2 seconds\n");
sleep(2);
if((shmctl(shmid, IPC_RMID, 0) < 0))
{
printf("shmctl error:%s\n", strerror(errno));
exit(-1);
}
}
waitpid(pid,NULL,0);
exit(0);
}
c/c++ linux 进程间通信系列 4，使用共享内存
linux 进程间通信系列 4，使用共享内存
<font color="green">
1，创建共享内存，用到的函数 shmget, shmat, shmdt
| 函数名 | 功能描述 |
|---|---|
| shmget | 创建共享内存，返回 pic key |
| shmat | 第一次创建完共享内存时，它还不能被任何进程访问，shmat () 函数的作用就是用来启动对该共享内存的访问，并把共享内存连接到当前进程的地址空间 |
| shmdt | 该函数用于将共享内存从当前进程中分离。注意，将共享内存分离并不是删除它，只是使该共享内存对当前进程不再可用。 |
int shmget(key_t key, size_t size, int shmflg);
-
第一个参数，与信号量的 semget 函数一样，程序需要提供一个参数 key（非 0 整数），它有效地为共享内存段命名，shmget () 函数成功时返回一个与 key 相关的共享内存标识符（非负整数），用于后续的共享内存函数。调用失败返回 - 1.
不相关的进程可以通过该函数的返回值访问同一共享内存，它代表程序可能要使用的某个资源，程序对所有共享内存的访问都是间接的，程序先通过调用 shmget () 函数并提供一个键，再由系统生成一个相应的共享内存标识符（shmget () 函数的返回值），只有 shmget () 函数才直接使用信号量键，所有其他的信号量函数使用由 semget 函数返回的信号量标识符。
-
第二个参数，size 以字节为单位指定需要共享的内存容量
-
第三个参数，shmflg 是权限标志，它的作用与 open 函数的 mode 参数一样，如果要想在 key 标识的共享内存不存在时，创建它的话，可以与 IPC_CREAT 做或操作。共享内存的权限标志与文件的读写权限一样，举例来说，0644, 它表示允许一个进程创建的共享内存被内存创建者所拥有的进程向共享内存读取和写入数据，同时其他用户创建的进程只能读取共享内存。
void *shmat(int shm_id, const void *shm_addr, int shmflg);
- 第一个参数，shm_id 是由 shmget () 函数返回的共享内存标识。
- 第二个参数，shm_addr 指定共享内存连接到当前进程中的地址位置，通常为空，表示让系统来选择共享内存的地址。
- 第三个参数，shm_flg 是一组标志位，通常为 0。
调用成功时返回一个指向共享内存第一个字节的指针，如果调用失败返回 - 1.
</font>
<font color="orange">
2，访问共享内存
3，删除共享内存
int shmctl(int shm_id, int command, struct shmid_ds *buf);
- 第一个参数，shm_id 是 shmget () 函数返回的共享内存标识符。
- 第二个参数，command 是要采取的操作，它可以取下面的三个值 ：
- PC_STAT：把 shmid_ds 结构中的数据设置为共享内存的当前关联值，即用共享内存的当前关联值覆盖 shmid_ds 的值。
- IPC_SET：如果进程有足够的权限，就把共享内存的当前关联值设置为 shmid_ds 结构中给出的值
- IPC_RMID：删除共享内存段
- 第三个参数，buf 是一个结构指针，它指向共享内存模式和访问权限的结构。
</font>
<font color="green">
1，创建共享内存，用到的函数 shmget, shmat, shmdt
</font>
#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
int main(){
int shm;
char* ptr;
shm = shmget(IPC_PRIVATE, 129, IPC_CREAT | 0600);
if(shm < 0){
perror("shmget");
return 1;
}
ptr = (char*)shmat(shm, NULL , 0);
if(atoi(ptr) == -1){
perror("shmat");
return -1;
}
strcpy(ptr, "HELLO");
shmdt(ptr);
return 0;
}
github 源代码
用下面的命令，能够查看到上面的程序创建的共享内存。
ipcs -m
<font color="orange">
2，访问共享内存
</font>
#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
int main(int argc, char* argv[]){
int shm;
char* ptr;
if(argc != 2){
return 1;
}
shm = atoi(argv[1]);
ptr = (char*)shmat(shm, NULL, 0);
if(atoi(ptr) == -1){
perror("shmat");
return 1;
}
printf("string from shared memory : %s\n", ptr);
shmdt(ptr);
return 0;
}
github 源代码
执行方法：【ipcs -m】执行后，得到下面的数字。
./a.out 789884
<font color="orange">
3，删除共享内存
</font>
#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
int main(int argc, char* argv[]){
int shm;
shmid_ds sds;
if(argc != 2){
printf("argc is wrong");
return 1;
}
shm = atoi(argv[1]);
if(shmctl(shm, IPC_RMID, &sds) != 0){
perror("shmctl");
return 1;
}
return 0;
}
用命令行删除共享内存：【ipcs -m】执行后，得到下面的数字。
ipcrm -m 321843
github 源代码
<font color="green">
c/c++ 学习互助 QQ 群：877684253
本人微信：xiaoshitou5854
</font>
IPC之共享内存
共享内存作为IPC（Inter-Process Communication）的一种方式，适合同一台机器上不同进程间的相互通信，由于不同进程直接对同一块"约定好"的内存进行操作，因此效率为所有IPC中最高的。
共享内存的使用还是很简单的，主要涉及到五个函数的使用，下面一一进行介绍。
（1）key_t ftok(const char *pathname, int proj_id);
功能：用来创建System V IPC的一个key值
参数：pathname:系统中真实存在的并可以访问的目录或文件
proj_id :在1~255之间的数值，可以用来标识这是该进程创建的第几块共享内存
返回值：成功则返回一个key_t值；失败返回-1.
（2）int shmget(key_t key, size_t size, int shmflg);
功能：用来创建一块共享内存
参数： key :由ftok返回的值
size :需要创建共享内存的大小
shmflg:共享内存的模式及权限标识
模式可以取如下值：
IPC_CREAT： 新建一块共享内存
IPC_ALLOC： 使用已开辟的内存
IPC_EXCL ： 如果标识符已存在，则返回错误值
返回值：成功则返回一个标志值；失败返回-1.
（3）void *shmat(int shmid, const void *shmaddr, int shmflg);
功能：把由shmid标识的共享内存attach到该进程的地址空间
参数： shmid :由shmget返回的共享内存的标志
shmaddr :把共享内存attach在进程地址空间的起始地址，一般设为0
shmflg :进程对该内存的操作模式。SHM_RDONLY表示只读模式，其它为读写模式。
返回值：成功则返回一个共享内存起始地址；失败返回(void *)-1.
（4）int shmdt(const void *shmaddr);
功能：删除一块共享内存
参数： shmaddr :要从进程中detach的共享内存地址
返回值：成功则返回0；失败返回-1.
（5） int shmctl(int shmid, int cmd, struct shmid_ds *buf);
功能：执行对共享内存的控制
参数： shmid :标志共享内存的id
cmd :控制命令，可取值如下：
IPC_STAT ：得到共享内存的状态IPC_SET ：改变共享内存的状态
IPC_RMID ：删除共享内存
buf ：用来存放共享内存的状态
返回值：失败返回-1；成功返回其他值。
下面看两个使用共享内存通信进程的例子：
//process1.cc
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#define MAX_SHM_SIZE 1024*1024
int main(int argc, char *argv[])
{
const char *name = "/home/pathenon/project/network";
int i = 1;
key_t key = ftok(name, i);
if(-1 == key)
{
perror("ftok");
return 1;
}
int shm_id=shmget(key, MAX_SHM_SIZE, IPC_CREAT|0666);
if(-1 == shm_id)
{
perror("shmget");
return 1;
}
char buffer[] = "Hello share memory ipc\n";
char *p = (char *)shmat(shm_id, 0, 0);
if((void *)-1 == (void *)p)
{
perror("shmat");
return 1;
}
//write memory
int size = sizeof(buffer);
memcpy(p, &size, 4);
memcpy(p+4, buffer, sizeof(buffer));
shmdt(p);
return 0;
}
//process2.cc
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#define MAX_SHM_SIZE 1024*1024
int main()
{
const char *name = "/home/pathenon/project/network";
int i = 1;
key_t key = ftok(name, i);
if(-1 == key)
{
perror("ftok");
return 1;
}
int shm_id=shmget(key, MAX_SHM_SIZE, IPC_CREAT|0666);
if(-1 == shm_id)
{
perror("shmget");
return 1;
}
char *p = (char *)shmat(shm_id, 0, 0);
if((void *)-1 == (void *)p)
{
perror("shmat");
return 1;
}
//read memory
int size;
memcpy(&size, p, 4);
char buffer[1024] = {''\0''};
memcpy(buffer, p+4, size);
printf("%s", buffer);
shmdt(p);
return 0;
}分别编译上面两个程序，并先运行第一个可执行程序，后运行第二个，会发现输出：Hello share memory ipc
我们可以总结一下使用共享内存的大致步骤：
1.使用ftok获得一个key_t值
2.使用 shmget()开辟一块共享内存
3.使用shmat()允许本进程使用某块共享内存
4.对共享内存进行操作
5.禁止本进程使用这块共享内存 shmdt()
6.使用shmctl()或者命令行下ipcrm删除这块共享内存
注意:在使用完共享内存后，如果没有在程序中用shmctl()删除共享内存就退出程序，一定要在命令行下用ipcrm命令删除这块共享内存否则它就一直在那儿放着。
下面使用ipcs命令和ipcrm命令来查看与删除共享内存。
>ipcs -m
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00000000 65538 yangfan 600 196608 2
>ipcrm -m 65538
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00000000 65538 yangfan 600 196608 2 dest
IPC进程间通信---共享内存
共享内存
共享内存：共享内存就是分配一块能被其它进程访问的内存。每个共享内存段在内核中维护着一个内部结构shmid_ds，
该结构定义在头文件linux/shm.h中，其结构如下：
struct shmid_ds
{
struct ipc_perm shm_perm; //操作许可，里面包含共享内存的用户ID、组ID等信息
int shm_segsz; //共享内存段的大小，单位为字节
__kernel_time_t shm_atime; //最后一个进程访问共享内存的时间
__kernel_time_t shm_dtime; //最后一个进程离开共享内存的时间
__kernel_time_t shm_ctime; //最后一次修改共享内存的时间
__kernel_ipc_pid_t shm_cpid; //创建共享内存的进程ID
__kernel_ipc_pid_t shm_lpid; //最后操作共享内存的进程ID
ushort shm_nattch; //当前使用该共享内存段的进程数量
ushort shm_unused;
void *shm_unused2;
void *shm_unused3;
};要获得一个共享内存的描述符，只需提供该共享内存的键值即可，该键值通常由函数ftok返回，该函数原形为：
#include <sys/ipc.h>
key_t ftok(const char *pathname,int proj_id);
创建一个新的共享内存或访问一个已存在的共享内存前需要使用ftok函数得到key值，下面是ftok函数的包裹函数：
key_t Ftok(const char *pathname,int proj_id)
{
key_t key= ftok(pathname,proj_id);
if(key== -1)
{
perror("ftok.");
exit(1);
}
return key;
}共享内存的创建或打开：
Linux下使用shmget函数来创建一个共享内存区，或者访问已经存在的共享内存区。该函数定义在头文件<sys/shm.h>
中，该函数原形为：
#include <sys/ipc.h>
#include <sys/msg.h>
int shmget(key_t key,size_t size,int shmflg);
函数中，第一个参数是由ftok()函数得到的键值，第二个参数size为以字节为单位指定内存的大小，第三个参数shmflg为
操作标志位，它的值为一些宏，如下所示：
- IPC_CREAT：调用shmget时，系统将此值与其它所有共享内存区的key值进行比较，如果存在相同的key，说明共享内
存区已存在，此时返回该共享内存区的标识符，否则新建一个共享内存区并返回其标识符。
- IPC_EXCL：该宏必须和IPC_CREAT一起使用，否则没有意义。当shmget取IPC_CREAT|IPC_EXCL时，表示如果发现信号
集已经存在，则返回-1，错误码为EEXIST。
共享内存区的操作：
在使用共享内存区前，必须通过shmat函数将其附加到进程的地址空间。进程与共享内存就建立了连接。shmat调用成
功后就会返回一个指向共享内存区的指针，使用该指针就可以访问共享内存区了，如果失败返回-1。该函数声明在头文件
<sys/shm.h>中，该函数原形为：
#include <sys/types.h>
#include <sys/shm.h>
void* shmat(int shmid,const void *shmaddr,int shmflg);
函数中参数shmid为shmget函数的返回值，参数shmaddr为共享内存的附加点，参数shmflg为存取权限标志，参数shmaddr
不同取值情况的含义说明如下：
- 如果为空，则由内核选择一个空闲的内存区；如果非空，返回地址取决于调用者是否给shmflg参数指定了SHM_RND值，
如果没有指定，则共享内存区附加到由shmaddr指定的地址；否则附加地址为shmaddr向下舍入一个共享内存低端边界地址
后地址（SHMLBA，一个常址）。
- 通常将参数shmaddr设置为NULL。
当进程结束使用共享内存区时，要通过函数shmdt断开与共享内存区的连接。该函数声明在<sys/shm.h>头文件中，该
函数原形为：
#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);
参数shmaddr为shmat函数的返回值。该函数调用成功后，返回0，否则返回-1。进程脱离共享内存区后，数据结构shmid_ds
中的shm_nattch就会减1。但是共享内存段依然存在，只有shm_nattch为0后，即没有任何进程再使用共享内存区，共享内存
区才在内核中被删除。一般来说，当一个进程终止时，它所附加的共享内存区都会自动脱离。
共享内存区的控制：
对共享内存区的控制是通过函数shmctl来完成的，该函数定义在<sys/shm.h>中，该函数原形为：
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid,int cmd,struct shmid_ds *buf);
函数中，参数shmid为共享内存区的标识符；参数buf为指向shmid_ds结构体的指针；cmd为操作标志位，支持以下控制操作：
- IPC_RMID：从系统中删除由shmid标识的共享内存区。
- IPC_SET：设置共享内存区的shmid_ds结构。
- IPC_STAT：读取共享内存区的shmid_ds结构，并将其存储到buf指向的地址中。
下面是使用共享内存区发送消息的例子：
// myipc.h
#pragma once
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/msg.h>
union semun
{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};
key_t Ftok(const char *pathname,int proj_id)
{
key_t key= ftok(pathname,proj_id);
if(key== -1)
{
perror("ftok.");
exit(1);
}
return key;
}//server.c
#include "myipc.h"
int main(int argc,char *argv[])
{
key_t shm_key= Ftok(argv[1],atoi(argv[2]));
int shm_id= shmget(shm_key,1024,IPC_CREAT|0755);
if(shm_id== -1)
{
perror("shmget");
exit(1);
}
char *addr= (char*)shmat(shm_id,NULL,0);
if((void*)addr== (void*)-1)
{
perror("shmat");
shmctl(shm_id,IPC_RMID,NULL);
exit(1);
}
key_t sem_key= shm_key;
int sem_id= semget(sem_key,2,IPC_CREAT|0755);
struct sembuf p= {0,-1,0};
struct sembuf v= {1,1,0};
while(1)
{
printf("Ser: ");
scanf("%s",addr);
semop(sem_id,&v,1);
semop(sem_id,&p,1);
printf("Cli: %s\n",addr);
}
shmdt(addr);
semctl(sem_id,0,IPC_RMID);
semctl(sem_id,1,IPC_RMID);
shmctl(shm_id,IPC_RMID,NULL);
return 0;
}//client.c
#include "myipc.h"
int main(int argc,char *argv[])
{
key_t shm_key= Ftok(argv[1],atoi(argv[2]));
int shm_id= shmget(shm_key,0,0);
char *addr= (char*)shmat(shm_id,NULL,0);
key_t sem_key= shm_key;
int sem_id= semget(sem_key,0,0);
struct sembuf p= {1,-1,0};
struct sembuf v= {0,1,0};
while(1)
{
semop(sem_id,&p,1);
printf("Ser: %s\n",addr);
printf("Cli: ");
scanf("%s",addr);
semop(sem_id,&v,1);
}
shmdt(addr);
return 0;
}
Linux --进程间通信--共享内存
一、共享内存
共享内存是最高效的通信方式，因为不需要一个进程先拷贝到内核，另一个进程在存内核中读取。
二、 ipcs -m 查看共享内存
ipcrm -m 删除共享内存
三、主要函数
shmget 创建
shmctl 删除
shmat 挂接
shmdt 取消挂接
********* man 函数名 查看*****
四、代码实现
comm.h
1 #pragma once 2 #include<stdio.h> 3 #include<stdlib.h> 4 #include<unistd.h> 5 #include<sys/ipc.h> 6 #include<sys/shm.h> 7 #define _PATH_ "." 8 #define _PROJID_ 0x666 9 #define _SHM_SIZE_ 4096 10 int getShmget(); 11 int destoryShm(int shm_id); 12 char* at_shm(int shm_id); 13 int delete_Shm(char *addr);
comm.c
1 #include"comm.h"
2 int getShmget()
3 {
4 key_t key=ftok(_PATH_,_PROJID_);
5
6 int shmflg=IPC_CREAT |0666;
7 int shm_id=shmget(key,_SHM_SIZE_,shmflg);
8 if(shm_id<0)
9 {
10 perror("shmget");
11 return -1;
12 }
13 return shm_id;
14 }
15
16 int destoryShm(int shm_id)
17 {
18 return shmctl(shm_id,IPC_RMID,NULL);
19 }
20
21 char* at_shm(int shm_id)
22 {
23 return (char*)shmat(shm_id,NULL,0);
24 }
25 int delete_Shm(char *addr)
26 {
27 return shmdt(addr);
28 }client.c
1 #include"comm.h"
2 int main()
3 {
4 int shm_id=getShmget();
5 char *addr=at_shm(shm_id);
6 int i=0;
7 for(;i<_SHM_SIZE_;i++)
8 {
9 addr[i ]='A';
10 addr[i+1]='\0';
11 sleep(1);
12 }
13 delete_Shm(addr);
14 return 0;
15 }server.c
1 #include"comm.h"
2 int main()
3 {
4 int shm_id=getShmget();
5 char * addr=at_shm(shm_id);
6 int i=0;
7 for(;i<_SHM_SIZE_;i++)
8 {
9 printf("%s\n",addr);
10 sleep(1);
11 }
12 delete_Shm(addr);
13 destoryShm(shm_id);
14 return 0;
15 }运行结果
以上就是Linux --进程间通信--共享内存的内容。
关于linux ftok和函数 -- 多进程 IPC 之共享内存的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于c/c++ linux 进程间通信系列 4，使用共享内存、IPC之共享内存、IPC进程间通信---共享内存、Linux --进程间通信--共享内存等相关知识的信息别忘了在本站进行查找喔。
本文标签：
