• 博客访问: 984467
  • 博文数量: 167
  • 博客积分: 2234
  • 博客等级: 大尉
  • 技术积分: 3214
  • 用 户 组: 普通用户
  • 注册时间: 2012-05-17 21:34
个人简介

未来很长。

文章存档

2017年(7)

2016年(4)

2015年(1)

2014年(6)

2013年(37)

2012年(112)

微信关注

IT168企业级官微



微信号:IT168qiye



系统架构师大会



微信号:SACC2013

订阅
热词专题
信号量 2013-05-03 09:41:29

分类: C/C++

原文地址:信号量 作者:graylocus

1.信号量的概念

   信号量的本质是一种数据操作锁,它本身不具有数据交换的功能,而是通过控制其他的通信资源(文件,外部设备)来实现进程间通信,它本身只是一种外部资源的标识。信号量在此过程中负责数据操作的互斥、同步等功能。

   当请求一个使用信号量来表示的资源时,进程需要先读取信号量的值来判断资源是否可用。大于0,资源可以请求,等于0,无资源可用,进程会进入睡眠状态直至资源可用。

  当进程不再使用一个信号量控制的共享资源时,信号量的值+1,对信号量的值进行的增减操作均为原子操作,这是由于信号量主要的作用是维护资源的互斥多进程的同步访问。而在信号量的创建及初始化上,不能保证操作均为原子性。

  内核为每个信号量集都设置一个shmid_ds结构,同时用一个无名结构来标识一个信号量。

  表示一个信号量的结构:

  struct{ unsigned short semval;

          pid_t          sempid;

          unsigned short semncent;

        .....

        };

2.信号量的创建

    使用函数semget创建或者获得一个信号量集ID(不是创建一个信号量,该信号量集可以包含多个信号量)

   #include <sys/sem.h>

   int semget(key_t key,int nsems, int flag);

   参数key用来变换成一个标识符,每一个IPC对象与一个key相对应。函数使用flag的相应权限位对ipc_perm结构中的mode域赋值。

   nsems是一个大于等于0的值,用于指明该信号量集中可用资源数(在第一次创建一个信号量时需要指定)。当打开一个已存在的信号量集时,该参数值为0。函数执行成功,返回信号量集的标识符,失败,返回-1.

   返回值:如果成功,则返回信号量集的IPC标识符。如果失败,则返回-1:errno=EACCESS(没有权限)

   EEXIST(信号量集已经存在,无法创建)

   EIDRM(信号量集已经删除)

   ENOENT(信号量集不存在,同时没有使用IPC_CREAT)

   ENOMEM(没有足够的内存创建新的信号量集)

   ENOSPC(超出限制)

    系统调用semget()的第一个参数是关键字值(一般是由系统调用ftok()返回的)。系统内核将此值和系统中存在的其他的信号量集的关键字值进行比较。打开和存取操作与参数semflg中的内容相关。IPC_CREAT如果信号量集在系统内核中不存在,则创建信号量集。IPC_EXCL当和 IPC_CREAT一同使用时,如果信号量集已经存在,则调用失败。

    如果单独使用IPC_CREAT,则semget()要么返回新创建的信号量集的标识符,要么返回系统中已经存在的同样的关键字值的信号量的标识符。如果IPC_EXCL和IPC_CREAT一同使用,则要么返回新创建的信号量集的标识符,要么返回-1。IPC_EXCL单独使用没有意义。参数nsems指出了一个新的信号量集中应该创建的信号量的个数。信号量集中最多的信号量的个数是在linux/sem.h中定义的:

3.信号量所表示的资源的操作

   函数semop用以操作一个信号量集,实质是通过修改sem_op指定对资源要进行的操作,semctl函数则是对信号量本身的值进行操作,可以修改信号量的值或者删除一个信号量,这是他们二者容易混淆的地方:

   int semop(int semid,struct sembuf semoparray[],size_t nops);

   semid是通过semget函数返回的一个信号量集标识符ID,nops标明了参数semoparray所指向数组中的元素个数。semoparray是一个结构数组指针。结构体struct sembuf 用来说明要执行的操作

  struct sembuf{

    unsigned short sem_num; //对应信号量集中的某一个资源

    short sem_op;  //指明所要执行的操作

    short  sem_flg; //函数semop的行为

   }

   在sembuf结构中,sem_num是相对应的信号量集中的某一个资源,所以它的值是一个从 0--相对应的信号量集的资源总数(ipc_perm.sem_nsems)之间的整数。

 sem_op指明想要进行的操作,sem_flg说明函数semop的行为。sem_op的值是一个整数。

sem_op:

(1)> 0:释放相应的资源数,如果有两个信号量,释放信号量1,则其semval+1,对信号量这个无名结构体的操作,可以通过下面介绍的semctl函数实现。

(2)0:进程阻塞直到信号量的相应值为0,当信号量已经为0,函数立即返回。

(3)< 0:请求sem_op的绝对值的资源数。

sem_flg 参数:

         该参数可设置为 IPC_NOWAIT 或 SEM_UNDO 两种状态。只有将 sem_flg 指定为 SEM_UNDO 标志后,semadj (所指定信号量针对调用进程的调整值)才会更新。   此外,如果此操作指定SEM_UNDO,系统更新过程中会撤消此信号灯的计数(semadj)。此操作可以随时进行---它永远不会强制等待的过程。调用进程必须有改变信号量集的权限。

         sem_flg公认的标志是 IPC_NOWAIT 和 SEM_UNDO。如果操作指定SEM_UNDO,它将会自动撤消该进程终止时。

        在标准操作程序中的操作是在数组的顺序执行、原子的,那就是,该操作要么作为一个完整的单元,要么不。如果不是所有操作都可以立即执行的系统调用的行为取决于在个人sem_flg领域的IPC_NOWAIT标志的存在。

示例1:sem.c

点击(此处)折叠或打开

  1. #include <sys/types.h>
  2. #include <sys/ipc.h>
  3. #include <sys/sem.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>

  6. int main(void)
  7. {
  8.     int sem_id;
  9.     int nsems=1;
  10.     int flag=0666;
  11.     struct sembuf buf;
  12.     

  13.     sem_id=semget(IPC_PRIVATE,nsems,flag);
  14.     if(sem_id<0)
  15.     {
  16.         printf("semget fail!\n");
  17.         exit(1);
  18.     }
  19.     
  20.     printf("semaphore :%d\n",sem_id);
  21.     buf.sem_num=0;
  22.     buf.sem_op=1;
  23.     buf.sem_flg=IPC_NOWAIT;
  24.     
  25.     if(semop(sem_id,&buf,nsems)<0)
  26.     {
  27.         perror("semop error");
  28.         exit(1);
  29.     }
  30.     
  31.     system("ipcs -s");
  32.     exit(0);
  33. }

  34. ./sem

  35. ------ Semaphore Arrays --------
  36. key semid owner perms nsems
  37. 0x00000000 0 root 666 1
  38. 0x00000000 32769 root 666 1
  39. 0x00000000 65538 root 666 1

  40. semaphore :65538


示例2:sem2.c

创建了包含两个信号量的一个信号量集

点击(此处)折叠或打开

  1. #include <sys/types.h>
  2. #include <sys/ipc.h>
  3. #include <sys/sem.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>

  6. int main(void)
  7. {
  8.     int sem_id;
  9.     int nsems=2;
  10.     int flag=0666;
  11.     struct sembuf buf[2];
  12.     

  13.     sem_id=semget(IPC_PRIVATE,nsems,flag);
  14.     if(sem_id<0)
  15.     {
  16.         printf("semget fail!\n");
  17.         exit(1);
  18.     }
  19.     
  20.     printf("semaphore :%d\n",sem_id);
  21.     buf[1].sem_num=1;
  22.     buf[1].sem_op=1;
  23.     buf[1].sem_flg=IPC_NOWAIT;
  24.     
  25.     buf[0].sem_num=0;
  26.     buf[0].sem_op=1;
  27.     buf[0].sem_flg=IPC_NOWAIT;
  28.     
  29.     if(semop(sem_id,buf,nsems)<0)
  30.     {
  31.         perror("semop error");
  32.         exit(1);
  33.     }
  34.     
  35.     system("ipcs -s");
  36.     exit(0);
  37. }

  38. ------ Semaphore Arrays --------
  39. key semid owner perms nsems
  40. 0x00000000 0 root 666 1
  41. 0x00000000 32769 root 666 1
  42. 0x00000000 65538 root 666 1
  43. 0x00000000 98307 root 666 2
  44. 0x00000000 131076 root 666 2
  45. 0x00000000 163845 root 666 2
  46. 0x00000000 196614 root 666 2
  47. 0x00000000 229383 root 666 2

  48. semaphore :229383


4.信号量集的操作

信号量集的操作函数semctl

#include <sys/sem.h>

int semctl(int sem_id,int semnum, int cmd[,union semun arg]);

sem_id是信号量集标识符,semnum指定集中某一个信号灯,类似于struct sembuf 结构数组的下标,用来对指定资源进行操作。cmd定义了函数要进行的操作。

cmd的值:

GETVAL  返回结构体数组中以semnum为下标的元素的成员semval值

SETVAL 使用arg.val对该信号量的semnum.sempid赋值

GETPID GETTNCNT GETZCNT GETALL SETALL ..

arg为可选参数,根据参数cmd的相关操作来选择使用

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

示例sem_ctl.c


点击(此处)折叠或打开

  1. #include <sys/types.h>
  2. #include <sys/ipc.h>
  3. #include <sys/sem.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>

  6. int main(void)
  7. {
  8.     int sem_id;
  9.     int nsems=2;
  10.     int flag=0666;
  11.     int val=1;
  12.     
  13.     sem_id=semget(IPC_PRIVATE,nsems,flag);
  14.     if(sem_id<0)
  15.     {
  16.         printf("semget fail!\n");
  17.         exit(1);
  18.     }
  19.     
  20.     printf("semaphore :%d\n",sem_id);
  21.     system("ipcs -s");
  22.     
  23.     if((val=semctl(sem_id,1,GETVAL))<0)
  24.     {
  25.         printf("getval fail!\n");
  26.     }
  27.     else
  28.     {
  29.         printf("val = %d\n",val);
  30.     }
  31.     
  32.     if(semctl(sem_id,0,IPC_RMID)<0)
  33.     {
  34.         perror("semctl!");
  35.         exit(1);
  36.     }
  37.     else
  38.     {
  39.         printf("semaphore removed:%d!\n",sem_id);
  40.         system("ipcs -s");
  41.     }
  42.     
  43.     exit(0);
  44.     
  45. }


  46. ------ Semaphore Arrays --------
  47. key semid owner perms nsems
  48. 0x00000000 0 root 666 1
  49. 0x00000000 32769 root 666 1
  50. .....
  51. 0x00000000 393228 root 666 2
  52. 0x00000000 720909 root 666 2


  53. ------ Semaphore Arrays --------
  54. key semid owner perms nsems
  55. 0x00000000 0 root 666 1
  56. 0x00000000 32769 root 666 1
  57. ......
  58. 0x00000000 131076 root 666 2
  59. 0x00000000 393228 root 666 2

  60. semaphore :720909
  61. val = 0  //val未初始化,尽管前面定义为1,这里还是0
  62. semaphore removed:
以上是对信号量与信号量集的基本操作,

进程间的信号量机制的测试:sem_process.c
 

点击(此处)折叠或打开

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


  11. typedef union semunion{
  12.     int val;
  13.     struct semid_ds *buf;
  14.     unsigned short *array;
  15. } semun;

  16. typedef semun semunion;

  17. int sem_init(int key)
  18. {
  19.     int semid;
  20.     semunion arg;
  21.     
  22.     printf("key is %d\n",key);
  23.     semid=semget(key,1,0660|IPC_CREAT);//创建一个信号量集,且只有一个信号量,控制的资源key
  24.     if(semid<0)
  25.     {
  26.         perror("semget fail!\n");
  27.         exit(1);
  28.     }
  29.     
  30.     arg.val = 2;
  31.     if(semctl(semid,0,SETVAL,arg)<0) //设置信号量的参数val
  32.     {
  33.         perror("semget fail!\n");
  34.         exit(2);
  35.     }
  36.     
  37.     return semid;
  38. }


  39. int sem_pos(int semid)
  40. {
  41.     struct sembuf buf;
  42.     buf.sem_num=0;
  43.     buf.sem_op=-1; //请求-1的绝对值个资源,
  44.     buf.sem_flg=SEM_UNDO;
  45.     
  46.     if(semop(semid,&buf,1)== -1)
  47.     {
  48.         perror("sem_op \n");
  49.         exit(3);
  50.     }
  51.     printf("sem_poss success!\n");
  52.     
  53.     return 0;
  54. }

  55. int sem_rel(int semid)
  56. {
  57.     struct sembuf buf;
  58.     buf.sem_num=0; //这个就是信号量集中的信号量元素下标
  59.     buf.sem_op=1; //释放1 个资源,
  60.     buf.sem_flg=IPC_NOWAIT;
  61.     
  62.     if(semop(semid,&buf,1)== -1)
  63.     {
  64.         perror("sem_op \n");
  65.         exit(3);
  66.     }
  67.     printf("sem_rel success!\n");
  68.     
  69.     return 0;
  70. }

  71. int sem_rmv(int semid)
  72. {
  73.     
  74.     if(semctl(semid,0,IPC_RMID)<0)
  75.     {
  76.         perror("semctl\n");
  77.         exit(3);
  78.     }
  79.     return 0;
  80. }


  81. int main(void)
  82. {
  83.    
  84.    key_t key;    
  85.    int pid,fd,semid,n;
  86.    char str[80];

  87.    key=ftok("./test.txt",5);//获得关键字,这就是信号量实际控制的资源
  88.    
  89.    semid=sem_init(key);
  90.    
  91.    if(semid<0)
  92.    {
  93.        perror("semget fail!\n");
  94.        exit(1);
  95.    }
  96.    
  97.    // 读写方式,如果文件不存在则新建,打开之后指针定位在文件尾部
  98.    fd=open("./test.txt",O_RDWR|O_CREAT|O_TRUNC,0644);
  99.    while((pid=fork())==-1); //创建子进程
  100.    if(pid==0)//child process
  101.    {
  102.     sleep(1); //睡眠1s
  103.     sem_pos(semid);
  104.     lseek(fd,SEEK_SET,0); //定位文件
  105.     read(fd,str,sizeof(str)); //读文件
  106.     sem_rel(semid); //释放操作
  107.     printf("child:read str from test file:%s\n",str);
  108.     exit(0);
  109.    }
  110.    else //parent process
  111.    {
  112.     sem_pos(semid); //     P操作
  113.     printf("parent:please enter a str for test file(strlen<80):\n");
  114.     gets(str);        //输入
  115.     n=strlen(str); // 长度
  116.     lseek(fd, SEEK_SET,0);    //定位    
  117.     write(fd,str,n);        //
  118.     sem_rel(semid); //释放
  119.     wait(0);
  120.     close(fd); //关闭文件
  121.     sem_rmv(semid); //删除信号量
  122.     exit(0);
  123.     }
  124.         return(0);
  125. }


 

 

   


 

  

 

阅读(1236) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册