共享内存学习

作为最快的IPC方式，共享内存当然得好好学一下咯。

 

System V进程间通信方式：信号量、消息队列、共享内存。他们都是由AT&T System V2版本的UNIX引进的，所以统称为System V IPC.

除了下面讲的System V IPC，还有mmap也可以将文件进行内存映射，从而实现共享内存的效果。对比可以参考 Link

 

参考 http://blog.csdn.net/ljianhui/article/details/10253345

 

它们声明在头文件 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函数

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

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

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

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

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

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

 

3、shmdt函数

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

int shmdt(const void *shmaddr);  

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

 

4、shmctl函数

与信号量的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结构至少包括以下成员：

struct shmid_ds  
{  
    uid_t shm_perm.uid;  
    uid_t shm_perm.gid;  
    mode_t shm_perm.mode;  
};  

 

三、使用共享内存进行进程间通信

文件shmread.c创建共享内存，并读取其中的信息，另一个文件shmwrite.c向共享内存中写入数据。为了方便操作和数据结构的统一，为这两个文件定义了相同的数据结构，定义在文件shmdata.c中。结构shared_use_st中的written作为一个可读或可写的标志，非0：表示可读，0表示可写，text则是内存中的文件。

shmdata.h

#ifndef _SHMDATA_H_HEADER
#define _SHMDATA_H_HEADER

#define TEXT_SZ 2048

struct shared_use_st {
        int written;
        char text[TEXT_SZ];
};

#endif

 

shmread.c

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

int main() {
        int running = 1;
        void *shm = NULL;
        struct shared_use_st *shared;
        int shmid;

        shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);
        if (shmid == -1) {
                fprintf(stderr, "shmget failed\n");
                exit(EXIT_FAILURE);
        }

        shm = shmat(shmid, 0, 0);
        if (shm == (void*)-1) {
                fprintf(stderr, "shmat failed\n");
                exit(EXIT_FAILURE);
        }

        printf("Memory attached at %X\n", (int)shm);

        shared = (struct shared_use_st*)shm;
        shared->written = 0;
        while (running) {
                if (shared->written != 0) {
                        printf("You wrote: %s\n", shared->text);
                        sleep(rand() % 5 + 1);

                        if (strncmp(shared->text, "end", 3) == 0) {
                                running = 0;
                        }
                        shared->written = 0;
                }
                else {
                        sleep(rand() % 5 + 1);
                }
        }

        if (shmdt(shm) == -1) {
                fprintf(stderr, "shmdt failed\n");
                exit(EXIT_FAILURE);
        }

        if (shmctl(shmid, IPC_RMID, 0) == -1) {
                fprintf(stderr, "shmctl(IPC_RMID) failed\n");
                exit(EXIT_FAILURE);
        }

        exit(EXIT_SUCCESS);

}

 

shmwrite.c

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

int main() {
        int running  = 1;
        void *shm = NULL;
        struct shared_use_st *shared = NULL;
        char buffer[BUFSIZ + 1];
        int shmid;

        shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);
        if (shmid == -1) {
                fprintf(stderr, "shmget failed\n");
                exit(EXIT_FAILURE);
        }

        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);

        shared = (struct shared_use_st*)shm;
        while (running) {
                while (shared->written == 1) {
                        sleep(1);
                        printf("waiting...\n");
                }
                printf("Enter some text:");
                fgets(buffer, BUFSIZ, stdin);
                strncpy(shared->text, buffer, TEXT_SZ);

                shared->written = 1;
                if (strncmp(buffer, "end", 3) == 0) {
                        running = 0;
                }
        }

        if (shmdt(shm) == -1) {
                fprintf(stderr, "shmdt failed\n");
                exit(EXIT_FAILURE);
        }
        sleep(2);
        exit(EXIT_SUCCESS);

}

 

编译命令：

gcc -o shmwrite shmwrite.c -lm
gcc -o shmread  shmread.c  -lm
# actually no -lm also works

 

运行效果：

$ ./shmread &
$ Memory attached at B76A8000

$ ./shmwrite 
Memory attached at 5f886000
Enter some text:a
waiting...
You wrote: a

waiting...
waiting...
Enter some text:b
waiting...
waiting...
You wrote: b

waiting...
waiting...
Enter some text:end
You wrote: end

$ 
[1]+  Done                    ./shmread

 

分析：

1、程序shmread创建共享内存，然后将它连接到自己的地址空间。在共享内存的开始处使用了一个结构struct_use_st。该结构中有个标志written，当共享内存中有其他进程向它写入数据时，共享内存中的written被设置为0，程序等待。当它不为0时，表示没有进程对共享内存写入数据，程序就从共享内存中读取数据并输出，然后重置设置共享内存中的written为0，即让其可被shmwrite进程写入数据。

2、程序shmwrite取得共享内存并连接到自己的地址空间中。检查共享内存中的written，是否为0，若不是，表示共享内存中的数据还没有被完，则等待其他进程读取完成，并提示用户等待。若共享内存的written为0，表示没有其他进程对共享内存进行读取，则提示用户输入文本，并再次设置共享内存中的written为1，表示写完成，其他进程可对共享内存进行读操作。

 

四、关于前面的例子的安全性讨论

这个程序是不安全的。

 

要想让程序安全地执行，就要有一种进程同步的进制，保证在进入临界区的操作是原子操作。例如，可以使用前面所讲的信号量来进行进程的同步。因为信号量的操作都是原子性的。 

 

五、使用共享内存的优缺点

1、优点：我们可以看到使用共享内存进行进程间的通信真的是非常方便，而且函数的接口也简单，数据的共享还使进程间的数据不用传送，而是直接访问内存，也加快了程序的效率。同时，它也不像匿名管道那样要求通信的进程有一定的父子关系。

 

2、缺点：共享内存没有提供同步的机制，这使得我们在使用共享内存进行进程间通信时，往往要借助其他的手段来进行进程间的同步工作。

 

实现 

大多数的共享内存的实现，

都把由不同进程之间共享的内存安排为同一段物理内存。

 

它并未提供同步机制，

我们通常是用共享内存来提供对大块内存区域的有效访问，

同时通过传递小消息来同步对该内存的访问。

 

实际编程中，

应该使用信号量，

或通过传递消息(使用管道或IPC消息)，

或生成信号

的方法来提供读写之间的更有效的同步机制。