posix信号量与互斥锁

1、简介

　　POSIX信号量是一个sem_t 类型的变量，但POSIX 有两种信号量的实现机制：无名信号量和命名信号量。无名信号量可以用在共享内存的情况下，

　　比如实现进程中各个线程之间的互斥和同步。命名信号量通常用于不共享内存的情况下，比如不共享内存的进程之间。

1.1POSIX 无名信号量

　　在使用信号量之前，必须对其进行初始化。sem_init 函数初始化指定的信号量：

　　int sem_init (sem_t *sem, int pshared, unsigned int value)

　　无名信号量（也称为基于内存的信号量）sem初始化，设置共享选项pshared，并指定一个整数类型的初始值为value。pshared参数控制着信号量的类型。

　　如果 pshared的值是0，就表示它是当前里程的局部信号量；否则，其它进程就能够共享这个信号量。

　　intsem_destroy(sem_t *sem);

 　　释放无名信号量。

1.2POSIX 命名信号量

　　之所以称为命名信号量，是因为它有一个名字、一个用户ID、一个组ID和权限，这些是提供给不共享内存的那些进程使用命名信号量的接口。命名信号量的名字是一个遵守路径名构造规则的字符串。

　　sem_t*sem_open(const char *name,int oflag,mode_t mode,unsigned int value);

　　参数 name 是一个标识信号量的字符串。参数oflag 用来确定是创建信号量还是连接已有信号量。如果设置了oflag 的O_CREAT 比特位，则会创建一个新的信号量。

　　有名信号量（返回值）的创建和初始化。出错时返回为SEM_FAILED。

　　int sem_close(sem_t *sem);

　　单个程序可以用sem_close函数关闭命名信号量，但是这样做并不能将信号量从系统中删除，因为命名信号量在单个程序的执行之外是具有持久性的。

　　当进程调用_exit、exit、exec 或从main 返回时，进程打开的命名信号量同样会被关闭。对应有名信号量的关闭，注意不是销毁，是关闭。

 　　int sem_unlink(count char*name);

　　sem_unlink函数用于在所有进程关闭了命名信号量之后，将信号量从系统中删除。对应有名信号量的销毁，每个信号都有一个引用计数器记录当前的打开次数，

　　sem_unlink必须等待这个数为0时才能把name所指的信号灯从文件系统中删除。也就是要等待最后一个sem_close发生

1.3信号量的操作函数为sem_post、sem_wait、sem_trywait:

　　int sem_wait(sem_t *sem); 

　　int sem_trywait(sem_t *sem);

　　对应信号量的P操作。 sem_wait和sem_trywait的差别是：当所指定信号灯的值已是0时，后者并不将调用线程投入睡眠。相反，他返回一个EAGAIN错误。

 　　int sem_post(sem_t *sem);

　　int sem_getvalue(sem_t *sem,int *valp);

　　对应信号量的V操作。

2、互斥锁是通过锁的机制来实现线程间的同步问题。互斥锁的基本流程为：

　　初始化一个互斥锁：pthread_mutex_init()函数

　　加锁：pthread_mutex_lock()函数或者pthread_mutex_trylock()函数

　　对共享资源的操作

　　解锁：pthread_mutex_unlock()函数

　　注销互斥锁：pthread_mutex_destory()函数

　　其中，在加锁过程中，pthread_mutex_lock()函数和pthread_mutex_trylock()函数的过程略有不同：

　　　　当使用pthread_mutex_lock()函数进行加锁时，若此时已经被锁，则尝试加锁的线程会被阻塞，直到互斥锁被其他线程释放，当pthread_mutex_lock()函数有返回值时，说明加锁成功；

　　　　而使用pthread_mutex_trylock()函数进行加锁时，若此时已经被锁，则会返回EBUSY的错误码。

　　同时，解锁的过程中，也需要满足两个条件：

　　　　解锁前，互斥锁必须处于锁定状态；

　　　　必须由加锁的线程进行解锁。

　　当互斥锁使用完成后，必须进行清除。

　　初始化互斥锁

　　int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

　　功能：初始化一个互斥锁。

　　参数：mutex：互斥锁地址。类型是 pthread_mutex_t 。
　　　　   attr：设置互斥量的属性，通常可采用默认属性，即可将 attr 设为 NULL。

　　可以使用宏 PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁，比如：

　　　　　pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;

　　这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_mutex_init() 来完成动态初始化，不同之处在于 PTHREAD_MUTEX_INITIALIZER 宏不进行错误检查。

　　返回值：成功：0，成功申请的锁默认是打开的。失败：非 0 错误码

　　上锁

　　int pthread_mutex_lock(pthread_mutex_t *mutex);　

　　功能：对互斥锁上锁，若互斥锁已经上锁，则调用者一直阻塞，直到互斥锁解锁后再上锁。

　　参数：mutex：互斥锁地址。

　　返回值：成功：0，失败：非 0 错误码

　　int pthread_mutex_trylock(pthread_mutex_t *mutex);

　　调用该函数时，若互斥锁未加锁，则上锁，返回 0；若互斥锁已加锁，则函数直接返回失败，即 EBUSY。

　　解锁

　　int pthread_mutex_unlock(pthread_mutex_t * mutex);

　　功能：对指定的互斥锁解锁。

　　参数：mutex：互斥锁地址。

　　返回值：成功：0，失败：非 0 错误码

　　销毁互斥锁

　　int pthread_mutex_destroy(pthread_mutex_t *mutex);

　　功能：销毁指定的一个互斥锁。互斥锁在使用完毕后，必须要对互斥锁进行销毁，以释放资源。

　　参数：mutex：互斥锁地址。

　　返回值：成功：0，失败：非 0 错误码

#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
", 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("	<--consume");

            printf("
");
        }

        consume_id = g_buffer[out];
        printf("%d begin consume product %d
", num, consume_id);
        g_buffer[out] = -1;
        out = (out + 1) % BUFFSIZE;
        printf("%d end consume product %d
", 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
", 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("	<--produce");

            printf("
");
        }
        
        printf("%d begin produce product %d
", num, produce_id);
        g_buffer[in] = produce_id;
        in = (in + 1) % BUFFSIZE;
        printf("%d end produce product %d
", 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;
}

 参考：http://blog.csdn.net/tennysonsky/article/details/46494077