C++中的信号量使用

Linux环境中的semaphore使用

定义信号量

Linux下信号量的数据结构体为：sem_t。它本质上是一个长整型的数。

1
2
sem_t firstSemaphore;
sem_t secondSemaphore;

利用sem_init()函数进行初始化

sem_init() 初始化一个定位在 sem 的匿名信号量。它的函数原型如下。

1
2
3
#include <semaphore.h>
// 初始化
int sem_init(sem_t *sem,int pshared,unsigned int value);

  • pshared 参数指明信号量是由进程内线程共享，还是由进程之间共享。如果 pshared 的值为 0，那么信号量将被进程内的线程共享，并且应该放置在这个进程的所有线程都可见的地址上(如全局变量，或者堆上动态分配的变量)。

  • value 参数指定信号量的初始值。

  • sem_init() 成功时返回 0；错误时，返回 -1，并把 errno 设置为合适的值。

信号量加减操作

函数sem_post( sem_t *sem )用来增加信号量的值。当有线程阻塞在这个信号量上时，调用这个函数会使其中的一个线程不再阻塞，选择机制同样是由线程的调度策略决定的。sem_post() 成功时返回 0；错误时，信号量的值没有更改，-1被返回，并设置errno来指明错误。错误EINVAL sem不是一个有效的信号量。EOVERFLOW信号量允许的最大值将要被超过。

1
int sem_post(sem_t *sem);  // 信号量增加1

函数sem_wait( sem_t *sem )被用来阻塞当前线程直到信号量sem的值大于0，解除阻塞后将sem的值减一，表明公共资源经使用后减少。

1
int sem_wait(sem_t *sem);  // 信号量减少1

函数sem_trywait ( sem_t *sem )是函数sem_wait（）的非阻塞版本，它直接将信号量sem的值减一。在成功完成之后会返回零。其他任何返回值都表示出现了错误。

1
int sem_trywait(sem_t *sem);

信号量其他操作

函数sem_destroy(sem_t *sem)用来释放信号量sem，属于无名信号量。在清理信号量的时候如果还有线程在等待它，用户就会收到一个错误。与其它的函数一样，这些函数在成功时都返回0。

1
int sem_destroy(sem_t *sem);

函数sem_getvalue(sem_t *sem)用来获取当前信号量的值。

1
int sem_getvalue(sem_t *sem);

线程同步实例

我们提供了一个类：

public class Foo {
public void first() { print(“first”); }
public void second() { print(“second”); }
public void third() { print(“third”); }
}
三个不同的线程 A、B、C 将会共用一个 Foo 实例。

一个将会调用 first() 方法
一个将会调用 second() 方法
还有一个将会调用 third() 方法
请设计修改程序，以确保 second() 方法在 first() 方法之后被执行，third() 方法在 second() 方法之后被执行。

示例 1:

输入: [1,2,3]
输出: “firstsecondthird”
解释:
有三个线程会被异步启动。
输入 [1,2,3] 表示线程 A 将会调用 first() 方法，线程 B 将会调用 second() 方法，线程 C 将会调用 third() 方法。
正确的输出是 “firstsecondthird”。
示例 2:

输入: [1,3,2]
输出: “firstsecondthird”
解释:
输入 [1,3,2] 表示线程 A 将会调用 first() 方法，线程 B 将会调用 third() 方法，线程 C 将会调用 second() 方法。
正确的输出是 “firstsecondthird”。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <semaphore.h>
class Foo {
protected:
    //定义信号量
    sem_t firstJobDone;
    sem_t secondJobDone;
public:
    Foo() {
        //在constructor中初始化信号量
        sem_init(&firstJobDone,0,0);
        sem_init(&secondJobDone,0,0);
    }

    void first(function<void()> printFirst) {
        
        // printFirst() outputs "first". Do not change or remove this line.
        printFirst();
        //信号量firstJobDone加一
        sem_post(&firstJobDone);
    }

    void second(function<void()> printSecond) {
        
        // printSecond() outputs "second". Do not change or remove this line.
        //信号量firstJobDone减一
        sem_wait(&firstJobDone);
        printSecond();
        //信号量secondJobDone加一
        sem_post(&secondJobDone);
    }

    void third(function<void()> printThird) {
        
        // printThird() outputs "third". Do not change or remove this line.
        //信号量secondJobDone减一
        sem_wait(&secondJobDone);
        printThird();
    }
};

在C++中自己实现semaphore

标准C++中没有实现自己的信号量机制，需要借助外部库或者自己实现。

下面的代码使用std::unique_lock和std::mutex实现了信号量机制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <mutex>
#include <condition_variable>
using namespace std;
class Semaphore{
public:
    Semaphore(int count = 0):count_(count){
    }
    void set(int count){
        count_ = count;
    }
    void signal(){
        unique_lock<mutex> lck(mutex_);
        ++count;
        cv_.notify_one();
    }
    void wait(){
        unique_lock<mutux> lck(mutex_);
        while(count<=0){
			cv_.wait(lock);	
        }
        --count;
    }
    
private:
	mutex mutex_;
    condition_variable cv_
    int count_;
};

经典的哲学家就餐问题

五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在桌子上有五只碗和五只筷子，他们的生活方式是交替地进行思考和进餐。平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。进餐毕，放下筷子继续思考。

哲学家从 0 到 4 按 顺时针 编号。请实现函数 void wantsToEat(philosopher, pickLeftFork, pickRightFork, eat, putLeftFork, putRightFork)：

  • philosopher 哲学家的编号。
  • pickLeftFork 和 pickRightFork 表示拿起左边或右边的叉子。
  • eat 表示吃面。
  • putLeftFork 和 putRightFork 表示放下左边或右边的叉子。
  • 由于哲学家不是在吃面就是在想着啥时候吃面，所以思考这个方法没有对应的回调。

三种策略实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include <semaphore.h>
class DiningPhilosophers {
private:
    sem_t count;
    sem_t forks[5];
    sem_t mutex;
public:
    DiningPhilosophers() {
        sem_init(&count,0,4);
        sem_init(&mutex,0,1);
        for(int i=0;i<5;++i){
            sem_init(forks+i,0,1);
        }
    }

    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {
		/*
        //解法一：最多只允许四个哲学家同时进餐
        int left = philosopher;
        int right = (philosopher+1)%5;
        sem_wait(&count);
        sem_wait(forks+left);
        sem_wait(forks+right);
        pickLeftFork();
        pickRightFork();
        eat();
        putLeftFork();
        putRightFork();
        sem_post(forks+right);
        sem_post(forks+left);
        sem_post(&count);
        */

        /*
        //解法二：同时拿起左右筷子
        int left = philosopher;
        int right = (philosopher+1)%5;
        sem_wait(&mutex);
        sem_wait(forks+left);
        sem_wait(forks+right);
        pickLeftFork();
        pickRightFork();
        sem_post(&mutex);
        eat();
        putLeftFork();
        putRightFork();
        sem_post(forks+left);
        sem_post(forks+right);
        */

        /*
        //解法三：奇数拿左，偶数拿右
        int left = philosopher;
        int right = (philosopher+1)%5;
        if(philosopher%2==1){
            sem_wait(forks+left);
            sem_wait(forks+right);
            pickLeftFork();
            pickRightFork();
            eat();
            putRightFork();
            putLeftFork();
            sem_post(forks+right);
            sem_post(forks+left);
        }
        else {
            sem_wait(forks+right);
            sem_wait(forks+left);
            pickRightFork();
            pickLeftFork();
            eat();
            putLeftFork();
            putRightFork();
            sem_post(forks+left);
            sem_post(forks+right);
        }
        */
    }
};

使用条件变量condition_variable

condition_variable介绍

在C++11中，我们可以使用条件变量（condition_variable）实现多个线程间的同步操作；当条件不满足时，相关线程被一直阻塞，直到某种条件出现，这些线程才会被唤醒。

成员函数如下：

在这里插入图片描述

条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：

  1. 一个线程因等待”条件变量的条件成立”而挂起；
  2. 另外一个线程使”条件成立”，给出信号，从而唤醒被等待的线程。

在条件变量中只能使用std::unique_lock<std::mutex>

wait/wait_for函数

1
2
3
4
void wait( std::unique_lock<std::mutex>& lock );
//Predicate 谓词函数，可以普通函数或者lambda表达式
template< class Predicate >
void wait( std::unique_lock<std::mutex>& lock, Predicate pred );

wait 导致当前线程阻塞直至条件变量被通知，或虚假唤醒发生，可选地循环直至满足某谓词。

1
2
3
4
5
6
7
8
template< class Rep, class Period >
std::cv_status wait_for( std::unique_lock<std::mutex>& lock,
                         const std::chrono::duration<Rep, Period>& rel_time);
                         
template< class Rep, class Period, class Predicate >
bool wait_for( std::unique_lock<std::mutex>& lock,
               const std::chrono::duration<Rep, Period>& rel_time,
               Predicate pred);

wait_for 导致当前线程阻塞直至条件变量被通知，或虚假唤醒发生，或者超时返回。

由于系统存在虚假唤醒的情况，一般这样使用wait()函数：

1
2
3
4
5
while (!pred()){	 //while循环，解决了虚假唤醒的问题
    //虚假唤醒发生，由于while循环，再次检查条件是否满足，
    //否则继续等待，解决虚假唤醒
    wait(lock);
}

该方法和下述方法等价。

1
wait(lock,pred());

notify_all/notify_one

1
2
3
4
5
void notify_one() noexcept;
若任何线程在 *this 上等待，则调用 notify_one 会解阻塞(唤醒)等待线程之一。

void notify_all() noexcept;
若任何线程在 *this 上等待，则解阻塞（唤醒)全部等待线程。

使用条件变量完成同步实例

我们提供一个类：

class FooBar {
public void foo() {
for (int i = 0; i < n; i++) {
print(“foo”);
}
}

public void bar() {
for (int i = 0; i < n; i++) {
print(“bar”);
}
}
}
两个不同的线程将会共用一个 FooBar 实例。其中一个线程将会调用 foo() 方法，另一个线程将会调用 bar() 方法。

请设计修改程序，以确保 “foobar” 被输出 n 次。

示例 1:

输入: n = 1
输出: “foobar”
解释: 这里有两个线程被异步启动。其中一个调用 foo() 方法, 另一个调用 bar() 方法，”foobar” 将被输出一次。
示例 2:

输入: n = 2
输出: “foobarfoobar”
解释: “foobar” 将被输出两次。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class FooBar {
private:
    int n;
    mutex mutex_;
    condition_variable cv_;
    bool fooDone = false;
public:
    FooBar(int n) {
        this->n = n;
    }

    void foo(function<void()> printFoo) {
        for (int i = 0; i < n; i++) {
            unique_lock<mutex> lck(mutex_);
            cv_.wait(lck,[&](){return !fooDone;});
        	// printFoo() outputs "foo". Do not change or remove this line.
        	printFoo();
            fooDone = true;
            cv_.notify_one();
        }
    }

    void bar(function<void()> printBar) {    
        for (int i = 0; i < n; i++) {
            unique_lock<mutex> lck(mutex_);
            cv_.wait(lck,[&](){return fooDone;});
        	// printBar() outputs "bar". Do not change or remove this line.
        	printBar();
            fooDone = false;
            cv_.notify_one();
        }
    }
};
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

武汉大学研究生在读<br><br>喜爱电影、摄影和健身运动<br>希望能和你相识！ <br><br>宠辱不惊，闲看庭前花开花落；<br>去留无意，漫随天外云卷云舒。