信号量控制线程顺序

之前面试问过的一个问题

多线程并发下，怎么让线程按照顺序执行

答案是用信号量，当然是在线程不多的情况，每个线程分配一个信号量，然后在前面的线程先获取自己的信号量，结束后释放下一个线程的信号量，从而达到有序

#include <iostream>
#include <semaphore.h>  // semaphore/seməfɔːr/
#include <thread>


//信号量的主要函数有:


/*
 * 函数名：sem_init()
 * 功能：对指定信号初始化
 * 参数1：*sem：信号，
 * 参数2：pshared=0时，信号在当前进程的多个线程之间共享
 * 参数3：unsigned
 * 参数4：value表示初始化信号的值
 * int sem_init(sem_t *sem,int pshared,unsigned int value);
 */


/*
 * 函数名：sem_wait()
 * 功能：阻塞当前进程，直到信号量的值大于0，解除阻塞，
 *      解除阻塞后sem的值-1表示公共资源执行减少了,例
 *      如：如果你对一个值为2的信号量调用sem_wait(),
 *      线程将会继续执行，信号量的值将-1。当初始化
 *      value=0后，使用sem_wai会阻塞这个线程，这个
 *      线程函数就会等待其它线程函数调用sem_post增加
 *      了了这个值使它不再是0，才开始执行,然后value值-1。
 * 参数：*sem
 * int sem_wait(sem_t *sem);
 */


/*
 * 函数名：sem_post(sem_t *sem);
 * 功能：增加信号量的值+1，当有线程阻塞在这个信号量上时，
 *      调用这个函数会使其中的一个线程不再阻塞，选择机制
 *      由线程的调度策略决定
 * 参数：*sem
 * int sem_post(sem_t *sem);
 */
sem_t sem,sem1,sem2;


void* thread_a(){
    LOOP:
    sem_wait(&sem2);
    cout<<"thread_a running"<<endl;
    sem_post(&sem);
    sleep(1);
    goto LOOP;
}


void* thread_b(){
    LOOP:
    sem_wait(&sem);
    cout<<"thread_b running"<<endl;
    sem_post(&sem1);
    sleep(1);
    goto LOOP;
}


void* thread_c(){
    LOOP:
    sem_wait(&sem1);
    cout<<"thread_c running"<<endl;
    sem_post(&sem2);
    sleep(1);
    goto LOOP;
}


int main(void){
    sem_init(&sem,0,1);
    sem_init(&sem1,0,0);
    sem_init(&sem2,0,0);

    thread th1(thread_a);
    thread th2(thread_b);
    thread th3(thread_c);

    th1.join();
    th2.join();
    th3.join();

    return 0;
}