精华内容
下载资源
问答
  • 2021-03-07 19:38:04

    创建共享内存

    int shmget( key_t key, size_t size, int flag );
    //such as:
            key_t key = ftok(".",1);
            shmId = shmget(key,1024*4,IPC_CREAT|0666);
            if(shmId == -1){
                    perror("shmget:");
                    return -1;
            }
    

    第一个参数 key
    系统建立IPC通讯 (消息队列、信号量和共享内存) 时必须指定一个ID值。通常情况下,该id值通过ftok函数得到。

    key_t ftok( const char * fname, int id )
    fname就是你指定的文件名(已经存在的文件名),一般使用当前目录,如:
    key_t key;
    key = ftok(".", 1); 这样就是将fname设为当前目录。
    id是子序号。虽然是int类型,但是只使用8bits(1-255)。

    第二个参数 size
    内核是以页为单位分配内存,当size参数的值不是系统内存页长的整数倍时,系统会分配给进程最小的可以满足size长的页数,但是最后一页的剩余部分内存是不可用的。

    简单来说,就是1024的倍数
    注意:只获取共享内存时指定为0

    第三个参数 flag

    IPC_CREAT:如果内核中不存在键值与key相等的共享内存,则新建一个共享内存;如果存在这样的共享内存,返回此共享内存的标识符

    IPC_CREAT|IPC_EXCL:如果内核中不存在键值 与key相等的共享内存,则新建一个共享内存;如果存在这样的共享内存则报错

    0:返回共享内存的标识符

    注意:上述shmflg参数为模式标志参数,使用时需要与IPC对象存取权限(如0600)进行|运算来确定信号量集的存取权限

    更多相关内容
  • 共享内存是系统出于多个进程之间通讯的考虑,而预留的的一块内存区。在/proc/sys/kernel/目录下,记录着...一、应用共享内存的使用,主要有以下几个API:ftok()、shmget()、shmat()、shmdt()及shmctl()。1)用ftok...

    共享内存是系统出于多个进程之间通讯的考虑,而预留的的一块内存区。在/proc/sys/kernel/目录下,记录着共享内存的一些限制,如一

    个共享内存区的最大字节数shmmax,系统范围内最大共享内存区标识符数shmmni等,可以手工对其调整,但不推荐这样做。

    一、应用

    共享内存的使用,主要有以下几个API:ftok()、shmget()、shmat()、shmdt()及shmctl()。

    1)用ftok()函数获得一个ID号.

    应用说明:

    在IPC中,我们经常用用key_t的值来创建或者打开信号量,共享内存和消息队列。

    函数原型:

    key_t ftok(const char *pathname, int proj_id);

    Keys:

    1)pathname一定要在系统中存在并且进程能够访问的

    3)proj_id是一个1-255之间的一个整数值,典型的值是一个ASCII值。

    当成功执行的时候,一个key_t值将会被返回,否则-1被返回。我们可以使用strerror(errno)来确定具体的错误信息。

    考虑到应用系统可能在不同的主机上应用,可以直接定义一个key,而不用ftok获得:

    #define IPCKEY 0x344378

    2)shmget()用来开辟/指向一块共享内存的函数

    应用说明:

    shmget()用来获得共享内存区域的ID,如果不存在指定的共享区域就创建相应的区域。

    函数原型:

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

    key_t key

    是这块共享内存的标识符。如果是父子关系的进程间通信的话,这个标识符用IPC_PRIVATE来代替。如果两个进程没有任何关系,所以就用ftok()算出来一个标识符(或者自己定义一个)使用了。

    int size 是这块内存的大小.

    int flag 是这块内存的模式(mode)以及权限标识。

    模式可取如下值:

    IPC_CREAT 新建(如果已创建则返回目前共享内存的id)

    IPC_EXCL  与IPC_CREAT结合使用,如果已创建则则返回错误

    然后将“模式” 和“权限标识”进行“或”运算,做为第三个参数。

    如:  IPC_CREAT | IPC_EXCL |

    0640

    例子中的0666为权限标识,4/2/1

    分别表示读/写/执行3种权限,第一个0是UID,第一个6(4+2)表示拥有者的权限,第二个4表示同组权限,第3个0表示他人的权限。

    这个函数成功时返回共享内存的ID,失败时返回-1。

    关于这个函数,要多说两句。

    创建共享内存时,shmflg参数至少需要 IPC_CREAT | 权限标识,如果只有IPC_CREAT

    则申请的地址都是k=0xffffffff,不能使用;

    取已创建的共享内存时,shmflg不要用IPC_CREAT(只能用创建共享内存时的权限标识,如0640),否则在某些情况下,比如用ipcrm删除

    共享内存后,用该函数并用IPC_CREAT参数获取一次共享内存(当然,获取失败),则即使再次创建共享内存也不能成功,此时必须更改key来重建共享

    内存。

    3) shmat()将这个内存区映射到本进程的虚拟地址空间。

    函数原型:

    void  *shmat( int shmid ,

    char *shmaddr , int shmflag );

    shmat()是用来允许本进程访问一块共享内存的函数。

    int shmid是那块共享内存的ID。

    char

    *shmaddr是共享内存的起始地址,如果shmaddr为0,内核会把共享内存映像到调用进程的地址空间中选定位置;如果shmaddr不为0,内核会把共享内存映像到shmaddr指定的位置。所以一般把shmaddr设为0。

    int shmflag是本进程对该内存的操作模式。如果是SHM_RDONLY的话,就是只读模式。其它的是读写模式

    成功时,这个函数返回共享内存的起始地址。失败时返回-1。

    4)

    shmdt()函数删除本进程对这块内存的使用,shmdt()与shmat()相反,是用来禁止本进程访问一块共享内存的函数。

    函数原型:

    int shmdt( char *shmaddr );

    参数char *shmaddr是那块共享内存的起始地址。

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

    5) shmctl() 控制对这块共享内存的使用

    函数原型:

    int  shmctl( int shmid ,

    int cmd , struct shmid_ds *buf );

    int shmid是共享内存的ID。

    int cmd是控制命令,可取值如下:

    IPC_STAT  得到共享内存的状态

    IPC_SET  改变共享内存的状态

    IPC_RMID  删除共享内存

    struct shmid_ds

    *buf是一个结构体指针。IPC_STAT的时候,取得的状态放在这个结构体中。如果要改变共享内存的状态,用这个结构体指定。

    返回值:  成功:0

    失败:-1

    接下去是两个demo

    write部分

    #include

    #include

    #include

    #include

    #include

    typedef struct {

    char name;

    int age;

    }people;

    int main(void)

    {

    int shm_id,i;

    key_t key;

    people *p_map;

    key =

    ftok("/home/beichenming/class3",0);

    if (key == -1)

    {

    perror("ftok error");

    exit(1);

    }

    printf("key

    %d\n",key);

    shm_id = shmget(key,

    2048,IPC_CREAT | IPC_EXCL | 0666);

    if (shm_id == -1)

    {

    perror("shmget error");

    exit(1);

    }

    printf("shm_id

    %d\n",shm_id);

    p_map =

    (people*)shmat(shm_id, NULL, 0);

    for (i = 0; i < 10;

    i++)

    {

    p_map[i].name = 'a';

    p_map[i].age = i;

    }

    shmdt(p_map);

    return 0;

    }

    read部分

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    typedef struct {

    char

    name;

    int

    age;

    }people;

    int main(void)

    {

    int shm_id,i;

    key_t key;

    people *p_map;

    key =

    ftok("/home/beichenming/class3",0);

    if (key == -1)

    {

    perror("ftok error");

    exit(1);

    }

    printf("key

    %d\n",key);

    shm_id =

    shmget(key,0,0);

    if (shm_id == -1)

    {

    perror("shmget error");

    exit(1);

    }

    printf("shm_id

    %d\n",shm_id);

    p_map =

    (people*)shmat(shm_id, NULL, 0);

    for (i = 0; i < 10 ;

    i ++)

    {

    printf("name %c\n",p_map[i].name);

    printf("age %d\n",p_map[i].age);

    }

    return 0;

    }

    代码下载地址

    ipc_write.c : http://pan.baidu.com/s/13maGp

    ipc_read.c:

    http://pan.baidu.com/s/1GJmaU

    展开全文
  • int shmget(key_t key, size_t size, int shmflg); 参数 size 是以字节为单位指定内存的大小;参数 shmflg 是操作标志,它的一些宏定义如下:IPC_CREATE : 调用 shmget 时,系统将此值与其他共享内存区的 ...

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

    参数 size 是以字节为单位指定内存的大小;

    参数 shmflg 是操作标志位,它的一些宏定义如下:

    IPC_CREATE : 调用 shmget 时,系统将此值与其他共享内存区的 key 进行比较,如果存在相同的 key ,说明共享内存区已存在,此时返回该共享内存区的标识符,否则新建一个共享内存区并返回其标识符。

    IPC_EXCL : 该宏必须和 IPC_CREATE 一起使用,否则没意义。当 shmflg 取 IPC_CREATE | IPC_EXCL 时,如果没有该块共享内存则创建,如果发现内存区已经存在则返回 -1,错误代码为 EEXIST 。


    注意,当创建一个新的共享内存区时,size 的值必须大于 0 ;如果是访问一个已经存在的内存共享区,则置 size 为 0




    共享内存的使得

    与信号量一样,在Linux中也提供了一组函数接口用于使用共享内存,而且使用共享共存的接口还与信号量的非常相似,而且比使用信号量的接口来得简单。它们声明在头文件 sys/shm.h 中。

    1、shmget()函数

    该函数用来创建共享内存,它的原型为:

    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,它表示允许一个进程创建的共享内存被内存创建者所拥有的进程向共享内存读取和写入数据,同时其他用户创建的进程只能读取共享内存。

    2、shmat()函数    -- at:attach

    第一次创建完共享内存时,它还不能被任何进程访问,shmat()函数的作用就是用来启动对该共享内存的访问,并把共享内存连接到当前进程的地址空间。它的原型如下:

    void *shmat(int shm_id, const void *shm_addr, int shmflg);

    第一个参数,shm_id是由shmget()函数返回的共享内存标识。

    第二个参数,shm_addr指定共享内存连接到当前进程中的地址位置,通常为空,表示让系统来选择共享内存的地址。

    第三个参数,shm_flg是一组标志位,通常为0。

    调用成功时返回一个指向共享内存第一个字节的指针,如果调用失败返回-1.

    3、shmdt()函数    -- dt:detach

    该函数用于将共享内存从当前进程中分离。注意,将共享内存分离并不是删除它,只是使该共享内存对当前进程不再可用。它的原型如下:

    int shmdt(const void *shmaddr);

    参数shmaddr是shmat()函数返回的地址指针,调用成功时返回0,失败时返回-1.

    4、shmctl()函数    -- ctl:control

    与信号量的semctl()函数一样,用来控制共享内存,它的原型如下:

    int shmctl(int shm_id, int command, struct shmid_ds *buf);

    第一个参数,shm_id是shmget()函数返回的共享内存标识符。

    第二个参数,command是要采取的操作,它可以取下面的三个值 :

    • IPC_STAT:把shmid_ds结构中的数据设置为共享内存的当前关联值,即用共享内存的当前关联值覆盖shmid_ds的值。
    • IPC_SET:如果进程有足够的权限,就把共享内存的当前关联值设置为shmid_ds结构中给出的值
    • IPC_RMID:删除共享内存段

    第三个参数,buf是一个结构指针,它指向共享内存模式和访问权限的结构。

    shmid_ds结构 至少包括以下成员:

    1
    2
    3
    4
    5
    6
    struct  shmid_ds
    {
         uid_t shm_perm.uid;
         uid_t shm_perm.gid;
         mode_t shm_perm.mode;
    };

    展开全文
  • SHMGET

    千次阅读 2019-11-25 10:13:42
    http://man7.org/linux/man-pages/man2/shmget.2.html 名称 shmget---分配一个system V 共享内存段 摘要 #include <sys/ipc.h>...int shmget(key_t key, size_t size, int shmflg); 描述 shmg...

    http://man7.org/linux/man-pages/man2/shmget.2.html

    名称

    shmget---分配一个system V 共享内存段

    摘要

    #include <sys/ipc.h>
    #include <sys/shm.h>

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

    描述

    shmget --- 分配一个system V共享内存段

    声明

    #include <sys/ipc.h>
     #include <sys/shm.h>

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

    描述

    shmget() 返回了参数key的值关联的system V 共享内存段的标识符。它可能用于获取之前已经创建的共享内存段的标识符(当shmflg是0, 且 key的值不是IPC_PRIVATE), 也可能是创建一个新的段。

    一个新的共享内存段,它的的size 等于参数size对齐到PAGE_SIZE的整数倍;如果key的值是 IPC_PRIVATE,则会创建该新的的共享内存段; 如果key的值不是 IPC_PRIVATE, 但是该参数key没有对应的共享内存段且shmflg中设置了IPC_CREAT,则创建新的共享内存段。

    如果shmflg 同时指定IPC_CREAT 和 IPC_EXCL ,并且该key的共享内存段已经存在,则  shmget() 会返回失败,errno 为 EEXIST。它仿照了open的 O_CREAT | O_EXCL 选项。

    shmflg的值可以是如下所示的组合:

    •  IPC_CREAT  创建一个新的段。如果这个flag没有使用,shmget()会查找key对应的共享内存段,并且检查用户是否有访问该内存段的权限。
    • IPC_EXCL   这个flag 与IPC_CREAT配合使用, 来确保这个调用会创建一个共享内存段。如果该内存段已经存在,则调用失败。
    • SHM_HUGETLB (since Linux 2.6)  使用“huge pages” 分配一个共享内存段。详细信息见linux内核源文件Documentation/admin-guide/mm/hugetlbpage.rst
    •  SHM_HUGE_2MB, SHM_HUGE_1GB  (since Linux 3.8)    与SHM_HUGETLB配合使用来选择 可选择的hugetlb page size(相应的是2MB 或 1GB),如果系统支持“multiple hugetlb page sizes”。 通常, “desired huge page size” 可以配置成“desired page size”的对数,使用 SHM_HUGE_SHIFT偏移6个bit 。因此,上面的两个常数定义如下:

                             #define SHM_HUGE_2MB    (21 << SHM_HUGE_SHIFT)
                             #define SHM_HUGE_1GB    (30 << SHM_HUGE_SHIFT)

                         其它的信息可以查看mmap函数操作。

    • SHM_NORESERVE (since Linux 2.6.15)  这个flag与mmap的MAP_NORESERVE flag相同的作用,不要为该内存段保留swap space。当保留swap space, 其中一个用户要保证它可能修改了内存段。当没有保留swap space, 在没有可用内存时, 一个用户可以获取SIGSEGV错误号。 可以在“proc”的/proc/sys/vm/overcommit_memory文件中查看。

    除了上面的flags, shmflg的最小的9个bits 指定了owner、group和others的权限。这些bits有相同的格式, 相同的含义,它们与open操作的mode参数一致。当前,执行权限没有被使用。

    当一个新的共享内存段被创建,它的内容被初始化为0值,并且它相关联的结构提数据,hmid_ds
           (see shmctl(2)),按如下的方式进行初始化。

    • shm_perm.cuid 和 shm_perm.uid 被设置成调用进行的有效用户ID。
    • shm_perm.cgid 和 shm_perm.gid  被设置成调用进程的有效 groupID。
    • shm_perm.mode的最小的9个bits 被设置成shmflg的最小的9个bits。
    • shm_segsz 被设置成 size的值。
    • shm_lpid, shm_nattch, shm_atime, and shm_dtime 被设置为0
    • shm_ctime 被设置成当前时间。

    如果共享内存段已经存在, 如果它标识为销毁, 会检查权限。

     

    返回值

    • 如果成功,会返回一个合法的共享内存段标识符。如果出错,会返回-1, errno 来标识出错的原因。

    ERRORS       如果出错,errno会被如下出错码的其中一个:

    • EACCES  用户没有访问共享内存段的权限,在管理它的IPC名字空间的用户名字空间内,它没有 CAP_IPC_OWNER 能力。
    •   EEXIST   在shmflg中指定了IPC_CREAT 和 IPC_EXCL,但是该key对应的共享内存段已经存在。
    • EINVAL  一个给定的key的内存段已经存在,但是它的size 大于已经存在的共享内存段。
    • ENFILE   系统级的限制, 限制打开文件的个数是否超过了限制。
    • ENOENT  给定的key不存在共享内存段, 并且没有指定IPC_CREAT。
    • ENOMEM 没有足够大的内存来分配共享内存段。
    • ENOSPC  所有可能的共享内存ID(SHMMNI)已经被使用,或者如果分配入参指定的size的内存段会引起超过系统级的共享内存的限制(SHMALL)。
    • EPERM  指定了SHM_HUGETLB, 但是调用者没有这个权限(没有 CAP_IPC_LOCK的权限)。

    遵循的协议

    • POSIX.1-2001, POSIX.1-2008, SVr4.
    • SHM_HUGETLB and SHM_NORESERVE are Linux extensions.

    说明:

    共享内存的限制:如下共享内存段资源的限制会影响到shmget()的调用:

    • SHMALL  System-wide limit on the total amount of shared memory, measured in units of the system page size.在linux 中,这个限制可以通过对 /proc/sys/kernel/shmall 读取和修改来获取或修改。从linux 3.16,该属性的默认值为:

                        ULONG_MAX - 2^24

                   该值的作用是对内存分配不做限制。

    • SHMMAX   Maximum size in bytes for a shared memory segment.在linux, 这个限制可以通过读取或修改/proc/sys/kernel/shmmax 文件来获取。从linux 3.16 该值默认为:

                        ULONG_MAX - 2^24

                   该值的作用是对内存的分配没有限制。

    • SHMMIN  Minimum size in bytes for a shared memory segment: implementation dependent (currently 1 byte, though PAGE_SIZE  is the effective minimum size, 也就是说,虽然设置为1个byte, 实际上分配了一个PAGE_SIZE大小的内存)。在linux系统中该值通过 /proc/sys/kernel/shmmni读取或修改。

    调用举例

    https://www.cnblogs.com/fangshenghui/p/4039720.html

    shmdata.h文件:

    #ifndef _SHMDATA_H_HEADER
    #define _SHMDATA_H_HEADER
    #define TEXT_SZ 2048

    struct shared_use_st
    {
        int written;/*flag , 0: write available; not 0: read availbe;*/
        char text[TEXT_SZ];/*the data*/
    };
    #endif

     

    shmread.c文件,共享内存读取;

    #include<unistd.h>
    #include<stdlib.h>
    #include<stdio.h>
    #include<sys/shm.h>
    #include"shmdata.h"

    #define MEM_KEY (1234)

    int main()
    {
        int running =1; //judge if or not process is running
        void*shm = NULL; //the addres of share memory segment 
        struct shared_use_st *shared;//point to shm
        int shmid; //share memory id
        //create share memory

        shmid = shmget((key_t)MEM_KEY,sizeof(struct shared_use_st),0666|IPC_CREAT);
        if(shmid ==-1)
        {
            fprintf(stderr,"shmget failed\n");
            exit(EXIT_FAILURE);
        }
        //attach shared memory to current process namespace
        shm = shmat(shmid,0,0);
        if(shm ==(void*)-1)
        {
            fprintf(stderr,"shmat failed\n");
            exit(EXIT_FAILURE);
        }
        printf("\nMemory attached at %X\n",(int)shm);
        //convert user defined structure data;
        shared =(struct shared_use_st*)shm;
        shared->written =0;
        while(running)//read share memory data
        {
            //judge if or not this memory can read, other words, if not write process push data into the memory
            if(shared->written !=0)
            {
                printf("You wrote: %s", shared->text);
                sleep(rand()%3);
                //after reading the data, set written flag is 0 for next writting
                shared->written =0;
                //if writing data is 'end', exit reading cycle process
                if(strncmp(shared->text,"end",3)==0)
                    running =0;
            }

            else//if no data input sleeping
                sleep(1);
        }
        //dis-attach the shared memory from current process
        if(shmdt(shm)==-1)
        {
            fprintf(stderr,"shmdt failed\n");
            exit(EXIT_FAILURE);
        }
        //delete the share memory
        if(shmctl(shmid, IPC_RMID,0)==-1)
        {
            fprintf(stderr,"shmctl(IPC_RMID) failed\n");
            exit(EXIT_FAILURE);
        }

        exit(EXIT_SUCCESS);
    }

     

     shwrite.c 文件---共享内存写入

    #include<unistd.h>
    #include<stdlib.h>
    #include<stdio.h>
    #include<string.h>
    #include<sys/shm.h>
    #include"shmdata.h"
    #define MEM_KEY (1234)

    int main()
    {
        int running =1;
        void*shm = NULL;
        struct shared_use_st *shared = NULL;
        char buffer[BUFSIZ +1];//used to save txt
        int shmid;
        //creat share memory segment 
        shmid = shmget((key_t)MEM_KEY,sizeof(struct shared_use_st),0666|IPC_CREAT);
        if(shmid ==-1)
        {
            fprintf(stderr,"shmget failed\n");
            exit(EXIT_FAILURE);
        }
        //associate the share memory to current process namespace
        shm = shmat(shmid,(void*)0,0);
        if(shm ==(void*)-1)
        {
            fprintf(stderr,"shmat failed\n");
            exit(EXIT_FAILURE);
        }
        printf("Memory attached at %X\n",(int)shm);
        //convert to our own structure obj
        shared =(struct shared_use_st*)shm;
        while(running)//write data to shared memory segment
        {
            //if data not read, waiting for reading , and do not write txt to this share memory
            while(shared->written ==1)
            {
                sleep(1);
                printf("Waiting...\n");
            }
            //write data to share memory segment 
            printf("Enter some text: ");
            fgets(buffer, BUFSIZ, stdin);
            strncpy(shared->text, buffer, TEXT_SZ);
            //if written is done, set the written flag as reading available
            shared->written =1;
            //input end, if we finish inputing the data, and exit the cycle , and exit the process
            if(strncmp(buffer,"end",3)==0)
                running =0;
        }
        //disattach the share memory from current process
        if(shmdt(shm)==-1)
        {
            fprintf(stderr,"shmdt failed\n");
            exit(EXIT_FAILURE);
        }
        sleep(2);
        exit(EXIT_SUCCESS);
    }
          

     
    展开全文
  • 文章目录共享内存介绍shmget:创建共享内存shmat:将创建好的共享内存连接到某个进程,并指定内存空间shmdt:脱钩函数,把共享内存与当前进程脱离开代码实例 共享内存介绍 共享内存是IPC中效率最高的一个,它是原理...
  • 共享内存_shmget

    2021-10-07 20:00:06
    文章目录共享内存创建共享内存映射共享内存删除共享内存父子进程共享内存共享内存通信 共享内存   共享内存是被多个...使用shmget函数创建共享内存。 使用shmat函数将创建的共享内存映射到具体的进程空间。 创建共
  • 共享内存的接口函数及指令 1、查看系统中的共享存储段 ipcs -m 1 ipcs-m 2、删除系统中的共享存储段 ipcrm -m [shmid] 1 ipcrm-m[shmid] 3、 shmget():创建共享内存 int shmget(key_t key, size_t size, int ...
  • 共享内存的常用函数详解shmget shmat

    千次阅读 2015-03-31 07:16:28
    int sys_shmget (key_t key, int size, int shmflg)         这里key是表示该共享内存对象的键值,size是该共享内存区域的大小(以字节为单位),shmflg是标志(对该共享内存对象的特殊要求)。     ...
  • shmget出现Invalid argument错误

    千次阅读 2015-09-16 21:37:28
    shmget出现Invalid argument错误的原因以及解决办法。
  • 共享内存函数由shmget、shmat、shmdt、shmctl四个函数组成。下面的表格列出了这四个函数的函数原型及其具体说明。1.   shmget函数原型shmget(得到一个共享内存标识符或创建一个共享内存对象)所需头文件#include...
  • 在linux中,可以使用IPC对象来进行进程间通信。IPC对象存在于内核中,多进程可以操作同一个IPC对象。 每个IPC对象都有一个唯一的编号,该编号是由系统分配的。...可以在创建时,调用ftok函数,得到一个key值,调用s
  • shmget报错Invalid argument

    千次阅读 2016-08-23 21:39:54
    一、先看测试代码 #include #include #include #include using namespace std; int main() { //int key=83886080; int key=53882300; int size=104595456;... int rtn = shmget(key,size,IPC_CREAT|0666
  • 共享内存函数由shmget、shmat、shmdt、shmctl四个函数组成。下面的表格列出了这四个函数的函数原型及其具体说明。 shmget函数原型 shmget(得到一个共享内存标识符或创建一个共享内存对象) 所需头文件 #include <...
  • Linux信号量 sem_t简介

    千次阅读 2015-02-27 22:14:00
    信号量的数据类型为结构sem_t,它本质上是一个长整型的数。 函数sem_init()用来初始化一个信号量。它的原型为:int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));sem为指向信号量结构的...
  • 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.共享...
  • int shmget(key_t key, size_t size, int shmflg) 函数传入值 key 0(IPC_PRIVATE):会建立新共享内存对象 大于0的32位整数:视参数shmflg来确定操作。...
  • 2014年4月2日共享内存函数(shmget、shmat、shmdt、shmctl)及其范例 - guoping16的专栏 - 博客频道 - http://doc.xuehai.net登录 | 注册guoping16的专栏目录视图摘要视图订阅个人资料2014开源技术大会(读书汇) ...
  •   进程间通信,传统的方式:无名管道(pipe)、有名管道(fifo)和信号(signal);...存在的IPC对象通过它的标识符来引用和访问,这个标识符是一个非负整数,它唯一的标识了一个IPC对象,这个IPC对象可...
  • 1、shmget()函数 该函数用来创建共享内存,它的原型为: int shmget(key_t key, size_t size, int shmflg); 第一个参数,与信号量的semget函数一样,程序需要提供一个参数key(非0整数),它有效地为共享内存段命名...
  • 今天复习到共享内存,将整个共享内存的使用精细的学习了一下,下面是跟据自己的理解和查找到的资料整理出来的。   使用共享内存共分四步:   我们用一个简短的例子来体验...shmid = shmget(IPC_PRIVATE, 4, 0); 
  • 共享内存(shared memory)共享内存1、背景2、定义3、两种方式(mmap上一篇博客说明)3.2、shmget3.2.1、使用流程和基本原理3.2.2、函数原型(创建共享内存)3.2.3、其他相关AP函数3.2.3.1、shmat ( ):挂接共享内存...
  • mmap内存映射和shmget共享内存

    千次阅读 2019-06-14 12:41:17
    (1)通过int shmget(key_t key, size_t size, int shmflg);在物理内存创建一个共享内存,返回共享内存的编号。 (2)通过void *shmat(int shmid, constvoid shmaddr,int shmflg);连接成功后把共享内存区对象映射到...
  • Linux使用共享内存

    2017-10-24 21:47:43
    int shmget(key_t key, size_t size, int shmflg);  int shmget(key_t key, size_t size, int shmflg); 第一个参数,与信号量的semget函数一样,程序需要提供一个参数key(非0整数),它有效地为...
  • 进程间通信

    2022-02-08 15:07:38
    1.管道 管道用来在两个进程之间传递数据。 1.1有名管道 有名管道可以在任意两个进程之间...int mkfifo(const char *filename, mode_t mode) **示例1:**进程 a 将从键盘获取的数据循环传递给另一个进程 b //a.c 从屏
  • 共享内存API#include #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...
  • 键值构建ftok()函数 ftok()函数将路径名和项目的标识符转变为一个系统V的IPC键值 key_t ftok(const char *pathname, int proj_id) pathname:必须是已经存在的目录 proj_id:8的值,通常用a,b等表示 3.5 获得消息...
  • 进程间通信(IPC)

    2020-10-02 16:16:07
    //获取键值 1 #include <sys/msg.h> 2 // 创建或打开消息队列:成功返回非负队列ID,失败返回-1 3 int msgget(key_t key, int flag); 4 // 添加消息:成功返回0,失败返回-1 5 int msgsnd(int msqid, const void *...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,600
精华内容 1,440
关键字:

shmget key_t 是多少位整数