linux 进程通信之 共享内存

共享内存是被多个进程共享的一部分物理内存。共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容。

关于共享内存使用的API

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

#在IPC中，我们经常用一个 key_t 的值来创建或者打开 信号量，共享内存和消息队列。这个 key_t 就是由ftok函数产生的。

pathname：指定的文件名，该文件必须是存在而且可以访问

proj_id：1~255之间的整数值。

对于ftok这个函数，个人是觉得没有太大用处，第一，应用程序可能会在不同的主机上使用，（换了一个环境，文件有没有？）。第二点，如果在访问同一共享内存的多个进程先后调用ftok这个时间段中， pathname指定的文件被删除且重新创建，那么，每个进程得到的 key_t 是不一样的，应用程序不会报错，但是数据共享的目的是达不到了。

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

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

key： 这块共享内存的标识符。如果是父子关键的进程间通信，这个标识符用 IPC_PRIVATE 代替。如果两个进程没有任何关系，官方的说法是用ftok产生一个key（鉴于上面关于ftok的介绍，个人比较认同的做法是自己定义一个）使用。

size：这块共享内存的大小。（字节数）

shmflg：是一组标志。

IPC_CREAT：如果共享内存不存在，则创建一个共享内存。

IPC_EXCL：只有在共享内存不存在的时候，新的共享内存才建立，否则就产生错误。

对于这个参数一般是这样操作

#define PERM S_IRUSR | S_IWUSR | IPC_CREAT

然后把 PERM 当作shmflg。

成功返回共享内存的标识符，不成功返回-1，并设置errno。

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

用来建立内存映射（允许本进程与指定共享内存建立联系，读写数据）

shmid：共享内存的ID。(shmget函数的返回值)

shmaddr：指定共享内存连接到当前进程中的地址位置，通常为空，表示让系统选择共享内存的地址。

shmflg：是一组标致。代表本进程对该内存进程的操作模式。如果是SHM_RDONLY的话就是只读模式，其他的是读写模式。这个参数一般设置为0。

成功返回共享内存的起始地址，失败返回-1，并设置errno。

int shmdt(const void *shmaddr);

断开链接的共享内存指针。（并不是从内核正真的删除这个共享内存段）

shmaddr：共享内存的起始地址（shmat函数的返回值）

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

控制共享内存的使用

shmid：共享内存的ID。(shmget函数的返回值)

cmd： 控制命令。可取值如下：

IPC_STAT：得到共享内存的状态

IPC_SET：改变共享内存的状态

IPC_RMID：删除共享内存

buf：是一个结构体指针，当cmd为IPC_STAT的时候，取得的状态放入这个结构体中。如果要改变共享内存的状态，用这个结构体指定。

struct shmid_ds 原型

struct shmid_ds {

struct ipc_perm shm_perm;    /* 操作权限 */

size_t          shm_segsz;   /* 共享内存段的大小（以字节为单位） */

time_t          shm_atime;   /* 最后一个进程附加到该段的时间 */

time_t          shm_dtime;   /* 最后一个进程离开该段的时间 */

time_t          shm_ctime;   /* 最后一个进程修改该段的时间 */

pid_t           shm_cpid;    /* 创建共享内存段进程的pid */

pid_t           shm_lpid;    /* 在该共享内存段上操作的最后一个进程的pid */

shmatt_t        shm_nattch;  /* 当前附件到该共享内存段的进程个数 */

...

};

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

注意！！！！！！！！！：在使用共享内存，结束程序退出后。如果你没在程序中用shmctl()删除共享内存的话，一定要在命令行下用ipcrm命令删除这块共享内存。你要是不管的话，它就一直在那儿放着了。

简单解释一下ipcs命令和ipcrm命令。

应用场景

  • 进程间通讯-生产者消费者模式

生产者进程和消费者进程通信常使用共享内存，比如一个网络服务器，接入进程收到的数据包后，直接写到共享内存中，并唤醒处理进程，处理进程从共享内存中读数据包，进行处理。当然，这里要解决互斥的问题。

示例程序：

#ifndef SHM_COM_H_INCLUDED
#由于fork产生的子进程和父进程不共享内存区，所以父子进程间的通讯也可以使用共享内存。父进程启动后创建内存共享，然后调用fork创建子进程。最后分别在父子进程做内存映射，以达到数据共享。define SHM_COM_H_INCLUDED

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

#define PERM            S_IRUSR | S_IWUSR | IPC_CREAT

#define TEXT_SZ        2048

struct shared_use_st
{
    int written_by_you;
    char some_text[TEXT_SZ];
};

/*
消费者程序

创建共享内存段
然后将它连接到它自己的地址空间中（共享内存映射）
并且，
我们在共享内存的开始处使用了一个结构shared_use_st.
该结构中有个标志written_by_you,
当共享内存中有数据写入时，就设置这个标志。

这个标志被设置时，
程序就从共享内存中读取文本，
将它打印出来，
然后清除这个标志，表示已经读完数据。
我们用一个特殊字符串end来退出循环。

接下来，
程序分离共享内存段并删除它。
*/

#include  "shm_com.h"

int main ( int argc, char** argv )
{
    srand ( ( unsigned int ) getpid() );
    int runing = 1, shmid;
    struct shared_use_st *shared_stuff;

    if ( ( shmid = shmget ( ( key_t ) 8888, sizeof ( struct shared_use_st ), PERM ) ) == -1 )
        {
            fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
            return -1;
        }

    if ( ( shared_stuff = ( struct shared_use_st * ) shmat ( shmid, 0, 0 ) ) == ( struct shared_use_st * ) - 1 )
        {
            fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
            return -1;
        }

    shared_stuff->written_by_you = 0;

    while ( runing )
        {
             while(shared_stuff->written_by_you == 0)
            sleep(1);

            printf ( "You wrote: %s", shared_stuff->some_text );
            sleep ( rand() % 4 );
            shared_stuff->written_by_you = 0;

            if ( strncmp ( shared_stuff->some_text, "end", 3 ) == 0 )
                {
                    runing = 0;
                }
        }

    if ( shmdt ( shared_stuff ) == -1 )
        {
            fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
            return -1;进程间共享-只读模式业务经常碰到一种场景，进程需要加载一份配置文件，可能这个文件有100K大，那如果这台机器上多个进程多要加载这份配置文件，比如有200个进程，那么内存开销合计为20M,但如果文件更多或者进程数更多时，这种对内存的消耗就是一种严重的浪费。比较好的解决方法是，由一个进程负责把配置文件加载到共享内存中，然后所有需要这份配置的进程只要使用这个共享内存即可。
        }

    if ( shmctl ( shmid, IPC_RMID, 0 ) == -1 )
        {
            fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
            return -1;
        }

    return 0;
}

#include "shm_com.h"

/*
生产者程序
使用相同的键值来取得并连接同一个共享内存段，
然后提示用户输入一些文本。
如果标志written_by_you被设置，
生产者就知道消费都进程还未读完上一次的数据，
因此就继续等待。
当其它进程清除了这个标志后，
生产者写入新的数据并设置这个标志。
它还使用字符串end来终止并分离共享内存段。

这里提供的同步标志written_by_you，
它是一个非常缺乏效率的忙等待(不停地循环)。

*/
int main ( int argc, char** argv )
{
    int running = 1, shmid;
    struct shared_use_st *shared_stuff;

    if ( ( shmid = shmget ( ( key_t ) 8888, sizeof ( struct shared_use_st ), PERM ) ) == -1 )
        {
            fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
            return -1;
        }

    if ( ( shared_stuff = ( struct shared_use_st * ) shmat ( shmid, 0, 0 ) ) == ( struct shared_use_st * ) - 1 )
        {
            fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
            return -1;
        }

    while ( running )
        {
            while ( shared_stuff->written_by_you == 1 )
                {
                    sleep ( 1 );
                }

            printf ( "Enter sone text: " );
            memset ( shared_stuff->some_text, 0, sizeof ( shared_stuff->some_text ) );
            fgets ( shared_stuff->some_text, TEXT_SZ, stdin );
            shared_stuff->written_by_you = 1;

            if ( strncmp ( shared_stuff->some_text, "end", 3 ) == 0 )
                {
                    running = 0;
                }
        }

    if ( shmdt ( shared_stuff ) == -1 )
        {
            fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
            return -1;
        }

    return 0;
}
  • 父子进程间通讯

由于fork产生的子进程和父进程不共享内存区，所以父子进程间的通讯也可以使用共享内存。父进程启动后创建内存共享，然后调用fork创建子进程。最后分别在父子进程做内存映射，以达到数据共享。

示例代码：

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

#define PERM    S_IRUSR | S_IWUSR | IPC_CREAT
typedef char * p_str;
int main ( int argc, char **argv )
{
    int shmid;
    pid_t pid;
    p_str p_shmaddr, c_shmaddr;

    if ( ( shmid = shmget ( IPC_PRIVATE, 1024, PERM ) )  == -1 )
        {
            fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
            return -1;
        }

    if ( ( pid = fork() ) == 0 )
        {
            if ( ( c_shmaddr = shmat ( shmid, 0, 0 ) ) == ( p_str ) ( -1 ) )
                {
                    fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
                    return -1;
                }

            memset ( c_shmaddr, '\0', 1024 );
            stpcpy ( c_shmaddr, "Hello" );

            if ( shmdt ( c_shmaddr ) == -1 )
                {
                    fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
                    return -1;
                }

            wait ( NULL );
        }
    else
        if ( pid > 0 )
            {
                sleep ( 2 );

                if ( ( p_shmaddr = shmat ( shmid, 0, 0 ) ) == ( p_str ) ( -1 ) )
                    {
                        fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
                        return -1;
                    }

                printf ( "%s\n", p_shmaddr );

                if ( shmdt ( p_shmaddr ) == -1 )
                    {
                        fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
                        return -1;
                    }

                if ( shmctl ( shmid, IPC_RMID, 0 ) == -1 )
                    {
                        fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
                        return -1;
                    }

                exit ( 0 );
            }
        else
            {
                fprintf ( stderr, "%s %s %d\n", strerror ( errno ), __FILE__, __LINE__ );
                return -1;
            }

    return 0;
}
  • 进程间共享-只读模式

业务经常碰到一种场景，进程需要加载一份配置文件，可能这个文件有100K大，那如果这台机器上多个进程多要加载这份配置文件，比如有200个进程，那么内存开销合计为20M,但如果文件更多或者进程数更多时，这种对内存的消耗就是一种严重的浪费。比较好的解决方法是，由一个进程负责把配置文件加载到共享内存中，然后所有需要这份配置的进程只要使用这个共享内存即可。

代码暂时不想写了。。。有需要的时候再补上吧。。。

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-09 06:22:37

linux 进程通信之 共享内存的相关文章

Linux 进程通信（共享内存区）

共享内存是由内核出于在多个进程间交换信息的目的而留出的一块内存区(段). 如果段的权限设置恰当,每个要访问该段内存的进程都可以把它映像到自己的私有地址空间中. 如果一个进程更新了段中的数据,其他进程也立即会看到更新. 由一个进程创建的段,也可以由另一个进程读写. 每个进程都把它自己对共享内存的映像放入自己的地址空间. 创建共享内存区 int shmget(key_t key,size_t size,int shm-flg); 参数key既可以是IPC_PRIVATE(IPC_PRIVATE表示让

linux进程通信之共享内存

共享内存同意两个或多个进程共享一给定的存储区,由于数据不须要来回复制,所以是最快的一种进程间通信机制.共享内存能够通过mmap()映射普通文件(特殊情况下还能够採用匿名映射)机制实现,也能够通过系统V共享内存机制实现.应用接口和原理非常easy,内部机制复杂.为了实现更安全通信,往往还与信号量等同步机制共同使用.以下主要介绍系统V共享内存机制,主要用到的系统API包含: 1.shmget函数:获得一个共享内存标识符. int shmget(key_t key, size_t size, int 

进程通信之共享内存

共享内存 共享内存就是允许两个不相关的进程访问同一个逻辑内存.共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式.不同进程之间共享的内存通常安排为同一段物理内存.进程可以将同一段共享内存连接到它们自己的地址空间中,所有进程都可以访问共享内存中的地址,就好像它们是由用C语言函数malloc分配的内存一样.而如果某个进程向共享内存写入数据,所做的改动将立即影响到可以访问同一段共享内存的任何其他进程. 共享内存并未提供同步机制,也就是说,在第一个进程结束对共享内存的写操作之前,并无自

进程通信之共享内存篇

共享内存原理示意图 shmget函数语法: shmat函数语法 shmdt函数语法 代码分析: /* shmem.c */ #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define BUFFER_SIZE 2048 int main

linux 进程学习笔记-共享内存

如果能划定一块物理内存,让多个进程都能将该内存映射到其自身虚拟内存空间的话,那么进程可以通过向这块内存空间读写数据而达到通信的目的.另外,和消息队列不同的是,共享的内存在用户空间而不是核空间,那么就不存在“用户空间和内核空间之间数据复制”的问题,这会减少不少开销. 由于不同进程都可能向同一个空间读写数据,所以其需要一些同步机制来防止混乱,可以使用的机制有“信号量”“文件锁”等. 共享内存有mmap和System V Shared Memory, 下面说的是后者. 创建或打开共享内存: int s

进程通信（共享内存）

共享内存: 用于进程间数据传输,是最高效的,并不提供同步,互斥  shm.h:   1 #include<stdio.h>   2 #include<stdlib.h>   3 #include<sys/ipc.h>   4 #include<sys/shm.h>   5 #include<string.h>   6 #include<sys/wait.h>   7 #include <unistd.h>   8    9

撸代码--linux进程通信（基于共享内存）

1.实现亲缘关系进程的通信,父写子读 思路分析:1)首先我们须要创建一个共享内存. 2)父子进程的创建要用到fork函数.fork函数创建后,两个进程分别独立的执行. 3)父进程完毕写的内容.同一时候要保证子进程退出后,在删除共享内存. 4)子进程完毕读的内容. 效果展示:                 代码展示:           #include <string.h> #include <unistd.h> #include <sys/types.h> #inc

linux进程间的通信(C): 共享内存

一.共享内存介绍 共享内存是三个IPC(Inter-Process Communication)机制中的一个. 它允许两个不相关的进程访问同一个逻辑内存. 共享内存是在两个正在进行的进程之间传递数据的一种非常有效的方式. 大多数的共享内存的实现, 都把由不同进程之间共享的内存安排为同一段物理内存. 共享内存是由IPC为进程创建一个特殊的地址范围, 它将出现在该进程的地址空间中. 其他进程可以将同一段共享内存连接它们自己的地址空间中. 所有进程都可以访问共享内存中的地址, 就好像它们是由mallo

linux进程间的通信之 共享内存

一.共享内存介绍 共享内存是三个IPC(Inter-Process Communication)机制中的一个. 它允许两个不相关的进程访问同一个逻辑内存. 共享内存是在两个正在进行的进程之间传递数据的一种非常有效的方式. 大多数的共享内存的实现, 都把由不同进程之间共享的内存安排为同一段物理内存. 共享内存是由IPC为进程创建一个特殊的地址范围, 它将出现在该进程的地址空间中. 其他进程可以将同一段共享内存连接它们自己的地址空间中. 所有进程都可以访问共享内存中的地址, 就好像它们是由mallo