Chinaunix首页 | 论坛 | 博客

lcldali的ChinaUnix博客

首页　| 　博文目录　| 　关于我

lcldali

  • 博客访问： 69201
  • 博文数量： 49
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 10
  • 用 户 组： 普通用户
  • 注册时间： 2016-09-10 14:44
文章分类

全部博文（49）

文章存档

2017年（1）

2016年（48）

我的朋友
最近访客
推荐博文
相关博文
进程间同步---system v ipc 对象信号灯集

分类： LINUX

2016-09-17 22:55:29

原文地址：进程间同步---system v ipc 对象信号灯集 作者：草根老师

一、信号灯简介

Linux支持System V的信号灯(semaphore)，是一种进程间通信的方式，只不过它和管道、FIFO或者共享内存不一样，信号灯主要用于同步或者互斥对共享资源的访问，它的发明来源于火车运行系统中的"信号灯",利用信号灯可以实现"PV"操作这种进程间同步进制。P操作时获得资源，将信号灯的值减1，如果结果不为负则执行完毕，进程获得资源，否则进程睡眠以等待的进程释放;V操作则是释放资源，给信号灯的值加1， 唤醒一个因执行P操作而等待的进程。

二、信号灯的两种类型

A、二值信号灯

最简单的信号灯形式，信号灯的值只能取0或1,类似互斥锁。

注意：虽然二值信号灯能够实现互斥锁的功能，但两者的关注内容不同。信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。

B.计数信号灯

信号灯的值可以取任意非负值(当然受内核本省的约束)，用来统计资源，其值就代表可用资源的个数。

注意：通常所说的系统V信号灯指的是计数信号灯集

三、相关API

A.创建一个信号灯集



功能：创建一个信号灯集并返回这个信号灯集的ID 或直接返回一个已经存在的信号灯集的ID

参数说明:

key:如果key值为IPC_PRIVATE或key为0并且semflg设置了IPC_CREAT，此时调用此函数总是创建一个新的信号灯集(我们在共享内存的时候验证过，还记的吗？其实system v 的ipc对象的创建机制都很类似。

nsems：指定这个信号灯集中信号灯的个数(每个信号灯代表了某一类资源)。

semflg:可以指定为IPC_CREAT | 0666,其含义为,不存在则创建，访问权限为0666。我们也可以通过IPC _CREAT | IPC_EXCL一起使用的时候确定要创建的信号灯集是否存在，如果存在此时这个函数放回-1 。



B.控制信号灯集



参数说明:

semid : 信号灯集ID

semnum:要修改的信号灯编号(创建信号灯集时，信号灯的编号从0开始)

cmd:

IPC_STAT  获取信号灯信息，信息由arg.buf(即第四个参数)返回
GETVAL  : 获取semnum信号灯的值
SETVAL  : 设置semnum信号灯的值
IPC_RMID : 从系统中删除semnum所代表的信号灯  

注意：semctl是可变参数，cmd为GETVAL或SETVAL时，需要传递第四个参数，其参数类型为 union semun。这个结构体的类型必须在应用程序中定义，定义如下:



<1>设置信号灯集中第一个信号灯的数值为1(即某一类资源的个数)

a.必须在应用程序中定义如下类型

union semun{
  int   val;
  struct  semid_ds  *buf;
  unsigned  short  *array;
  struct  seminfo  *  __buf;
};

b.定义一个union semun变量,并赋值

union semun mysemun;
mysemun.val = 1;

c.调用semctl函数

//第一个信号灯的编号为0
if ( ( semctl (  semid  ,  0  ,  SETVAL,mysemun)) < 0)
{
    perror("Fail to semctl");
    exit(EXIT_FAILURE);
}

<2>删除一个信号灯

if(  semctl  (  semid  ,  0  ,  IPC_RMID  ,  0 ) < 0 )
{
    perror("Fail to semctl  IPC_RMID");
    exit(EXIT_FAILURE);
}



C.操作信号灯



功能：semop系统调用可以实现对由semid标志的信号等集中的某一个指定信号灯的一系列操作

参数说明:

semid信号灯集的标识ID。

sops :指向结构体sembuf的指针，设置信号灯集中某一个信号灯的工作方式。



<1>sem_num对应信号灯集中的信号灯，0代表第一个信号灯

<2>sem_op值决定了对sem_num的三种不同操作:

a.sem_op = 0,调用者阻塞等待，直到信号灯的值等于0时返回。可以用来测试共享资源是否已用完。

b.sem_op = 1,释放资源，V操作

c.sem_op = -1,分配资源，P操作

<3>sem_flg可取0,IPC_NOWAIT以及SEM_UNDO三个标志

a.   0  代表阻塞调用(资源不满足阻塞)
b.   IPC_NOWAIT  代表非阻塞调用
c.   如果设置了SEM_UNDO标志，那么在进程结束时，相应的操作将被取消，这是一个比较重要的一个标志。

案例：封装一个P操作和一个V操作

//p操作
int my_sem_wait(int semid,int sem_num)
{
    struct sembuf  op;
     
    op.sem_num = sem_num;
    op.sem_op = -1;
    op.sem_flg = 0;
    
    if(semop(sem_id,&op,1) < 0)
    {
perror("fail to semop");
exit(-1);
    }

    return 0;
}

//V操作
int my_sem_wait(int semid,int sem_num)
{
    struct sembuf  op;
     
    op.sem_num = sem_num;
    op.sem_op = 1;
    op.sem_flg = 0;
    
    if(semop(sem_id,&op,1) < 0)
    {
perror("fail to semop");
exit(-1);
    }

    return 0;
}

案例探究(用信号灯集实现共享内存间的同步):

A .读共享内存

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <errno.h>
  5. #include <unistd.h>
  6. #include <sys/ipc.h>
  7. #include <sys/shm.h>
  8. #include <sys/types.h>
  9. #include <sys/sem.h>

  11. #define READ 0
  12. #define WRITE 1

  14. #define N 2

  16. union semun{
  17.     int val;
  18.     struct semid_ds *buf;
  19.     unsigned short *array;
  20.     struct seminfo *__buf;
  21. };

  23. //初始化信号灯集中的信号灯的值
  24. int my_sem_init(int semid)
  25. {
  26.     int i = 0;
  27.     union semun mysemun;

  29.     for(i = 0;i < N;i ++)
  30.     {
  31.         mysemun.val = i;
  32.         if(semctl(semid,i,SETVAL,mysemun) < 0)
  33.         {
  34.             perror("Fail to semctl");
  35.             return -1;
  36.         }
  37.     }

  39.     return 0;
  40. }

  42. //信号灯集中的信号灯释放资源
  43. int my_sem_post(int semid,int sem_num)
  44. {
  45.     struct sembuf op;

  47.     op.sem_num = sem_num;
  48.     op.sem_op = 1;
  49.     op.sem_flg = 0;

  51.     if(semop(semid,&op,1) < 0)
  52.     {
  53.         perror("Fail to semop");
  54.         return -1;
  55.     }

  57.     return 0;
  58. }

  60. //信号灯集中的信号灯申请资源
  61. int my_sem_wait(int semid,int sem_num)
  62. {
  63.     struct sembuf op;

  65.     op.sem_num = sem_num;
  66.     op.sem_op = -1;
  67.     op.sem_flg = 0;

  69.     if(semop(semid,&op,1) < 0)
  70.     {
  71.         perror("Fail to semop");
  72.         return -1;
  73.     }

  75.     return 0;
  76. }

  78. //读共享内存
  79. int read_share_memory(int semid,char *addr)
  80. {
  81.     int n;

  83.     while(1)
  84.     {
  85.         my_sem_wait(semid,READ);
  86.         
  87.         printf("Read : %s.\n",addr);

  89.         my_sem_post(semid,WRITE);

  91.         if(strncmp(addr,"quit",4) == 0)
  92.         {
  93.             if(shmdt((void *)addr) < 0)
  94.             {
  95.                 perror("Fail to semdt");
  96.                 return -1;
  97.             }
  98.             
  99.             break;
  100.         }

  102.     }
  103.     
  104.     return 0;
  105. }

  107. int main(int argc,char *argv[])
  108. {
  109.     key_t key;
  110.     void *shmaddr;
  111.     int shmid,semid;
  112.     
  113.     if(argc < 2)
  114.     {
  115.         fprintf(stderr,"usage : %s argv[1].\n",argv[0]);
  116.         exit(EXIT_FAILURE);
  117.     }
  118.     
  119.     //获取键值
  120.     if((key = ftok(argv[1],'a')) < 0)
  121.     {
  122.         perror("Fail to ftok");
  123.         exit(EXIT_FAILURE);
  124.     }
  125.     
  126.     //创建共享内存
  127.     if((shmid = shmget(key,1024,IPC_CREAT | 0666)) < 0)
  128.     {
  129.         perror("Fail to shmget");
  130.         exit(EXIT_FAILURE);
  131.     }

  133.     //映射共享内存到进程地址空间
  134.     if((shmaddr = shmat(shmid,NULL,0)) == (void *)-1)
  135.     {
  136.         perror("Fail to shmat");
  137.         exit(EXIT_FAILURE);
  138.     }
  139.     
  140.     //创建含有2个的信号灯的信号灯集
  141.     if((semid = semget(key,N,IPC_CREAT | 0666)) < 0)
  142.     {
  143.         perror("Fail to shmget");
  144.         exit(EXIT_FAILURE);
  145.     }

  147.     //初始化信号灯集中的信号灯
  148.     my_sem_init(semid);
  149.     
  150.     read_share_memory(semid,(char *)shmaddr);

  152.     exit(EXIT_SUCCESS);
  153. }
写共享内存

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <errno.h>
  5. #include <unistd.h>
  6. #include <sys/ipc.h>
  7. #include <sys/shm.h>
  8. #include <sys/types.h>
  9. #include <sys/sem.h>

  11. #define READ 0
  12. #define WRITE 1

  14. #define N 2

  16. union semun{
  17.     int val;
  18.     struct semid_ds *buf;
  19.     unsigned short *array;
  20.     struct seminfo *__buf;
  21. }mysemun;

  23. //初始化信号灯集中的信号灯的值
  24. int my_sem_init(int semid)
  25. {
  26.     int i = 0;

  28.     for(i = 0;i < N;i ++)
  29.     {
  30.         mysemun.val = i;
  31.         if(semctl(semid,i,SETVAL,mysemun) < 0)
  32.         {
  33.             perror("Fail to semctl");
  34.             return -1;
  35.         }
  36.     }

  38.     return 0;
  39. }

  41. //信号灯集中的信号灯释放资源
  42. int my_sem_post(int semid,int sem_num)
  43. {
  44.     struct sembuf op;

  46.     op.sem_num = sem_num;
  47.     op.sem_op = 1;
  48.     op.sem_flg = 0;

  50.     if(semop(semid,&op,1) < 0)
  51.     {
  52.         perror("Fail to semop");
  53.         return -1;
  54.     }

  56.     return 0;
  57. }

  59. //信号灯集中的信号灯申请资源
  60. int my_sem_wait(int semid,int sem_num)
  61. {
  62.     struct sembuf op;

  64.     op.sem_num = sem_num;
  65.     op.sem_op = -1;
  66.     op.sem_flg = 0;

  68.     if(semop(semid,&op,1) < 0)
  69.     {
  70.         perror("Fail to semop");
  71.         return -1;
  72.     }

  74.     return 0;
  75. }

  77. //读共享内存
  78. int read_share_memory(int semid,char *addr)
  79. {
  80.     int n;

  82.     while(1)
  83.     {
  84.         my_sem_wait(semid,WRITE);

  86.         printf(">");
  87.         fgets(addr,1024,stdin);
  88.         addr[strlen(addr)-1] = '\0';

  90.         my_sem_post(semid,READ);

  92.         if(strncmp(addr,"quit",4) == 0)
  93.         {
  94.             if(shmdt((void *)addr) < 0)
  95.             {
  96.                 perror("Fail to semdt");
  97.                 return -1;
  98.             }
  99.             
  100.             break;
  101.         }

  103.     }
  104.     
  105.     return 0;
  106. }

  108. int main(int argc,char *argv[])
  109. {
  110.     key_t key;
  111.     void *shmaddr;
  112.     int shmid,semid;
  113.     
  114.     if(argc < 2)
  115.     {
  116.         fprintf(stderr,"usage : %s argv[1].\n",argv[0]);
  117.         exit(EXIT_FAILURE);
  118.     }
  119.     
  120.     //获取键值
  121.     if((key = ftok(argv[1],'a')) < 0)
  122.     {
  123.         perror("Fail to ftok");
  124.         exit(EXIT_FAILURE);
  125.     }
  126.     
  127.     //创建共享内存
  128.     if((shmid = shmget(key,1024,IPC_CREAT | 0666)) < 0)
  129.     {
  130.         perror("Fail to shmget");
  131.         exit(EXIT_FAILURE);
  132.     }

  134.     //映射共享内存到进程地址空间
  135.     if((shmaddr = shmat(shmid,NULL,0)) == (void *)-1)
  136.     {
  137.         perror("Fail to shmat");
  138.         exit(EXIT_FAILURE);
  139.     }
  140.     
  141.     //创建含有2个的信号灯的信号灯集
  142.     if((semid = semget(key,N,IPC_CREAT | 0666)) < 0)
  143.     {
  144.         perror("Fail to shmget");
  145.         exit(EXIT_FAILURE);
  146.     }

  148.     //初始化信号灯集中的信号灯
  149.     my_sem_init(semid);
  150.     
  151.     read_share_memory(semid,(char *)shmaddr);

  153.     if(shmctl(shmid,IPC_RMID,NULL) < 0)
  154.     {
  155.         perror("Fail to shmctl");
  156.         return -1;
  157.     }

  159.     if(semctl(semid,0,IPC_RMID,0) < 0)
  160.     {
  161.         perror("Fail to semctl WRITE");
  162.         return -1;
  163.     }

  165.     exit(EXIT_SUCCESS);
  166. }
阅读(1574) | 评论(0) | 转发(0) |
0

上一篇：进程间通信---共享内存

下一篇：Linux应用编程一些简单常用函数

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6