信号量的产生原因
我们将可能会被多个执行流同时访问的资源叫做临界资源，临界资源需要进行保护否则会出现数据不一致等问题。
当我们仅用一个互斥锁对临界资源进行保护时，相当于我们将这块临界资源看作一个整体，同一时刻只允许一个执行流对这块临界资源进行访问。
但实际我们可以将这块临界资源再分割为多个区域，当多个执行流需要访问临界资源时，如果这些执行流访问的是临界资源的不同区域，那么我们可以让这些执行流同时访问临界资源的不同区域，此时不会出现数据不一致等问题。
举个栗子：
假设临界资源是一块数组：
vector<int>nums(5,1)互斥锁的要求是只能访问这个数组nums，信息量可以允许A执行流访问nums[1];B执行流访问nums[2]，只要下标是不一样的，其他执行流都可以访问数组nums。
信号量的概念
信号量又叫做信号灯，其本质是一个支持PV操作的计数器。POSIX信号量和SystemV信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的。 但POSIX可以用于线程间同步。
信号量函数
初始化
SEM_INIT(3) Linux Programmer's Manual SEM_INIT(3)
NAME
sem_init - initialize an unnamed semaphore
SYNOPSIS
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
Link with -pthread.
销毁
NAME
sem_destroy - destroy an unnamed semaphore
SYNOPSIS
#include <semaphore.h>
int sem_destroy(sem_t *sem);
Link with -pthread.
等待
NAME
sem_wait, sem_timedwait, sem_trywait - lock a semaphore
SYNOPSIS
#include <semaphore.h>
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
Link with -pthread.
Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
sem_timedwait(): _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
功能：等待信号量，会将信号量的值减1
发布
NAME
sem_post - unlock a semaphore
SYNOPSIS
#include <semaphore.h>
int sem_post(sem_t *sem);
Link with -pthread.
功能：发布信号量，表示资源使用完毕，可以归还资源了。将信号量值加1。
二元信号量模拟实现互斥功能
信号量本质是一个计数器，如果将信号量的初始值设置为1，那么此时该信号量叫做二元信号量。
基于环形队列的生产消费模型
环形队列采用数组模拟，用模运算来模拟环状特性
生产者和消费者申请和释放资源
空间资源和数据资源
代码上用 data_sem和space_sem分别表示数据资源和空间资源
生产者：生产者关注的是空间资源，只要环形队列中有空间，他就可以生产。
=》生产者申请空间资源，释放数据资源
让我们来分析一下生产者具体需要做什么：
1.如果blank_sem的值不为0，则信号量申请成功，此时生产者可以进行生产操作。
2.如果blank_sem的值为0，则信号量申请失败，此时生产者需要在blank_sem的等待队列下进行阻塞等待，直到环形队列当中有新的空间后再被唤醒
消费者：消费者关注的是数据资源，只要有数据就能消费
=》消费者申请数据资源，释放空间资源
消费者有具体怎么做呢？
虽然生产者在进行生产前是对blank_sem进行的P操作，但是当生产者生产完数据，应该对data_sem进行V操作而不是blank_sem。
生产者在生产数据前申请到的是blank位置，当生产者生产完数据后，该位置当中存储的是生产者生产的数据，在该数据被消费者消费之前，该位置不再是blank位置，而应该是data位置。
当生产者生产完数据后，意味着环形队列当中多了一个data位置，因此我们应该对data_sem进行V操作。
必须遵守的两个规则
第一个规则：生产者和消费者不能对同一个位置进行访问。（这个是显然的，如果同时访问同一个位置的数据，可能会产生意外的错误）
第二个规则：无论是生产者还是消费者，都不应该将对方套一个圈以上。
（我们通过信号量适当地让消费者线程和生产者线程相互切换）
信号量保护环形队列的原理
代码实现
#include <iostream>
#include <vector>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
const int NUM=16;
class RingQueue
{
public:
RingQueue(int _cap = NUM) : q(_cap), cap(_cap)
{
sem_init(&data_sem, 0, 0);
sem_init(&space_sem, 0, cap);
consume_step = 0;
product_step = 0;
}
void PutData(const int &data)
{
sem_wait(&space_sem); // P
q[consume_step] = data;
consume_step++;
consume_step %= cap;
sem_post(&data_sem); // V
}
void GetData(int &data)
{
sem_wait(&data_sem);
data = q[product_step];
product_step++;
product_step %= cap;
sem_post(&space_sem);
}
~RingQueue()
{
sem_destroy(&data_sem);
sem_destroy(&space_sem);
}
private:
std::vector<int> q;
int cap;
sem_t data_sem;
sem_t space_sem;
int consume_step;
int product_step;
};
void *consumer(void *arg)
{
RingQueue *rqp = (RingQueue *)arg;
int data;
while (true)
{
rqp->GetData(data);
std::cout << "Consume data done : " << data << std::endl;
sleep(1);
}
}
void *producter(void *arg)
{
RingQueue *rqp = (RingQueue *)arg;
srand((unsigned long)time(NULL));
while (true)
{
int data = rand() % 1024;
rqp->PutData(data);
std::cout << "Prodoct data done: " << data << std::endl;
// sleep(1);
}
}
int main()
{
RingQueue rq;
pthread_t c, p;
pthread_create(&c, NULL, consumer, (void *)&rq);
pthread_create(&p, NULL, producter, (void *)&rq);
pthread_join(c, NULL);
pthread_join(p, NULL);
}更多代码实现参考
RingQueue · fortianyang/StudyForLinux - 码云 - 开源中国 (gitee.com)
