linux网络编程之posix信号量与互斥锁

继上次学习了posix线程之后，这次来讨论一下posix信号量与互斥锁相关的知识：

 

跟posix消息队列，共享内存的打开，关闭，删除操作一样，不过，上面的函数是对有名信号量进行操作，通过man帮助可以得知：

有名信号量相对的那就是无名信号量，对于它相关的函数如下：

同样可以查看man帮助：

【思考】：是不是无名信号量就无法用于不同进程间的多个线程间进行通信呢？实际上不是这样的：

而对于信号量的P、V操作，可以用以下两个函数，既能用于有名，也能用于无名信号量：

初始化互斥锁：

 锁定操作：

 解锁操作：

 锁屏互斥锁：

【说明】:以上四个函数也是应用于无名的，也可以用于不同进程的不同线程间进行通信。

接下来就用信号量与互斥锁来解决生产者消费者的问题:

关于生产者消费者问题，在之前的学习中已经有接触过了，可以参考博文：http://www.cnblogs.com/webor2006/p/4204693.html

下面利用posix信号量与互斥锁来模拟生产者消费者问题：

由于生产者与消费者可以有多个，所以这两个的个数可以定义成一个宏，便于随意更改：

接下来要定义一些信号量和互斥锁变量：

以上是一些全局数据的初始化，接下来则开始真正代码的编写，首先得初始化信号量和互斥锁：

接下来创建若干个线程：

 

接下来来编写生产者与消费者的入口函数的实现：

 

先来实现生产产品的代码：

在正式生产之前，先打印出仓库当前的状态，也就是缓冲区里：

同样的，在消费之前，也打印一下当前仓库消费的状态：

打印状态之后，则开始生产产品：

同样的消费者也类似：

 至此代码功能已经编写完成，下面则通过调整生产者与消费者的个数，再配合睡眠来查看一下运行结果：

情况一：生产产品比较快，消费产品比较慢，所以经常有产品满的情况，也就是生产者会出现等待。

编译运行：

从结果中来以发现：

情况二：生产产品比较慢，但是消费得比较快，所以经常出现产品为空的情况，也就是消费者会不断出现等待。

下面再来看下这种情况的效果：

从中可以发现：

以上就是实验的结果，下面再了解两个相关的线程锁。

【仅作了解】

也就是说如果对某个临界区施加了共享锁，意味着还可以对其施加共享锁；而如果对临界区施加了共享锁或排它锁，则不允许其它线程对它施加排它锁。

最后再附上实验的代码：

#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 num = (int)arg;
    int i;
    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;
}

好了，先学到这~~