上次文章的最后，我们提出一个由异步引发的问题，这样的问题确实很麻烦，因此引出同步抽象的概念
Semaphore
class Semaphore {
public:
Semaphore(char* name, int value);
~Semaphore();
void P();
void V();
}
- P()：持续等待，直到计数器大于0，然后使计数器减少，然后返回
- V()：使计数器增加
下面一个栗子
int a = 0;
Semaphore *s;
void sum(int p) {
int t;
s->P();
a++;
t = a;
s->V();
printf("%d : a=%d\n", p, t);
}
void main() {
Thread *t = new Thread("");
s = new Semaphore("s", 1);
t->Fork(sum, 1);
sum(0);
}
注意下面几点
- 红色圈圈：是指创建一个Semaphore的对象，然后这个对象的名字是‘s’，他的计数器初始值为1
- 绿色圈圈：这个部分真真正正地实现了同步操作，如果进入sum函数，会触碰到P()，它会检测计数器是否大于0，由于计数器初始值为1，使他小于等于零的条件是执行P()操作（使计数器值减少），因此用人的思维来理解就是：这有多个sum函数正在执行，并且没有到达V()操作（因为V()操作要增加计数器的值）。如果满足上述的话，P()将会等待，直到计数器大于零，用人的话来说就是等别的sum函数结束才能运行此sum函数
Locks
虽然这个Semaphores确实解决了一些问题，但毕竟只是个初级设想，存在很多麻烦，自然而然要被锁来替代
class Lock {
public:
Lock(char* name); // initialize lock to be FREE
~Lock(); // deallocate lock
void Acquire(); // the only operations on a lock
void Release(); // they are both *atomic*
}
- Lock (name) : creates a lock that starts out in the unlocked state.
- Acquire() : Atomically waits until the lock state is unlocked, then sets the lock state to locked.
- Release() : Atomically changes the lock state to unlocked from locked.
简单来说，用锁的获取与释放，代替了计数器的增加与减少，相应的，也会多出更多的规则：
- 在同一时间只有一个线程能获取锁
- 多个线程如果尝试获取一个锁（未被锁上），那么只有一个能如愿
下面以生产者，消费者举个栗子：
Lock *l;
Semaphore *full;
Semaphore *empty;
void main() {
l = new Lock(“l”);
empty = new Semaphore("e", N);
full = new Semaphore("f", 0);
Thread *t = new Thread("c");
t->Fork(consumer, 1);
t = new Thread("p");
t->Fork(producer, 1);
}
void consumer (int dummy) {
while (1) {
full->P();
l->Acquire();
consume the next unit of data
l->Release();
empty->V();
}}
void producer (int dummy) {
while (1) {
empty->P();
l->Acquire();
produce the next unit of data
l->Release();
full->V();
}}
还是从下面几点说起
- 红色部分：要注意的是后面不再是1，取而代之的是N与0，这个N的意思是生产者生产产品的上限是N个，超出N便无法生产，他的实现方法在绿色部分
- 绿色部分：利用'l'代替了前面semaphore功能，它利用上锁与开锁巧妙地使只有一个线程能访问核心数据，这个full是再补充几件货，就达到货满，empty是有多少空闲的位置
条件变量
何为条件变量？
说白了，就是为lock附加几个功能，让他更便利
class Condition {
public:
Condition(char* debugName);
~Condition();
void Wait(Lock *conditionLock);
void Signal(Lock *conditionLock);
void Broadcast(Lock *conditionLock);
}
- Condition(name) : creates a condition variable.
- Wait(Lock *l) : Atomically releases the lock and waits. When Wait returns the lock will have been reacquired.
- Signal(Lock *l) : Atomically enables one of the waiting threads to run. When Signal returns the lock is still acquired.
- Broadcast(Lock *l) : Atomically enables all of the waiting threads to run. When Broadcast returns the lock is still acquired.
依旧对上述消费者，生产者进行改装
void consumer(int dummy) {
while (1) {
l->Acquire();
if (avail == 0) {
c->Wait(l);
}
consume the next unit of data
avail--;
l->Release();
}}
void producer(int dummy) {
while (1) {
l->Acquire();
produce the next unit of data
avail++;
c->Signal(l);
l->Release();
}}
要注意的是，这里我加入了wait和signal，为什么要加入wait呢？
因为如果此时没有产品，如果有多个消费者，那么他们会停留在Acquire状态，此时生产出一个产品，消费者A把产品消费了，然后消费者A执行了l->release()，这就尴尬了，这个release完全可以使消费者B的requice满足条件，但是此时并没有产品，于是乎wait完美地解决了这个问题
接下来我们再来讨论这个signal()的两种方式：
- Hoare condition variables：当执行signal时，下一个正在wait的线程继续执行
- Mesa condition variables：当执行signal时，随机一个正在wait的线程继续执行
这两位大佬引发的血案：依旧拿上面的程序说事，此时仓库为0，消费者A要消费，没有东西，自然要wait，生产者生产了一个产品后，signal消费者A，但此时消费者B抢走了产品，于是消费者A自然而然消费了空的东西，导致了错误
那么如何解决上述问题呢，其实很简单，把if(avail==0)换成while(avail==0)不就得了，这样消费者A会一直检测仓库是否为空
至于这个Broadcast，俗称广播，给的也不是没有道理，比如你做一个内存分配管理软件，1kb的小内存分出去10000个，如果我想要一个1m的，这时就要用到broadcase，哪个wait满足条件，就释放谁，不用排队