Linux线程同步之信号量

由于互斥锁的粒度比较大，如果我们希望多个线程对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发度下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。
信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。
注：信号量既可以用于线程同步，也可以用于进程同步。

一、信号量及相关函数使用

1.sem_init 函数 
初始化一个信号量
int sem_init(sem_t *sem, int pshared, unsigned int value);
参1：sem 信号量
参2：pshared 取 0 用于线程间同步，取非 0（一般为 1）用于进程间同步，也可以使用宏 PTHREAD_PROCESS_SHARED（进程间） 和 PTHREAD_PROCESS_PRIVATE（线程间） 来指定。
参3：value 指定信号量初值

2.sem_destroy 函数 
销毁一个信号量
int sem_destroy(sem_t *sem);

3.sem_wait 函数 
给信号量加锁，信号量的值大于0时，信号量的值-1，当信号量的值等于0时，继续调用造成线程阻塞。类比 pthread_mutex_lock。
int sem_wait(sem_t *sem);

4.sem_post 函数 
给信号量解锁，将信号量值+1，同时唤醒阻塞在信号量上的线程。类比pthread_mutex_unlock。
int sem_post(sem_t *sem);

5.sem_trywait 函数 
尝试对信号量加锁（与 sem_wait 的区别类比 lock 和 trylock）
int sem_trywait(sem_t *sem);

6.sem_timedwait 函数 
限时尝试对信号量加锁
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
参2：abs_timeout 采用的是绝对时间。

注：如果需要设置超时时间，可通过以下函数获取abs_timeout。

// c++代码 获取需要延时等待时间的绝对时间戳
void GetAbsTime(size_t milliseconds, timespec& absTime)
{
	// CLOCK_REALTIME：系统实时时间,随系统实时时间改变而改变,即从UTC1970-1-1 0:0:0开始计时,
	//                 中间时刻如果系统时间被用户改成其他,则对应的时间相应改变
    clock_gettime(CLOCK_REALTIME, &absTime);
    
	absTime.tv_sec += milliseconds / 1000;
    absTime.tv_nsec += (milliseconds % 1000) * 1000000;

    // 纳秒进位秒
    if(absTime.tv_nsec >= 1000000000) {
        absTime.tv_sec += 1;
        absTime.tv_nsec -= 1000000000;
    }
}

注：以上 6 个函数的返回值都是成功返回 0， 失败返回-1，同时设置 errno。

7.sem_t 类型
信号量类型，规定信号量 sem 不能 < 0。

二、基于信号量的生产者消费者模型

需要使用两个信号量，分别来阻塞消费者和生产者，代码如下：

/*信号量实现 生产者 消费者问题*/
#include <stdlib.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;

void *producer(void *arg)
{
    int i = 0;

    while (1) {
    	// 生产者将空格子数--, 为0则阻塞等待
        sem_wait(&blank_number);
        // 生产一个产品                  
        queue[i] = rand() % 1000 + 1;
        printf("----Produce---%d\n", queue[i]);
        // 将产品数++     
        sem_post(&product_number);                  
		// 借助下标实现环形
        i = (i+1) % NUM;
        sleep(rand()%1);
    }
}

void *consumer(void *arg)
{
    int i = 0;

    while (1) {
    	// 消费者将产品数--, 为0则阻塞等待
        sem_wait(&product_number);                  
        printf("-Consume---%d\n", queue[i]);
        // 消费一个产品 
        queue[i] = 0;
        // 消费掉以后, 将空格子数++
        sem_post(&blank_number);

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

int main(int argc, char *argv[])
{
    pthread_t pid, cid;
	// 初始化空格子信号量为5, 线程间共享
    sem_init(&blank_number, 0, NUM);
    // 初始化产品信号量为0, 线程间共享         
    sem_init(&product_number, 0, 0);

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

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

    sem_destroy(&blank_number);
    sem_destroy(&product_number);

    return 0;
}