• 转:Linux--进程间通信(信号量,共享内存)


    源地址:http://www.cnblogs.com/forstudy/archive/2012/03/26/2413724.html

    Linux--进程间通信(信号量,共享内存)(转)

     

    一. 信号量  

    l信号量: 解决进程之间的同步与互斥的IPC机制

    多个进程同时运行,之间存在关联
      •同步关系
      •互斥关系
    互斥与同步关系存在的根源在于临界资源
      •临界资源是在同一个时刻只允许有限个(通常只有一个)进程可以访问(读)或修改(写)的资源
        –硬件资源(处理器、内存、存储器以及其他外围设备等)
        –软件资源(共享代码段,共享结构和变量等)
      •临界区,临界区本身也会成为临界资源
     
     
    一个称为信号量的变量
      •信号量对应于某一种资源,取一个非负的整型值
      •信号量值指的是当前可用的该资源的数量,若它等于0则意味着目前没有可用的资源
    在该信号量下等待资源的进程等待队列
    对信号量进行的两个原子操作(PV操作)
      •P操作
      •V操作
     
    最简单的信号量是只能取0 和1 两种值,叫做二维信号量
     
    编程步骤:
      创建信号量或获得在系统已存在的信号量
        •调用semget()函数
        •不同进程使用同一个信号量键值来获得同一个信号量
      初始化信号量
        •使用semctl()函数的SETVAL操作
        •当使用二维信号量时,通常将信号量初始化为1
      进行信号量的PV操作
        •调用semop()函数
        •实现进程之间的同步和互斥的核心部分
      如果不需要信号量,则从系统中删除它
        •使用semclt()函数的IPC_RMID操作
        •在程序中不应该出现对已被删除的信号量的操作
     

     eg. 通过对信号量PV操作,消除父子进程间的竞争条件,使得其调用顺序可控。
    复制代码
     1 union semun {
    2 int val;
    3 struct semid_ds *buf;
    4 unsigned short *array;
    5 };
    6
    7 // 将信号量sem_id设置为init_value
    8 int init_sem(int sem_id,int init_value) {
    9 union semun sem_union;
    10 sem_union.val=init_value;
    11 if (semctl(sem_id,0,SETVAL,sem_union)==-1) {
    12 perror("Sem init");
    13 exit(1);
    14 }
    15 return 0;
    16 }
    17 // 删除sem_id信号量
    18 int del_sem(int sem_id) {
    19 union semun sem_union;
    20 if (semctl(sem_id,0,IPC_RMID,sem_union)==-1) {
    21 perror("Sem delete");
    22 exit(1);
    23 }
    24 return 0;
    25 }
    26 // 对sem_id执行p操作
    27 int sem_p(int sem_id) {
    28 struct sembuf sem_buf;
    29 sem_buf.sem_num=0;//信号量编号
    30 sem_buf.sem_op=-1;//P操作
    31 sem_buf.sem_flg=SEM_UNDO;//系统退出前未释放信号量,系统自动释放
    32 if (semop(sem_id,&sem_buf,1)==-1) {
    33 perror("Sem P operation");
    34 exit(1);
    35 }
    36 return 0;
    37 }
    38 // 对sem_id执行V操作
    39 int sem_v(int sem_id) {
    40 struct sembuf sem_buf;
    41 sem_buf.sem_num=0;
    42 sem_buf.sem_op=1;//V操作
    43 sem_buf.sem_flg=SEM_UNDO;
    44 if (semop(sem_id,&sem_buf,1)==-1) {
    45 perror("Sem V operation");
    46 exit(1);
    47 }
    48 return 0;
    49 }
    复制代码
    复制代码
     1 #include <stdio.h>
    2 #include <stdlib.h>
    3 #include <string.h>
    4 #include <sys/types.h>
    5 #include <unistd.h>
    6 #include <sys/sem.h>
    7 #include <sys/ipc.h>
    8 #include "sem_com.c"
    9
    10 #define DELAY_TIME 3
    11
    12 int main() {
    13 pid_t pid;
    14 // int sem_id;
    15 // key_t sem_key;
    16
    17 // sem_key=ftok(".",'a');
    18 // 以0666且create mode创建一个信号量,返回给sem_id
    19 // sem_id=semget(sem_key,1,0666|IPC_CREAT);
    20 // 将sem_id设为1
    21 // init_sem(sem_id,1);
    22
    23 if ((pid=fork())<0) {
    24 perror("Fork error! ");
    25 exit(1);
    26 } else if (pid==0) {
    27 // sem_p(sem_id); // P操作
    28 printf("Child running... ");
    29 sleep(DELAY_TIME);
    30 printf("Child %d,returned value:%d. ",getpid(),pid);
    31 // sem_v(sem_id); // V操作
    32 exit(0);
    33 } else {
    34 // sem_p(sem_id); // P操作
    35 printf("Parent running! ");
    36 sleep(DELAY_TIME);
    37 printf("Parent %d,returned value:%d. ",getpid(),pid);
    38 // sem_v(sem_id); // V操作
    39 // waitpid(pid,0,0);
    40 // del_sem(sem_id);
    41 exit(0);
    42 }
    43
    44 }
    复制代码

    在以上程序注释//未去掉时,即没用信号量机制时,其结果为:

    显然,此处存在竞争条件。

    在以上程序注释//去掉后,即使用信号量机制,其结果为:

    由于父子进程采用同一信号量且均执行各自PV操作,故必先等一个进程的V操作后,另一个进程才能工作。

    二. 共享内存

     

    最为高效的进程间通信方式
     
    进程直接读写内存,不需要任何数据的拷贝
      •为了在多个进程间交换信息,内核专门留出了一块内存区
      •由需要访问的进程将其映射到自己私有地址空间
      •进程直接读写这一内存区而不需要进行数据的拷贝,提高了效率
     
    多个进程共享一段内存,需要依靠某种同步机制,如互斥锁和信号量等

    l共享内存编程步骤:
      1. 创建共享内存
        •函数shmget()
        •从内存中获得一段共享内存区域
     
      2. 映射共享内存
        •把这段创建的共享内存映射到具体的进程空间中
        •函数shmat()
     
      3. 使用这段共享内存
        •可以使用不带缓冲的I/O读写命令对其进行操作
     
      4. 撤销映射操作: 函数shmdt()
     
      5. 删除共享内存: 函数shctl()
     

    eg. 下面这个例子完成:父进程从stdin读取字符串并保存到共享内存中,子进程从共享内存中读出数据并输出到stdout

    复制代码
      1 #include <stdio.h>
    2 #include <stdlib.h>
    3 #include <string.h>
    4 #include <sys/types.h>
    5 #include <sys/ipc.h>
    6 #include <sys/shm.h>
    7
    8 #define BUFFER_SIZE 2048
    9
    10 int main() {
    11 pid_t pid;
    12 int shmid;
    13 char *shm_addr;
    14 char flag[]="Parent";
    15 char buff[BUFFER_SIZE];
    16 // 创建当前进程的私有共享内存
    17 if ((shmid=shmget(IPC_PRIVATE,BUFFER_SIZE,0666))<0) {
    18 perror("shmget");
    19 exit(1);
    20 } else
    21 printf("Create shared memory: %d. ",shmid);
    22
    23 // ipcs 命令往标准输出写入一些关于活动进程间通信设施的信息
    24 // -m 表示共享内存
    25 printf("Created shared memory status: ");
    26 system("ipcs -m");
    27
    28 if((pid=fork())<0) {
    29 perror("fork");
    30 exit(1);
    31 }else if (pid==0) {
    32 // 自动分配共享内存映射地址,为可读可写,映射地址返回给shm_addr
    33 if ((shm_addr=shmat(shmid,0,0))==(void*)-1) {
    34 perror("Child:shmat");
    35 exit(1);
    36 }else
    37 printf("Child: Attach shared-memory: %p. ",shm_addr);
    38
    39 printf("Child Attach shared memory status: ");
    40 system("ipcs -m");
    41 // 比较shm_addr,flag的长度为strlen(flag)的字符
    42 // 当其内容相同时,返回0
    43 // 否则返回(str1[n]-str2[n])
    44 while (strncmp(shm_addr,flag,strlen(flag))) {
    45 printf("Child: Waiting for data... ");
    46 sleep(10);
    47 }
    48
    49 strcpy(buff,shm_addr+strlen(flag));
    50 printf("Child: Shared-memory: %s ",buff);
    51 // 删除子进程的共享内存映射地址
    52 if (shmdt(shm_addr)<0) {
    53 perror("Child:shmdt");
    54 exit(1);
    55 }else
    56 printf("Child: Deattach shared-memory. ");
    57
    58 printf("Child Deattach shared memory status: ");
    59 system("ipcs -m");
    60
    61 }else{
    62 sleep(1);
    63 // 自动分配共享内存映射地址,为可读可写,映射地址返回给shm_addr
    64 if ((shm_addr=shmat(shmid,0,0))==(void*)-1) {
    65 perror("Parent:shmat");
    66 exit(1);
    67 }else
    68 printf("Parent: Attach shared-memory: %p. ",shm_addr);
    69
    70 printf("Parent Attach shared memory status: ");
    71 system("ipcs -m");
    72 // shm_addr为flag+stdin
    73 sleep(1);
    74 printf(" Input string: ");
    75 fgets(buff,BUFFER_SIZE-strlen(flag),stdin);
    76 strncpy(shm_addr+strlen(flag),buff,strlen(buff));
    77 strncpy(shm_addr,flag,strlen(flag));
    78 // 删除父进程的共享内存映射地址
    79 if (shmdt(shm_addr)<0) {
    80 perror("Parent:shmdt");
    81 exit(1);
    82 }else
    83 printf("Parent: Deattach shared-memory. ");
    84
    85 printf("Parent Deattach shared memory status: ");
    86 system("ipcs -m");
    87 // 保证父进程在删除共享内存前,子进程能读到共享内存的内容
    88 waitpid(pid,NULL,0);
    89 // 删除共享内存
    90 if (shmctl(shmid,IPC_RMID,NULL)==-1) {
    91 perror("shmct:IPC_RMID");
    92 exit(1);
    93 }else
    94 printf("Delete shared-memory. ");
    95
    96 printf("Child Delete shared memory status: ");
    97 system("ipcs -m");
    98
    99 printf("Finished! ");
    100 }
    101
    102 exit(0);
    103 }
    复制代码

     
  • 相关阅读:
    02 make和目录结构
    05 UCI
    IE6下position:fixed不固定的解决办法
    php内存溢出
    MySQL计划任务(事件调度器)(Event Scheduler)
    PHP面向对象
    php学习笔记——12年2月16日开始不断更新
    Phpnow下配置Xdebug调试
    边学边用
    ASP时间格式化函数
  • 原文地址:https://www.cnblogs.com/xuhj001/p/3372894.html
Copyright © 2020-2023  润新知