信号量：
二元信号量和一般信号量
二元信号量是最简单的一种锁，适合那种被唯一线程访问的资源，而一般信号量就允许多线程并发的访问资源。
二元信号量类似于互斥量，但是有一点不同的是，互斥量只能被上锁的那个线程释放，通俗的说就是，哪个线程对互斥量加的锁，就由哪个线程来劲释放。
下面来举例证明上述言论，下面来个简单的生产者消费者的例子，拿二元信号量来实现：
?上述生产者和消费者分别有两个不同定义的信号量初值，生产者的信号量初值为1，消费者信号量初值为0，acquire方法是对信号量减一，release方法是对信号量进行加一。当信号量为0时，代表这个操作不可执行，例如semp = 0时，进入生产者线程且生产者不可再次生产(因为semp = 0)，当消费者执行完最后执行release方法，对semp进行加一操作，然后再来一个轮回执行。
下面来看代码：
#include<iostream>
#include<semaphore>
#include<thread>
using namespace std;
int g_num = 0;
std::binary_semaphore semp(1);
std::binary_semaphore sems(0);
void shengchanzhe()
{
for (int i = 0; i < 10; i++)
{
semp.acquire();
g_num = i;
cout << "生产：" << g_num << endl;
sems.release();
}
}
void xiaofeizhe()
{
for (int i = 0; i < 10; i++)
{
sems.acquire();
cout << "消费者：" << g_num << endl;
semp.release();
}
}
int main()
{
std::thread ths(shengchanzhe);
std::thread thx(xiaofeizhe);
ths.join();
thx.join();
return 0;
}下面是执行结果：
下面我们来看将二元信号量变为普通信号量：
std::binary_semaphore semp(1);
std::binary_semaphore sems(0);将信号量从上述变为：
std::counting_semaphore semp(2);
std::counting_semaphore sems(0);上述为啥要将消费者信号量初值从一变到二呢，因为二元信号量只有0和1，所以多线程对它进行访问的时候会有上述问题，这边因为有两个生产者线程，所以将生产者线程的信号量初始值设为2，将上述修改后的代码进行运行：
上述代码为普通信号量的执行结果，下面我们来对信号量进行模拟实现：
信号量模拟实现：
我们先构造一个Mysemaphore类，来模拟信号量的加减：
?
class Mysemaphore
{
public:
Mysemaphore(int val = 1) :count(1) {}
void P() //PV操作就是acquire和release操作
{
std::unique_lock<std::mutex> lock(mtk); //为了防止资源出现争夺，而出现生产或消费过度的情况
if (--count)
{
cv.wait(lock);
}
}
void V()
{
std::unique_lock<std::mutex> lock(mtk);
if (++count >= 0)
{
cv.notify_one();
}
}
private:
int count; //资源的个数
std::mutex mtk;
std::condition_variable cv;
};然后下面是生产者和消费者：
void P(int id) //生产者
{
for (int i = 0; i < 10; i++)
{
semp.P(); //acquire操作 +1操作
g_num = i;
cout << "生产者" << g_num << endl;
sems.V();
}
}
void xfz(int id) //消费者
{
for (int i = 0; i < 10; i++)
{
sems.P(); //release操作 -1操作
cout << "消费者" << g_num << endl;
semp.V();
}
}
然后我们进行测试代码：
int main()
{
std::thread th1(P, 1);
std::thread th2(S, 1);
th1.join();
th2.join();
return 0;
}结果如下：
?
