linux网络编程-posix信号量与互斥锁（39）

-posix信号量信号量

是打开一个有名的信号量

sem_init是打开一个无名的信号量，无名信号量的销毁用sem_destroy

sem_wait和sem_post是对信号量进行pv操作，既可以使用在有名的信号量也可以使用在无名的信号量

无名信号量是否意味着它不能够用于不同进程的多个线程之间的通信了

如果sem_init是非零的参数，那么这个无名的信号量可以用于不同进程间的多个线程之间的通信，前提条件是这个信号量的对象必须存储在共享内存区才可以。

上面这是互斥锁是无名的互斥锁，同样也可以可以用于不同进程间的多个线程之间的通信，前提条件是这个信号量的对象必须存储在共享内存区才可以。

下面我们使用互斥锁来解决生产者消费者的问题

生产者消费者问题是这样描述的，有一个缓冲区，是一个有大小的缓冲区，对于生产者来说，首先判断当前缓冲区是否满了，满了就阻塞不再生产，我们使用信号量来实现

使用信号量p(sem_full)的信号量来实现，初始化的值就是缓冲区的大小，一旦生产了一个产品sem_full的计数值值减一，一旦我们生成了产品，缓冲区不再是空的状态，我们使用一个

v(sem_empty)的信号量，用来告诉消费者可以来消费产品了，我们在生成产品的时候，由于生产者可能是多个，我们需要有一个互斥锁来包含缓冲区。

对于消费者，消费者也存在多个，首先判断当前缓冲区是否是空的，如果是空的就不能消费产品，需要等待生产者给消费者一个信号，消费者新建一个p(sem_empty)信号，使得信号量加一，这样消费者就可以消费产品了，

一旦消费者消费了一个产品，就会使得缓冲区的大小加一v(sem_full)这样的信号量，对于缓冲区，多个消费者也需要互斥

对于初始化，一开始只能生产产品，不能消费产品，假设缓冲区的大小是10，sem_full是10，sem_empty为0

下面我们通过代码来理解下面的问题：

信号量是在多线程环境中共享资源的计数器

sem_wait() 减小(锁定)由sem指定的信号量的值.如果信号量的值比0大,
　　那么进行减一的操作,函数立即返回.
　　如果信号量当前为0值,那么调用就会一直阻塞直到或者是信号量变得可以进行减一的操作
　　(例如,信号量的值比0大),或者是信号处理程序中断调用

当前初始化的sem_full的值是10，减一之后函数会立即返回不会阻塞

sem_wait   sem_post

信号量的数据类型为结构sem_t，它本质上是一个长整型的数。函数sem_init（）用来初始化一个信号量。它的原型为：　　

extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));　　

sem为指向信号量结构的一个指针；pshared不为０时此信号量在进程间共享，否则只能为当前进程的所有线程共享；value给出了信号量的初始值。　　

函数sem_post( sem_t *sem )用来增加信号量的值。当有线程阻塞在这个信号量上时，调用这个函数会使其中的一个线程不在阻塞，选择机制同样是由线程的调度策略决定的。　　

函数sem_wait( sem_t *sem )被用来阻塞当前线程直到信号量sem的值大于0，解除阻塞后将sem的值减一，表明公共资源经使用后减少。函数sem_trywait ( sem_t *sem )是函数sem_wait（）的非阻塞版本，它直接将信号量sem的值减一。　　

函数sem_destroy(sem_t *sem)用来释放信号量sem。　

信号量用sem_init函数创建的，下面是它的说明：
　　#include<semaphore.h>
 int sem_init (sem_t *sem, int pshared, unsigned int value);

生产完一个产品之后sem_post（&sem_empty）是的sem_empty的信号量的值加一

我们来看程序的代码：

#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)
#define CONSUMERS_COUNT 1
#define PRODUCERS_COUNT 1
#define BUFFSIZE 10
int g_buffer[BUFFSIZE];
unsigned short in = 0;
unsigned short out = 0;
unsigned short produce_id = 0;
unsigned short consume_id = 0;
sem_t g_sem_full;
sem_t g_sem_empty;
pthread_mutex_t g_mutex;
pthread_t g_thread[CONSUMERS_COUNT + PRODUCERS_COUNT];
void *consume(void *arg)
{
    int i;
    int num = (int)arg;
    while (1)
    {
        printf("%d wait buffer not empty\n", num);
        sem_wait(&g_sem_empty);
        pthread_mutex_lock(&g_mutex);
        for (i = 0; i < BUFFSIZE; i++)
        {
            printf("%02d ", i);
            if (g_buffer[i] == -1)
                printf("%s", "null");
            else
                printf("%d", g_buffer[i]);
            if (i == out)
                printf("\t<--consume");
            printf("\n");
        }
        consume_id = g_buffer[out];
        printf("%d begin consume product %d\n", num, consume_id);
        g_buffer[out] = -1;
        out = (out + 1) % BUFFSIZE;
        printf("%d end consume product %d\n", num, consume_id);
        pthread_mutex_unlock(&g_mutex);
        sem_post(&g_sem_full);
        sleep(1);
    }
    return NULL;
}
void *produce(void *arg)
{
    int num = (int)arg;
    int i;
    while (1)
    {
        printf("%d wait buffer not full\n", num);
        sem_wait(&g_sem_full);
        pthread_mutex_lock(&g_mutex);
        for (i = 0; i < BUFFSIZE; i++)
        {
            printf("%02d ", i);
            if (g_buffer[i] == -1)
                printf("%s", "null");
            else
                printf("%d", g_buffer[i]);
            if (i == in)
                printf("\t<--produce");
            printf("\n");
        }
        printf("%d begin produce product %d\n", num, produce_id);
        g_buffer[in] = produce_id;
        in = (in + 1) % BUFFSIZE;
        printf("%d end produce product %d\n", num, produce_id++);
        pthread_mutex_unlock(&g_mutex);
        sem_post(&g_sem_empty);
        sleep(5);
    }
    return NULL;
}
int main(void)
{
    int i;
    for (i = 0; i < BUFFSIZE; i++)
        g_buffer[i] = -1;
    sem_init(&g_sem_full, 0, BUFFSIZE);
    sem_init(&g_sem_empty, 0, 0);
    pthread_mutex_init(&g_mutex, NULL);

    for (i = 0; i < CONSUMERS_COUNT; i++)
        pthread_create(&g_thread[i], NULL, consume, (void *)i);
    for (i = 0; i < PRODUCERS_COUNT; i++)
        pthread_create(&g_thread[CONSUMERS_COUNT + i], NULL, produce, (void *)i);
    for (i = 0; i < CONSUMERS_COUNT + PRODUCERS_COUNT; i++)
        pthread_join(g_thread[i], NULL);
    sem_destroy(&g_sem_full);
    sem_destroy(&g_sem_empty);
    pthread_mutex_destroy(&g_mutex);
    return 0;
}

编译的时候需要加上gcc proudct.c -o product -lpthread

可以查看博客：

http://blog.csdn.net/nk_test/article/details/50449704