1、信号量的定义：

struct semaphore {

spinlock_t lock;

unsigned int count;

struct list_head wait_list;

};

在linux中，信号量用上述结构体表示，我们可以通过该结构体定义一个信号量。

2、信号量的初始化：

可用void sema_init(struct semaphore *sem, int val);直接创建，其中val为信号量初值。

也可以用两个宏来定义和初始化信号量的值为1或0：

DECLARE_MUTEX(name) : 定义信号量name并初始化为1

DECLARE_MUTEX_LOCKED(name) : 定义信号量name并初始化为0

还可以用下面的函数初始化：

void init_MUTEX(struct semaphore *sem); //初始化信号量的值为1

void init_MUTEX_LOCKED(struct semaphore *sem); //初始化信号量的值为0

3、信号量的原子操作：

p操作：

* void down(struct semaphore *sem); //用来获取信号量，如果信号量值大于或等于0，获取

信号量，否则进入睡眠状态，睡眠状态不可唤醒

* void down_interruptible(struct semephore *sem); //用来获取信号量，如果信号量大于或

等于0，获取信号量，否则进入睡眠状

态，等待信号量被释放后，激活该程。

* void down_trylock(struct semaphore *sem); //试图获取信号量，如果信号量已被其他进程

获取，则立刻返回非零值，调用者不会睡眠

v操作：

* void up(struct semaphore *sem); //释放信号量，并唤醒等待该资源进程队列的第一个进程




 前面一系列练习已经把进程控制、线程、进程间通信的大概知识过了一遍，现在进入综合练习，首先练习经典问题：生产者和消费者问题

1.问题概述

多个生产/消费者在有界缓冲上操作。它利用N个字节的共享内存作为有界循环缓冲区，利用写一字符模拟放一个产品，利用读一字符模拟消费一个产品。当缓冲区空时消费者应阻塞睡眠，而当缓冲区满时生产者应当阻塞睡眠。一旦缓冲区中有空单元，生产者进程就向空单元中入写字符,并报告写的内容和位置。一旦缓冲区中有未读过的字符，消费者进程就从该单元中读出字符，并报告读取位置。生产者不能向同一单元中连续写两次以上相同的字符，消费者也不能从同一单元中连续读两次以上相同的字符。

2.问题分析

首先看阶层，有两个，分别是生产者和消费者，他们之间的缓冲区是共享内存，首先想到一点：System V共享内存实现这一个缓冲区；又因为缓冲区是临界资源，所以要用一个互斥信号量实现；生产者和消费者要采用PV信号量操作实现进程同步

因为要求多个进程能同步，所以进程访问缓冲的指针也需要共享内存实现

大致框图：

生产者->[位置指针]--------（共享内存）缓冲-------[位置指针]->消费者

 

3.原语

  进程：Producer - 生产者进程，Consumer - 消费者进程
  共有的数据结构：
     buffer: array [0..k-1] of integer;
     in,out: 0..k-1;
       — in记录第一个空缓冲区，out记录第一个不空的缓冲区
     prod_key(缓冲区空的个数),cons_key(缓冲区满的个数),mutex(临界区): semaphore;

       — prod_key控制缓冲区不满,cons_key控制缓冲区不空,mutex保护临界区；
         初始化prod_key=k,cons_key=0,mutex=1
producer（生产者进程）：
   Item_Type item;
  {
     while (true)
     {
       produce(&item);
       p(prod_key);
       p(mutex);
       buffer[in]:=item;
       in:=(in+1) mod k;
       v(mutex);
       v(cons_key);
     }
  }

consumer（消费者进程）：
   Item_Type item;
  {
     while (true)
     {
       p(cons_key);
       p(mutex);
        item:=buffer[out];
        out:=(out+1) mod k;
        v(mutex);
        v(prod_key);
       consume(&item);
     }
   }
4.IPC操作函数

我们编写一个函数实现对IPC 信息队列、共享内存、信号量的包装，以备接下来更好的编写
程序
头文件ipc.h：声明ipc操作函数和一些变量

[cpp] view plain copy
  1. /*Filename : ipc.h*/  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <sys/types.h>  
  5. #include <sys/ipc.h>  
  6. #include <sys/shm.h>  
  7. #include <sys/sem.h>  
  8. #include <sys/msg.h>  
  9. #define BUFSZ 256  
  10. //建立或获取ipc 的一组函数的原型说明  
  11. int get_ipc_id(char *proc_file,key_t key);  
  12. char *set_shm(key_t shm_key,int shm_num,int shm_flag);  
  13. int set_msq(key_t msq_key,int msq_flag);  
  14. int set_sem(key_t sem_key,int sem_val,int sem_flag);  
  15. int down(int sem_id);  
  16. int up(int sem_id);  
  17. /*信号灯控制用的共同体*/  
  18. typedef union semuns   
  19. {  
  20.     int val;  
  21. } Sem_uns;  
  22. /* 消息结构体*/  
  23. typedef struct msgbuf  
  24. {  
  25.     long mtype;  
  26.     char mtext[1];  
  27. } Msg_buf;  
  28. //生产消费者共享缓冲区即其有关的变量  
  29. key_t buff_key;  
  30. int buff_num;  
  31. char *buff_ptr;  
  32. //生产者放产品位置的共享指针  
  33. key_t pput_key;  
  34. int pput_num;  
  35. int *pput_ptr;  
  36. //消费者取产品位置的共享指针  
  37. key_t cget_key;  
  38. int cget_num;  
  39. int *cget_ptr;  
  40. //生产者有关的信号量  
  41. key_t prod_key;     //IPC key标识  
  42. int prod_sem;       //生产者同步信号量  
  43.   
  44. //消费者有关的信号量  
  45. key_t cons_key;     //IPC key标识  
  46. int cons_sem;       //消费者同步信号量  
  47. int sem_val;  
  48. int sem_flg;  
  49. int shm_flg;  
  50. /*互斥信号量*/  
  51. key_t mtx_key;      //IPC key标识  
  52. int mtx_sem;        //互斥信号量  

ipc.c:这里包装了一些ipc的操作函数，包括信息队列、共享内存、信号量的创建/获得，及PV操作
这里逐一分析它们的实现过程：（在注释中）

[cpp] view plain copy
  1. /*ipc.c*/  
  2. #include "ipc.h"  
  3. /* 
  4. * get_ipc_id() 从/proc/sysvipc/文件系统中获取IPC 的id 号 
  5. * pfile: 对应/proc/sysvipc/目录中的IPC 文件分别为 
  6. * msg-消息队列,sem-信号量,shm-共享内存 
  7. * key: 对应要获取的IPC 的id 号的键值 
  8. */  
  9. int get_ipc_id(char *proc_file,key_t key)  
  10. {  
  11.     FILE *pf;  
  12.     int i,j;  
  13.     char line[BUFSZ],colum[BUFSZ];  
  14.     if((pf = fopen(proc_file,"r")) == NULL)  
  15.     {  
  16.         perror("Proc file not open");  
  17.         exit(EXIT_FAILURE);  
  18.     }  
  19.     fgets(line, BUFSZ,pf);  
  20.     while(!feof(pf))  
  21.     {  
  22.         i = j = 0;  
  23.         fgets(line, BUFSZ,pf);  
  24.         while(line[i] == ' ')  
  25.             i++;  
  26.         while(line[i] !=' ')  
  27.             colum[j++] = line[i++];  
  28.         colum[j] = '/0';  
  29.         if(atoi(colum) != key)   
  30.             continue;  
  31.         j=0;  
  32.         while(line[i] == ' ')  
  33.             i++;  
  34.         while(line[i] !=' ')   
  35.             colum[j++] = line[i++];  
  36.         colum[j] = '/0';  
  37.         i = atoi(colum);  
  38.         fclose(pf);  
  39.         return i;  
  40.     } fclose(pf);  
  41.     return -1;  
  42. }  
  43. /* 
  44. * 信号灯上的P/V 操作 
  45. * sem_id:信号灯数组标识符 
  46. * sem_num:信号灯数组下标 
  47. * buf:操作信号灯的结构 
  48. */  
  49. /*请求 P操作*/  
  50. int P_operation(int sem_id)  
  51. {  
  52.     struct sembuf buf;  
  53.     buf.sem_op = -1;  
  54.     buf.sem_num = 0;  
  55.     buf.sem_flg = SEM_UNDO;  
  56.     if((semop(sem_id,&buf,1)) <0)   
  57.     {  
  58.         perror("down error ");  
  59.         exit(EXIT_FAILURE);  
  60.     } return EXIT_SUCCESS;  
  61. }  
  62. /*释放 V操作*/  
  63. int V_operation(int sem_id)  
  64. {  
  65.     struct sembuf buf;  
  66.     buf.sem_op = 1;  
  67.     buf.sem_num = 0;  
  68.     buf.sem_flg = SEM_UNDO;  
  69.     if((semop(sem_id,&buf,1)) <0)   
  70.     {  
  71.         perror("up error ");  
  72.         exit(EXIT_FAILURE);  
  73.     } return EXIT_SUCCESS;  
  74. }  
  75. /* 
  76. * set_sem 函数建立一个具有n 个信号灯的信号量 
  77. * 如果建立成功，返回一个信号灯数组的标识符sem_id 
  78. * 输入参数： 
  79. * sem_key 信号灯数组的键值 
  80. * sem_val 信号灯数组中信号灯的个数 
  81. * sem_flag 信号灯数组的存取权限 
  82. */  
  83. /*实现过程:*建立信号灯->设置信号灯初值->返回ID*/  
  84. int set_sem(key_t sem_key,int sem_val,int sem_flg)  
  85. {  
  86.     int sem_id;  
  87.     Sem_uns sem_arg;  
  88.     //测试由sem_key 标识的信号灯数组是否已经建立  
  89.     if((sem_id = get_ipc_id("/proc/sysvipc/sem",sem_key)) < 0 )  
  90.     {  
  91.         //semget 新建一个信号灯,其标号返回到sem_id  
  92.         if((sem_id = semget(sem_key,1,sem_flg)) < 0)  
  93.         {  
  94.             perror("semaphore create error");  
  95.             exit(EXIT_FAILURE);  
  96.         }  
  97.         //设置信号灯的初值  
  98.         sem_arg.val = sem_val;  
  99.         if(semctl(sem_id,0,SETVAL,sem_arg) <0)  
  100.         {  
  101.             perror("semaphore set error");  
  102.             exit(EXIT_FAILURE);  
  103.         }  
  104.     }  
  105.     return sem_id;  
  106. }  
  107. /* 
  108. * set_shm 函数建立一个具有n 个字节的共享内存区 
  109. * 如果建立成功，返回一个指向该内存区首地址的指针shm_buf 
  110. * 输入参数： 
  111. * shm_key 共享内存的键值 
  112. * shm_val 共享内存字节的长度 
  113. * shm_flag 共享内存的存取权限 
  114. */  
  115. /*实现过程:创建共享内存->映射到进程的指针并返回*/  
  116. char * set_shm(key_t shm_key,int shm_num,int shm_flg)  
  117. {  
  118.     int i,shm_id;  
  119.     char * shm_buf;  
  120.     //测试由shm_key 标识的共享内存区是否已经建立  
  121.     if((shm_id = get_ipc_id("/proc/sysvipc/shm",shm_key)) < 0 )  
  122.     {  
  123.         //shmget 新建一个长度为shm_num 字节的共享内存,其标号返回到shm_id  
  124.         if((shm_id = shmget(shm_key,shm_num,shm_flg)) <0)  
  125.         {  
  126.             perror("shareMemory set error");  
  127.             exit(EXIT_FAILURE);  
  128.         }  
  129.         //shmat 将由shm_id 标识的共享内存附加给指针shm_buf  
  130.         if((shm_buf = (char *)shmat(shm_id,0,0)) < (char *)0)  
  131.         {  
  132.             perror("get shareMemory error");  
  133.             exit(EXIT_FAILURE);  
  134.         }  
  135.         /*共享内存区初始化*/  
  136.         for(i=0; i<shm_num; i++)   
  137.             shm_buf[i] = 0; //初始为0  
  138.     }  
  139.     //shm_key 标识的共享内存区已经建立,将由shm_id 标识的共享内存附加给指针shm_buf  
  140.     if((shm_buf = (char *)shmat(shm_id,0,0)) < (char *)0)  
  141.     {  
  142.         perror("get shareMemory error");  
  143.         exit(EXIT_FAILURE);  
  144.     }  
  145.     return shm_buf;  
  146. }  
  147. /* 
  148. * set_msq 函数建立一个消息队列 
  149. * 如果建立成功，返回一个消息队列的标识符msq_id 
  150. * 输入参数： 
  151. * msq_key 消息队列的键值 
  152. * msq_flag 消息队列的存取权限 
  153. */  
  154. /*实现过程:创建消息队列->返回ID*/  
  155. int set_msq(key_t msq_key,int msq_flg)  
  156. {  
  157.     int msq_id;  
  158.     //测试由msq_key 标识的消息队列是否已经建立  
  159.     if((msq_id = get_ipc_id("/proc/sysvipc/msg",msq_key)) < 0 )  
  160.     {  
  161.         //msgget 新建一个消息队列,其标号返回到msq_id  
  162.         if((msq_id = msgget(msq_key,msq_flg)) < 0)  
  163.         {  
  164.             perror("messageQueue set error");  
  165.             exit(EXIT_FAILURE);  
  166.         }  
  167.     }  
  168.     return msq_id;  
  169. }  

5.生产者程序实现：

首先建立（已存在时为打开）一系列的信号量和共享内存，接着就按照操作原语去实现了，代码如下：

[cpp] view plain copy
  1. /*Filename : producer.c*/  
  2. #include "ipc.h"  
  3. int main(int argc,char *argv[])  
  4. {  
  5.     int rate;  
  6.     //可在在命令行第一参数指定一个进程睡眠秒数，以调解进程执行速度  
  7.     if(argv[1] != NULL)   
  8.         rate = atoi(argv[1]);  
  9.     else  
  10.         rate = 3; //不指定为3 秒  
  11.     //共享内存使用的变量,其中键值任给,但是注意键值的  
  12.     //唯一性,在另外的文件中要用同一共享内存也要采用统一键值  
  13.     buff_key = 101;//缓冲区任给的键值  
  14.     buff_num = 8;//缓冲区任给的长度  
  15.     pput_key = 102;//生产者放产品指针的键值  
  16.     pput_num = 1; //指针数  
  17.     shm_flg = IPC_CREAT | 0644;//共享内存读写权限  
  18.     //获取缓冲区使用的共享内存，buff_ptr 指向缓冲区首地址  
  19.     buff_ptr = (char *)set_shm(buff_key,buff_num,shm_flg);  
  20.     //获取生产者放产品位置指针pput_ptr  
  21.     pput_ptr = (int *)set_shm(pput_key,pput_num,shm_flg);  
  22.     //信号量使用的变量  
  23.     prod_key = 201;//生产者同步信号灯键值  
  24.     mtx_key = 202;//互斥信号灯键值  
  25.     cons_key = 301;//消费者同步信号灯键值  
  26.     sem_flg = IPC_CREAT | 0644;  
  27.     //生产者同步信号灯初值设为缓冲区最大可用量  
  28.     sem_val = buff_num;  
  29.     //获取生产者同步信号灯，引用标识存prod_sem  
  30.     prod_sem = set_sem(prod_key,sem_val,sem_flg);  
  31.     //消费者初始无产品可取，同步信号灯初值设为0  
  32.     sem_val = 0;  
  33.     //获取消费者同步信号灯，引用标识存cons_sem  
  34.     cons_sem = set_sem(cons_key,sem_val,sem_flg);  
  35.     //生产者互斥信号灯初值为1  
  36.     sem_val = 1;  
  37.     //获取互斥信号灯，引用标识存mtx_sem  
  38.     mtx_sem = set_sem(mtx_key,sem_val,sem_flg);  
  39.     //循环执行模拟生产者不断放产品  
  40.     while(1)  
  41.     {  
  42.         //如果缓冲区满则生产者阻塞  
  43.         P_operation(prod_sem);  
  44.         //如果有进程进入，本生产者阻塞  
  45.         P_operation(mtx_sem);  
  46.         //用写一字符的形式模拟生产者放产品，报告本进程号和放入的字符及存放的位置  
  47.         buff_ptr[*pput_ptr] = 'A'+ *pput_ptr;  
  48.         //挂起rate秒  
  49.         sleep(rate);  
  50.         printf("%d producer put: %c to Buffer[%d]/n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);  
  51.         //存放位置循环下移  
  52.         *pput_ptr = (*pput_ptr+1) % buff_num;  
  53.         //唤醒阻塞的进程  
  54.         V_operation(mtx_sem);  
  55.         //唤醒阻塞的消费者  
  56.         V_operation(cons_sem);  
  57.     }  
  58.     return EXIT_SUCCESS;  
  59. }  

6.消费者程序实现

如同生产者上述，代码如下：

[cpp] view plain copy
  1. /* consumer.c*/  
  2. #include "ipc.h"  
  3. int main(int argc,char *argv[])  
  4. {  
  5.     int rate;  
  6.     //可在在命令行第一参数指定一个进程睡眠秒数，以调解进程执行速度  
  7.     if(argv[1] != NULL)   
  8.         rate = atoi(argv[1]);  
  9.     else   
  10.         rate = 3; //不指定为3 秒  
  11.     //共享内存使用的变量  
  12.     buff_key = 101; //缓冲区任给的键值  
  13.     buff_num = 8; //缓冲区任给的长度  
  14.     cget_key = 103; //消费者取产品指针的键值  
  15.     cget_num = 1; //指针数  
  16.     shm_flg = IPC_CREAT | 0644; //共享内存读写权限  
  17.     //获取缓冲区使用的共享内存，buff_ptr 指向缓冲区首地址  
  18.     buff_ptr = (char *)set_shm(buff_key,buff_num,shm_flg);  
  19.     //获取消费者取产品指针，cget_ptr 指向索引地址  
  20.     cget_ptr = (int *)set_shm(cget_key,cget_num,shm_flg);  
  21.     //信号量使用的变量  
  22.     prod_key = 201; //生产者同步信号灯键值  
  23.     mtx_key = 202; //互斥信号灯键值  
  24.     cons_key = 301; //消费者同步信号灯键值  
  25.     sem_flg = IPC_CREAT | 0644; //信号灯操作权限  
  26.     //生产者同步信号灯初值设为缓冲区最大可用量  
  27.     sem_val = buff_num;  
  28.     //获取生产者同步信号灯，引用标识存prod_sem  
  29.     prod_sem = set_sem(prod_key,sem_val,sem_flg);  
  30.     //消费者初始无产品可取，同步信号灯初值设为0  
  31.     sem_val = 0;  
  32.     //获取消费者同步信号灯，引用标识存cons_sem  
  33.     cons_sem = set_sem(cons_key,sem_val,sem_flg);  
  34.     //消费者互斥信号灯初值为1  
  35.     sem_val = 1;  
  36.     //获取互斥信号灯，引用标识存mtx_sem  
  37.     mtx_sem = set_sem(mtx_key,sem_val,sem_flg);  
  38.     //循环执行模拟消费者不断取产品  
  39.     while(1){  
  40.         //如果无产品消费者阻塞  
  41.         P_operation(cons_sem);  
  42.         //如果有进程进入,本消费者阻塞  
  43.         P_operation(mtx_sem);  
  44.         //用读一字符的形式模拟消费者取产品，报告本进程号和获取的字符及读取的位置  
  45.         sleep(rate);  
  46.         printf("%d consumer get: %c fromBuffer[%d]/n",getpid(),buff_ptr[*cget_ptr],*cget_ptr);  
  47.         //读取位置循环下移  
  48.         *cget_ptr = (*cget_ptr+1) % buff_num;  
  49.         //唤醒阻塞的进程  
  50.         V_operation(mtx_sem);  
  51.         //唤醒阻塞的生产者  
  52.         V_operation(prod_sem);  
  53.     }  
  54.     return EXIT_SUCCESS;  
  55. }  

7.编写Makefile

由于本项目工程有多个文件，所以需要Makefile来方便编译

[cpp] view plain copy
  1. hdrs = ipc.h  
  2. opts = -g -c  
  3. c_src = consumer.c ipc.c  
  4. c_obj = consumer.o ipc.o  
  5. p_src = producer.c ipc.c  
  6. p_obj = producer.o ipc.o  
  7. all: producer consumer  
  8. consumer: $(c_obj)  
  9.     gcc $(c_obj) -o consumer  
  10. consumer.o: $(c_src) $(hdrs)  
  11.     gcc $(opts) $(c_src)  
  12. producer: $(p_obj)  
  13.     gcc $(p_obj) -o producer  
  14. producer.o: $(p_src) $(hdrs)  
  15.     gcc $(opts) $(p_src)  
  16. clean:  
  17.     rm consumer producer *.o  

8.编译：

$ make

运行时打开多个终端窗口，输入

$./producer 1

另一个窗口输入：

$./consumer 1

.......

这时可以看到同步过程

GitHub 加速计划 / li / linux-dash
10.39 K
1.2 K
下载
A beautiful web dashboard for Linux
最近提交(Master分支：2 个月前 )
186a802e added ecosystem file for PM2 4 年前
5def40a3 Add host customization support for the NodeJS version 4 年前
Logo
GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的

avatar GitCode 开源社区

centOS 8 使用dnf安装Docker

DNF是什么？CentOS 8使用YUM软件包管理器版本v4.0.4。现在，该版本使用DNF(已删除YUM)。DNF是软件包管理器。它会在Linux发行版上安装，执行更新并删除软件包。使用DNF安装Docker跳过具有损坏依赖性的程序包一个有效的解决方案是使您的CentOS 8系统使用以下--nobest命令安装最符合条件的版本：sudo dnf install docker...

avatar GitCode 开源社区

定时同步数据库表(mysql+linux+crontab)

sync.sh里面的参数需要改变，ip/username/password/database/tablesync.sh#!/bin/sh# Please change the IP and password of the data source db.# Then change the table name.filename=/home/nington/db/$(date +%Y-%m

avatar GitCode 开源社区