假设有这么一个类：

class ZeroEvenOdd {
  public ZeroEvenOdd(int n) { ... }      // 构造函数
  public void zero(printNumber) { ... }  // 仅打印出 0
  public void even(printNumber) { ... }  // 仅打印出 偶数
  public void odd(printNumber) { ... }   // 仅打印出 奇数
}

相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：

1. 线程 A 将调用 zero()，它只输出 0 。
2. 线程 B 将调用 even()，它只输出偶数。
3. 线程 C 将调用 odd()，它只输出奇数。

每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506… ，其中序列的长度必须为 2n。

示例 1：

输入：n = 2
输出："0102"
说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 "0102"。

示例 2：

输入：n = 5
输出："0102030405"

Solution

参考：[LeetCode官方]

• 用三个互斥锁控制打印0，奇数，偶数的顺序。每把锁控制一种打印。

class ZeroEvenOdd {
private:
    int n;
    std::mutex mtx1;    // 0
    std::mutex mtx2;    // 偶数
    std::mutex mtx3;    // 奇数

public:
    ZeroEvenOdd(int n) {
        this->n = n;
        mtx2.lock();
        mtx3.lock();
    }

    // printNumber(x) outputs "x", where x is an integer.
    void zero(function<void(int)> printNumber) {
        for (int i = 1; i <= n; ++i) {
            mtx1.lock();
            printNumber(0);
            if (i & 1) mtx3.unlock();
            else mtx2.unlock();
        }
    }

    void even(function<void(int)> printNumber) {
        for (int i = 2; i <= n; i+=2) {
            mtx2.lock();
            printNumber(i);
            mtx1.unlock();
        }
    }

    void odd(function<void(int)> printNumber) {
        for (int i = 1; i <= n; i+=2) {
            mtx3.lock();
            printNumber(i);
            mtx1.unlock();
        }
    }
};

• 条件变量 + 互斥量，布尔量 ze && other 有三种状态

class ZeroEvenOdd {
private:
    int n;
    std::condition_variable cv;
    std::mutex mtx;
    bool ze, other;

public:
    ZeroEvenOdd(int n) {
        this->n = n;
        ze = false;
        other = true;
    }

    // printNumber(x) outputs "x", where x is an integer.
    void zero(function<void(int)> printNumber) {
        for (int i = 1; i <= n; ++i) {
            std::unique_lock<std::mutex> lk(mtx);
            cv.wait(lk, [=](){ return !ze && other; });
            printNumber(0);
            if (i & 1) ze = true;
            else other = false;
            cv.notify_all();
        }
    }

    void even(function<void(int)> printNumber) {
        for (int i = 2; i <= n; i+=2) {
            std::unique_lock<std::mutex> lk(mtx);
            cv.wait(lk, [=](){ return !ze && !other; });
            printNumber(i);
            ze = false;
            other = true;
            cv.notify_all();
        }
    }

    void odd(function<void(int)> printNumber) {
        for (int i = 1; i <= n; i+=2) {
            std::unique_lock<std::mutex> lk(mtx);
            cv.wait(lk, [=](){ return ze && other; });
            printNumber(i);
            ze = false;
            cv.notify_all();
        }
    }
};