C++多线程习题：非原创增加注释（03）

模型描述：

1：四个线程1、2、3、4
2：四个空文件a、b、c、d
3：线程1的功能就是输出1；线程2的功能就是输出2，以此类推。

目标：让线程以下面的格式写文件

a: 1 2 3 4 1 2...
b: 2 3 4 1 2 3...
c: 3 4 1 2 3 4...
d: 4 1 2 3 4 1...

#include <mutex>
#include <thread>
#include <condition_variable>
#include <fstream>
#include <iostream>

std::condition_variable cv;
std::mutex mtx;

int vis[] = {4, 1, 2, 3};

std::ofstream f1("a.txt");
std::ofstream f2("b.txt");
std::ofstream f3("c.txt");
std::ofstream f4("d.txt");

std::ofstream *files[4] = { &f1, &f2, &f3, &f4 };

void solve(const int id, int count)
{
    while (count--)
    {
        for (int i = 0; i < 4; i++)
        {
            std::unique_lock<std::mutex> lk(mtx);

            if (id == 1)
            {
                cv.wait(lk, [&]{ return vis[i] == 4; });
                (*files[i]) << 1;
                vis[i] = 1;
                char buf[32];
                sprintf_s(buf, "t%d vis[%d]=%d\n", id, i, vis[i]);
                std::cout << buf;
                lk.unlock();
                cv.notify_all();
            }
            else if (id == 2)
            {
                cv.wait(lk, [&] { return vis[i] == 1; });
                (*files[i]) << 2;
                vis[i] = 2;
                char buf[32];
                sprintf_s(buf, "t%d vis[%d]=%d\n", id, i, vis[i]);
                std::cout << buf;
                lk.unlock();
                cv.notify_all();
            }
            else if (id == 3)
            {
                // 分支完后i++成为3
                cv.wait(lk, [&] { return vis[i] == 2; });
                (*files[i]) << 3;
                vis[i] = 3;
                char buf[32];
                sprintf_s(buf, "t%d vis[%d]=%d\n", id, i, vis[i]);
                std::cout << buf;
                lk.unlock();
                cv.notify_all();
            }
            else if (id == 4)
            {
                cv.wait(lk, [&] { return vis[i] == 3; });
                (*files[i]) << 4;
                vis[i] = 4;
                char buf[32];
                sprintf_s(buf, "t%d vis[%d]=%d\n", id, i, vis[i]);
                std::cout << buf;
                lk.unlock();
                cv.notify_all();
            }
        }
    }
}

int main()
{
    std::thread t1(solve, 1, 2);
    std::thread t2(solve, 2, 2);
    std::thread t3(solve, 3, 2);
    solve(4, 2);

    t1.join();
    t2.join();
    t3.join();

    for (int i = 0; i < 4; i++)
        files[i]->close();

    return 0;
}

瞅了第一眼之后，你可能和我一样，想通过函数把核心实现重构一下。
不过，这个可能比你重构后的代码更易读 😃

在分析程序前，我们需要知道两点：

1. 每个线程的栈空间中，都有一个独立的计数索引i。
2. 数组vis的中的值，表示各个线程上次写完的值。

程序启动后，整体状态如下，其中file一栏表示文件的内容，初始为空。

   |  i    vis[i]    file
---+-----------------------------------
t1 |  0     [4]
t2 |  0     [4]
t3 |  0     [4]
t4 |  0     [4]

在首次启动后
假如t2被唤起，t2等待vis[i]==1，而 i==0, vis[0]=4，等待条件不成立…
假如t3被唤起，t3等待vis[i]==2，而 i==0, vis[0]=4，等待条件不成立…
假如t4被唤起，t4等待vis[i]==3，而 i==0, vis[0]=4，等待条件不成立…
假如t1被唤起，t1等待vis[i]==4，而 i==0, vis[0]=4，等待条件【成立】

在t1执行后，vis[0]被更新为1，此时：vis[4] = [1, 1, 2, 3]，状态更新后如下：

   |  i      file
---+---------------------------
t1 |  1      "1"
t2 |  0
t3 |  0
t4 |  0

线程t1的cv.notify_all()发出通知，让所有等待的线程有机会获得激活。
假设t1再次被激活，等待条件vis[1]==1不满足，因此进入等待状态，
t2/t3/t4的索引计数都是0，但t3/t4同t1一样，不满足等待条件，
唯独t2的等待条件vis[0]==1成立，因此t2被激活，
注意：在t2执行时，其计数索引i为0，files[i]就是文件a。

在t2执行后，vis[0]被更新为2，此时：vis[4] = [2, 1, 2, 3]，状态更新后如下：

   |  i      file
---+---------------------------
t1 |  1      "12"
t2 |  1
t3 |  0
t4 |  0

接下来，流程跟上面类似：
假如t1被唤起，i==1, vis[1]==1，等待条件不成立…
假如t4被唤起，i==0, vis[0]==2，等待条件不成立…
假如t3被唤起，i==0, vis[0]==2，等待条件成立，i是0，对应的文件是fa，写入"3"
假如t2被唤起，i==1, vis[1]==1，等待条件成立，i是1，对应的文件是fb，写入"1"

在t2与t3执行后，状态如下：vis[4] = [3, 2, 3, 3]

   |  i      file
---+---------------------------
t1 |  1      "123"
t2 |  2      "2"
t3 |  1
t4 |  0

后面就是继续重复上面的过程。