Linux 线程】线程同步《四》

1、信号量

（1）概念

信号量和互斥锁(mutex)的区别：互斥锁只允许一个线程进入临界区，而信号量允许多个线程同时进入临界区。

不多做解释，要使用信号量同步，需要包含头文件semaphore.h。

主要用到的函数：

• int sem_init(sem_t *sem, int pshared, unsigned int value);其中sem是要初始化的信号量，pshared表示此信号量是在进程间共享还是线程间共享，value是信号量的初始值。
• int sem_destroy(sem_t *sem);其中sem是要销毁的信号量。只有用sem_init初始化的信号量才能用sem_destroy销毁。
• int sem_wait(sem_t *sem);等待信号量，如果信号量的值大于0，将信号量的值减1，立即返回。如果信号量的值为0，则线程阻塞。相当于P操作。成功返回0，失败返回-1。
• int sem_post(sem_t *sem); 释放信号量，让信号量的值加1。相当于V操作。

（2）举例

《举例1》

 /*************************************************************************
     > File Name: semTest1.c
     > Summary:  信号量实现生产者&消费者模型
     > Author: xuelisheng
     > Created Time: 2018年12月18日
  ************************************************************************/

 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <semaphore.h>

 #define NUM 5

 int queue[NUM];                                // 全局数组实现环形队列
 sem_t blank_number, product_number;            // 定义2个信号量：空格子信号量   产品信号量

 void *producer(void *arg)
 {
     int i = ;
     while()
     {
         // int sem_post(sem_t *sem); 释放信号量，让信号量的值加1。相当于V操作。
         sem_wait(&blank_number);                // 生产者将空格字数 -- ，为0则阻塞等待
         queue[i] = rand() %  + ;           // 生产一个产品
         printf("-----producer-----%d          i = %d\n",queue[i], i);
         sem_post(&product_number);              // 将产品数 ++   唤醒

         i = (i+) % NUM;                        // 借助下标实现环形队列
         sleep(rand() % );
     }
 }

  void *consumer(void *arg)
  {
      int i = ;
      while()
      {
          // int sem_wait(sem_t *sem);等待信号量，如果信号量的值大于0,将信号量的值减1,立即返回。如果信号量的值为0,则线程阻塞。相当于P操作。成功返回0,失败返回-1。
          sem_wait(&product_number);            // 消费者将产品信号量数 --，为0则阻塞等待
          printf("-----consumer-----%d         i = %d\n", queue[i], i);
          queue[i] = ;                        // 消费一个产品（填充0表示）
          sem_post(&blank_number);             // 消费掉之后，将格子数 ++

          i= (i+) % NUM;
          sleep(rand() % );
      }
  }

  int main()
  {
      pthread_t pid, cid;

      // int sem_init(sem_t *sem, int pshared, unsigned int value);，其中sem是要初始化的信号量，pshared表示此信号量是在进程间共享还是线程间共享(0表示线程)，value是信号量的初始值。
      sem_init(&blank_number, , NUM);
      sem_init(&product_number, , );

      pthread_create(&pid, NULL, producer, NULL);
      pthread_create(&cid, NULL, consumer, NULL);

      pthread_join(pid, NULL);
      pthread_join(cid, NULL);

      // int sem_destroy(sem_t *sem); 其中sem是要销毁的信号量。只有用sem_init初始化的信号量才能用sem_destroy销毁。
      sem_destroy(&blank_number);
      sem_destroy(&product_number);

      return ;
  }

运行结果：

-----producer-----          i =
-----consumer-----         i =
-----producer-----          i =
-----producer-----          i =
-----producer-----          i =
-----producer-----          i =
-----producer-----            i =
-----consumer-----         i =
-----producer-----          i =
-----consumer-----         i =
-----producer-----          i =
-----consumer-----         i =
-----producer-----          i =
-----consumer-----         i =
-----producer-----          i =
-----consumer-----         i =
-----producer-----          i = 

《举例2》

 /*************************************************************************
     > File Name: semTest2.c
     > Summary:  基于信号量的多线程同步，操作系统原理中的P,V操作
     > Author: xuelisheng
     > Created Time: 2018年12月18日
  ************************************************************************/
 #include <pthread.h>
 #include <semaphore.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>

 /* @Scene: 某行业营业厅同时只能服务两个顾客。
  * 有多个顾客到来，每个顾客如果发现服务窗口已满，就等待，
  * 如果有可用的服务窗口，就接受服务。 */

 /* 将信号量定义为全局变量，方便多个线程共享 */
 sem_t sem;

 /* 每个线程要运行的例程 */
 void * get_service(void *thread_id)
 {
     /* 注意：立即保存thread_id的值，因为thread_id是对主线程中循环变量i的引用，它可能马上被修改 */
     int customer_id = *((int *)thread_id);

     if(sem_wait(&sem) == )                         // 对共享资源的控制（每次只能2个线程对共享资源进行访问）
     {
         usleep();                /* service time: 100ms */
         printf("customer %d receive service ...\n", customer_id);
         sem_post(&sem);
     }
 }

 #define CUSTOMER_NUM 10

 int main(int argc, char *argv[])
 {
     /* 初始化信号量，初始值为2，表示有两个顾客可以同时接收服务 */
     /* @prototype: int sem_init(sem_t *sem, int pshared, unsigned int value); */
     /* pshared: if pshared == 0, the semaphore is shared among threads of a process
      * otherwise the semaphore is shared between processes.   */
     sem_init(&sem, , );

     /* 为每个顾客定义一个线程id, pthread_t 其实是unsigned long int */
     // 定义10个线程
     pthread_t customers[CUSTOMER_NUM];

     int i, ret;
     /* 为每个顾客生成一个线程 */
     for(i = ; i < CUSTOMER_NUM; i++)
     {
         int customer_id = i;
         ret = pthread_create(&customers[i], NULL, get_service, &customer_id);
         if(ret != )
         {
             perror("pthread_create");
             exit();
         }
         else
         {
             printf("Customer %d arrived.\n", i);
         }
         usleep();
     }

     /* 等待所有顾客的线程结束 */
     /* 注意：这地方不能再用i做循环变量，因为可能线程中正在访问i的值 */
     int j;
     for(j = ; j < CUSTOMER_NUM; j++)
      {
         pthread_join(customers[j], NULL);
     }

     /* Only a  semaphore that  has been initialized  by sem_init(3)
      * should be destroyed using sem_destroy().*/
     sem_destroy(&sem);
     return ;
 }

运行结果：（结果不唯一）

Customer  arrived.
Customer  arrived.
customer  receive service ...
Customer  arrived.
customer  receive service ...
Customer  arrived.
customer  receive service ...
Customer  arrived.
customer  receive service ...
Customer  arrived.
customer  receive service ...
Customer  arrived.
customer  receive service ...
Customer  arrived.
customer  receive service ...
Customer  arrived.
customer  receive service ...
Customer  arrived.
customer  receive service ...
customer  receive service ...

参考：https://www.cnblogs.com/jiqingwu/p/linux_semaphore_example.html