C++ 多线程按顺序执行函数

我们提供了一个类：

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() 方法之后被执行。

法一：信号量

#include <semaphore.h>
class Foo {
private:
    sem_t firstDone;
    sem_t secondDone;
public:
    Foo() {
        sem_init(&firstDone,0,0);
        sem_init(&secondDone,0,0);
    }

    void first(function<void()> printFirst) {
        
        // printFirst() outputs "first". Do not change or remove this line.
        printFirst();
        sem_post(&firstDone);
    }

    void second(function<void()> printSecond) {
        sem_wait(&firstDone);
        // printSecond() outputs "second". Do not change or remove this line.
        printSecond();
        sem_post(&secondDone);
    }

    void third(function<void()> printThird) {
        sem_wait(&secondDone);
        // printThird() outputs "third". Do not change or remove this line.
        printThird();
    }
};

互斥锁：mutex

#include <semaphore.h>
class Foo {
private:
    mutex mtx1;
    mutex mtx2;
public:
    Foo() {
        mtx1.lock();
        mtx2.lock();
    }

    void first(function<void()> printFirst) {
        
        // printFirst() outputs "first". Do not change or remove this line.
        printFirst();
        mtx1.unlock();
    }

    void second(function<void()> printSecond) {
        mtx1.lock();
        // printSecond() outputs "second". Do not change or remove this line.
        printSecond();
        mtx1.unlock();
        mtx2.unlock();
    }

    void third(function<void()> printThird) {
        mtx2.lock();
        // printThird() outputs "third". Do not change or remove this line.
        printThird();
        mtx2.unlock();
    }
};

RAII lock_guard, unique_lock

#include <semaphore.h>
class Foo {
private:
    mutex mtx1;
    mutex mtx2;
    unique_lock<mutex> m1lock,m2lock;
public:
    Foo() :m1lock(mtx1,try_to_lock),m2lock(mtx2,try_to_lock){
        
    }

    void first(function<void()> printFirst) {
        
        // printFirst() outputs "first". Do not change or remove this line.
        printFirst();
        m1lock.unlock();
    }

    void second(function<void()> printSecond) {
        lock_guard<mutex> guard(mtx1);
        // printSecond() outputs "second". Do not change or remove this line.
        printSecond();
        m2lock.unlock();
    }

    void third(function<void()> printThird) {
        lock_guard<mutex> guard(mtx2);
        // printThird() outputs "third". Do not change or remove this line.
        printThird();
    }
};

条件变量

#include <semaphore.h>
class Foo {
private:
    condition_variable cv;
    mutex mtx;
    int k;
public:
    Foo() {
        k = 0;
    }

    void first(function<void()> printFirst) {
        printFirst();
        k = 1;
        cv.notify_all();
    }

    void second(function<void()> printSecond) {
        unique_lock<mutex> lock(mtx);
        cv.wait(lock,[this](){return k==1;});
        printSecond();
        k=2;
        cv.notify_one();
    }

    void third(function<void()> printThird) {
        unique_lock<mutex> lock(mtx);
        cv.wait(lock,[this](){return k==2;});
        printThird();
    }
};

原子操作

异步操作

class Foo {
    promise<void> pro1,pro2;
public:
    Foo() {
        
    }

    void first(function<void()> printFirst) {
        printFirst();
        pro1.set_value();
    }

    void second(function<void()> printSecond) {
        pro1.get_future().wait();
        printSecond();
        pro2.set_value();
    }

    void third(function<void()> printThird) {
        pro2.get_future().wait();
        printThird();
    }
};

博客地址：www.orzlinux.cn