利用信号量来调度共享资源 生产者-消费者问题

            信号量的的作用，互斥和同步。

        互斥就是确保对共享变量的互斥访问，基本思想就是：将每个共享变量与一个信号量s（初始化为1）联系起来，然后用P(s)和V（s)操作将相应的临界区包围起来。

        同步就是调度对共享资源的访问。信号量的同步：经典问题是生产者-消费者问题。

        生产者-消费者的问题描述如下：

  

         在本节中，我们将开发一个简单的包，叫做SBUF，用来构造生产者-消费者程序。在下一节中，我们会看到如何用它来构造一个基于预线程化的并发服务器。

         SBUF操作类型为sbuf_t的有限缓冲区，项目存放在一个动态分配的n項整数数组buf中。front 和 rear 索引值记录该数组的第一项和最后一项。三个信号量同步对缓冲区的访问。mutex信号量提供互斥的缓冲区访问。slots和items信号量分别记录空槽位和可用项目的数量。

        提示：下面的代码是在linux下运行的，在window下运行不了，需要链接线程库 pthread，代码是从从深入理解计算机系统中摘录下来的。

        注：csapp.h 是包装函数，包含了各种头文件和相关函数的错误处理，等一下会说明。

sbuf_h文件：         

<span style="color:#ff0000;">#ifndef __SBUF_H__
#define __SBUF_H__</span>

#include "csapp.h"

/* $begin sbuft */
typedef struct {
    int *buf;          /* Buffer array */         
    int n;             /* Maximum number of slots */
    int front;         /* buf[(front+1)%n] is first item */
    int rear;          /* buf[rear%n] is last item */
    <span style="color:#ff0000;">sem_t mutex;       /* Protects accesses to buf */</span>
    <span style="color:#ff0000;">sem_t slots;       /* Counts available slots */</span>
    <span style="color:#ff0000;">sem_t items;       /* Counts available items */</span>
} sbuf_t;
/* $end sbuft */

void sbuf_init(sbuf_t *sp, int n);
void sbuf_deinit(sbuf_t *sp);
void sbuf_insert(sbuf_t *sp, int item);
int sbuf_remove(sbuf_t *sp);

<span style="color:#ff0000;">#endif</span> /* __SBUF_H__ */

注释： 

           1、学习头文件的定义方式，使用#ifndef

         2、sem_t 信号量定义在文件semaphore.h

         3、三个信号量同步对缓冲区的访问。mutex信号量提供互斥的缓冲区访问。slots和items信号量分别记录空槽位和可用项目的数量。

         4、mutex：缓冲区的读取和写入不能同时进行，mutex保证对buffer的访问是互斥的

       现在给出 SBUF函数的实现，sbuf_init函数为缓冲区分配堆存储器，设置front 和 rear表示一个空的缓冲区，并为三个信号赋初始值。sbuf_deini是在应用程序使用完缓冲区时，释放缓冲区存储的。sbuf_insert函数等待一个可用的槽位，对互斥锁加锁，添加项目，对互斥锁解锁，然后宣布一个新项目可用。sbuf_remove在等待一个可用的缓冲区项目后，对互斥锁加锁，从缓冲区的前面取出该项目，对互斥锁解锁，然后发信号通知一个新的槽位可用。

/* $begin sbufc */
#include "csapp.h"
#include "sbuf.h"

/* Create an empty, bounded, shared FIFO buffer with n slots */
/* $begin sbuf_init */
void sbuf_init(sbuf_t *sp, int n)
{
    sp->buf = Calloc(n, sizeof(int)); 
    sp->n = n;                       /* Buffer holds max of n items */
    <span style="color:#ff6666;">sp->front = sp->rear = 0;        /* Empty buffer iff front == rear */</span>
<span style="color:#ff0000;">    Sem_init(&sp->mutex, 0, 1);      /* Binary semaphore for locking */
    Sem_init(&sp->slots, 0, n);      /* Initially, buf has n empty slots */
    Sem_init(&sp->items, 0, 0);      /* Initially, buf has zero data items */</span>
}
/* $end sbuf_init */

/* Clean up buffer sp */
/* $begin sbuf_deinit */
void sbuf_deinit(sbuf_t *sp)
{
    Free(sp->buf);
}
/* $end sbuf_deinit */

/* Insert item onto the rear of shared buffer sp */
/* $begin sbuf_insert */
void sbuf_insert(sbuf_t *sp, int item)
{
    <span style="color:#ff0000;">P(&sp->slots);   </span>                       /* Wait for available slot */
    <span style="color:#3333ff;">P(&sp->mutex);</span>                          /* Lock the buffer */
    sp->buf[(++sp->rear)%(sp->n)] = item;   /* Insert the item */
   <span style="color:#3366ff;"> V(&sp->mutex);</span>                          /* Unlock the buffer */
    V(&sp->items);                          /* Announce available item */
}
/* $end sbuf_insert */

/* Remove and return the first item from buffer sp */
/* $begin sbuf_remove */
int sbuf_remove(sbuf_t *sp)
{
    int item;
    P(&sp->items);                          /* Wait for available item */
    P(&sp->mutex);                          /* Lock the buffer */
    item = sp->buf[(++sp->front)%(sp->n)];  /* Remove the item */
    V(&sp->mutex);                          /* Unlock the buffer */
    <span style="color:#ff0000;">V(&sp->slots);</span>                          /* Announce available slot */
    return item;
}
/* $end sbuf_remove */
/* $end sbufc */

注释：

1、  Sem_init(&sp->mutex, 0, 1); -互斥锁初始化为1 

       Sem_init(&sp->slots, 0, n);   -初始化可用锁为n

       Sem_init(&sp->items, 0, 0); -初始化可用项目为0

2、互斥问题,P,V操作会在同一个进程（函数）中出现（代码中，标蓝的部分）

      同步问题,P,V操作会在不同的进程（函数)中出现（代码中， 标红的部分）

3、P(&sp->slots);P(&sp->mutex);这两个P操作不能对调，因为，若一个缓冲区已满，P(&sp->mutex)，生产者占用了缓冲区，之后执行P(&sp->slots)，因为缓冲区已满，生产者挂起，因为生产者占用了缓冲区，所以，消费者就无法进入缓冲区，导致死锁。

4、V(&sp->mutex);V(&sp->items);是可以对调的，逻辑上不会出错，但颠倒之后临界区会扩大，不合适。

5、P操作可以是调用者进程挂起，但V操作不会使调用者进程挂起。

接下来：介绍上面使用过的几个函数，都是包装完了，包含了错误处理，详情见博客：http://blog.csdn.net/lujiandong1/article/details/45486063

strerror(errno)：获取errno对应的错误

errno 是全局错误整数变量，由系统定义

下面的几个函数都是在 csapp.c中定义的

/************************** 
 * Error-handling functions
 **************************/
/* $begin errorfuns */
/* $begin unixerror */
  void unix_error(char *msg) /* unix-style error */
{
    fprintf(stderr, "%s: %s\n", msg, strerror(errno));
    exit(0);
}
/* $end unixerror */

void *Calloc(size_t nmemb, size_t size) 
{
    void *p;

    if ((p = calloc(nmemb, size)) == NULL)
	unix_error("Calloc error");
    return p;
}

void Free(void *ptr) 
{
    free(ptr);
}

void Sem_init(sem_t *sem, int pshared, unsigned int value) 
{
    if (sem_init(sem, pshared, value) < 0)
	unix_error("Sem_init error");
}

void P(sem_t *sem) 
{
    if (sem_wait(sem) < 0)
	unix_error("P error");
}

void V(sem_t *sem) 
{
    if (sem_post(sem) < 0)
	unix_error("V error");
}

总结：1、使用错误包装处理函数

           2、SBUF我们可以很容易改成类的形式，可以把缓冲区数据类型拓展成其他数据类型。