Linux进程——共享内存

mytomorrow

共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。共享内存往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
# f$ O8 q2 j7 w; p首先要用的函数是shmget，它获得一个共享存储标识符。

3 f+ D1 H& T+ `3 w' w＃i nclude <sys/types.h>
* |0 c! _5 t% b        ＃i nclude <sys/ipc.h>
+ d6 Q. c# b) U/ Z        ＃i nclude <sys/shm.h>
        int shmget(key_t key, int size, int flag);

这个函数有点类似大家熟悉的malloc函数，系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面第一个函数的key。数据类型key_t是在头文件sys/types.h中定义的，它是一个长整形的数据。在我们后面的章节中，还会碰到这个关键字。
# R1 ]$ P7 L( C6 k: e$ S3 S
. k5 b- T2 F8 K当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。
' N9 _1 G6 T- g- I' t' _5 R/ n
6 [9 a1 G: L1 o1 m  D6 W6 Jvoid *shmat(int shmid, void *addr, int flag);

shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。

使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。

共享内存机制使得两个不相关进程可以读取和修改同一段内存从而实现数据共享。主要函数定义:

1 j* V3 u: k& W1 F  F6 y1 ?; e#include <sys/shm.h>

9 x; h' @# B2 K1 ^% R# l. R6 ~void *shmat(int shm_id, const void *shm_addr, int shmflg);

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

6 o; L& n/ e* @# G+ w0 T# x( Fint shmdt(const void *shm_addr);

int shmget(key_t key, size_t size, int shmflag);
) ]$ l9 c7 `( T7 E- f8 o9 Y
) Q2 I$ ^% b, I( Y3 Q7 P9 W" S: `C代码

- Q$ z! r  o& {! ^/*server.c:向共享内存中写入People*/
#include <stdio.h>
" ?; @* x  q9 _4 x#include <sys/types.h>
/ a! E/ `7 B) p$ W1 y#include <sys/ipc.h>
#include <sys/sem.h>
8 P/ O4 l' Z: Yint main()  
5 K  k6 V* Z4 M* w( B{  
+ V$ E% c& g0 m$ N8 |' J$ ustruct People{  
char name[10];  
int age;  
    };  
int semid;  
. U- P! f: ]+ j4 K2 E& K( X9 Cint shmid;  
    key_t semkey;  
% Z6 \( H3 V( w* j+ ^3 H( F- t    key_t shmkey;  
' x  L* t! U( [! ~9 V1 q    semkey=ftok("server.c",0);  
6 I# g7 y. A) x$ e    shmkey=ftok("client.c",0);  
/*创建共享内存和信号量的IPC*/
    semid=semget(semkey,1,0666|IPC_CREAT);  
$ A% |! t# A4 Iif(semid==-1)  
    printf("creat sem is fail\n");  
- Z* L% J& x- `% @3 v7 z) \    shmid=shmget(shmkey,1024,0666|IPC_CREAT);  
' {/ y/ O) U. e* H3 fif(shmid==-1)  
    printf("creat shm is fail\n");  
) m+ h" n# K- G" o" `/*设置信号量的初始值，就是资源个数*/
2 V% W, k$ x* X) k: t  cunion semun{  
int val;  
struct semid_ds *buf;  
        ushort *array;  
    }sem_u;  
    sem_u.val=1;  
' L% c3 o, P# r    sEMCtl(semid,0,SETVAL,sem_u);  
  ~1 {& Q7 c  [/*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/
# k+ I$ O$ l5 {. g6 V8 kstruct People * addr;  
7 _$ F. j; e! r- P. D0 L0 x    addr=(struct People*)shmat(shmid,0,0);  
, j' X! P1 P% Vif(addr==(struct People*)-1)  
    printf("shm shmat is fail\n");  
/*信号量的P操作*/
void p()  
    {  
0 q; ?$ L, _3 w7 Bstruct sembuf sem_p;  
        sem_p.sem_num=0;  
        sem_p.sem_op=-1;  
if(semop(semid,&sem_p,1)==-1)  
        printf("p operation is fail\n");         
% g. ^8 R, \9 a8 @( y    }  
/*信号量的V操作*/
void v()  
    {  
, m; [( K6 z* j8 g4 _, \struct sembuf sem_v;  
        sem_v.sem_num=0;  
6 C$ k/ G/ d3 z& g2 y- I+ c        sem_v.sem_op=1;  
if(semop(semid,&sem_v,1)==-1)  
9 E6 `+ c) U1 I# g% b' {& `1 Y        printf("v operation is fail\n");  
    }  
/*向共享内存写入数据*/
/ w7 Z( k: @0 H1 U4 h  s2 S    p();  
    strcpy((*addr).name,"xiaoming");  
/*注意：①此处只能给指针指向的地址直接赋值，不能在定义一个  struct People people_1;addr=&people_1;因为addr在addr=(struct People*)shmat(shmid,0,0);时,已经由系统自动分配了一个地址，这个地址与共享内存相关联，所以不能改变这个指针的指向，否则他将不指向共享内存，无法完成通信了。
注意：②给字符数组赋值的方法。刚才太虎了。。*/
. S: t  W, O' J' C; B    (*addr).age=10;  
" q) v5 w8 G9 |; ~    v();  
/*将共享内存与当前进程断开*/
1 q' D8 B% u- n0 x- o, l, r) \& l; dif(shmdt(addr)==-1)  
. s* g4 W9 D+ U9 \0 h. A) A    printf("shmdt is fail\n");   
4 d7 _6 ~- t9 C* \; A# [! Q: c}
C代码
3 h( v, s0 t8 V( g. m( B
' v* {$ }$ J: P+ T) r% F2 A/*client.c:从共享内存中读出People*/
#include <stdio.h>
: D9 k, s- ~& t; I& G#include <sys/types.h>
& c$ Q, H6 G  w" {) r#include <sys/ipc.h>
: ^9 c4 I' W2 l4 a, H#include <sys/sem.h>
int main()  
! P) s6 y; ~! M; r" f4 X{  
9 b7 l9 B6 Z5 f  ~5 |0 Qint semid;  
. }( Y* |9 B8 I$ E  `int shmid;  
4 ^1 \/ g4 N! u/ S    key_t semkey;  
( d; B6 N* A3 s' b) x# D" Q    key_t shmkey;  
    semkey=ftok("server.c",0);  
3 n* b) P1 K9 [4 l    shmkey=ftok("client.c",0);  
struct People{  
char name[10];  
int age;  
    };  
( _1 I* o' N- O/ v( v) u7 L$ v/*读取共享内存和信号量的IPC*/
2 s/ H7 ]0 z5 Z/ J' j4 {    semid=semget(semkey,0,0666);  
+ _+ f1 \9 Z1 h6 q2 C& V7 bif(semid==-1)  
" ]1 f5 f. o5 [) J    printf("creat sem is fail\n");  
    shmid=shmget(shmkey,0,0666);  
9 \# B' P+ c; h# Q  q" c8 kif(shmid==-1)  
    printf("creat shm is fail\n");  
5 L$ D4 p' M) U. g1 F9 p/*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/
struct People * addr;  
8 ^! S* ^$ V9 H% J0 b, J- z    addr=(struct People*)shmat(shmid,0,0);  
9 K# ^% w  m& s. C& f# E+ Oif(addr==(struct People*)-1)  
    printf("shm shmat is fail\n");  
/*信号量的P操作*/
void p()  
    {  
0 y2 F( B* U+ F9 o8 ?. Nstruct sembuf sem_p;  
        sem_p.sem_num=0;  
        sem_p.sem_op=-1;  
; {+ @8 Z/ F8 K( z; zif(semop(semid,&sem_p,1)==-1)  
        printf("p operation is fail\n");         
    }  
6 E( X  A) v5 n2 S5 z/*信号量的V操作*/
, D; j" }" M2 O- `" ~& a: i$ Gvoid v()  
6 b+ E  [$ W6 [0 j, S    {  
struct sembuf sem_v;  
6 v& ]2 P! n$ J        sem_v.sem_num=0;  
        sem_v.sem_op=1;  
if(semop(semid,&sem_v,1)==-1)  
        printf("v operation is fail\n");  
( ?) \* N5 ^& h. ?1 A! [) }) k3 y) G' L/ `    }  
/*从共享内存读出数据*/
    p();  
    printf("name:%s\n",addr->name);  
( e) U; z- B$ ?6 O# z2 z% i    printf("age:%d\n",addr->age);  
    v();  
/*将共享内存与当前进程断开*/
if(shmdt(addr)==-1)  
+ h& r* S4 `; }" g    printf("shmdt is fail\n");  
/*IPC必须显示删除。否则会一直留存在系统中*/
, R2 Z$ s# L) Yif(semctl(semid,0,IPC_RMID,0)==-1)  
    printf("semctl delete error\n");  
if(shmctl(shmid,IPC_RMID,NULL)==-1)  
' A# v# |/ P, }    printf("shmctl delete error\n");  
; k. m9 H! ]* G) K# \}

yin123

Linux进程——共享内存