多线程同步

两个线程，一个线程打印字母（从A到Z），一个线程打印数组（从1到26），要求交替打印，如：1A2B3C？

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

using  namespace std;

class print
{
public:
    print();
    
    // 初始化列表：用于在构造函数中直接初始化成员变量。
    // 常量成员和引用成员必须通过初始化列表初始化。
    // 对于自定义类型的成员，如果自定义类型没有默认构造函数，也必须使用初始化列表。
    print(int n):start(n) {};
    ~print();
    
    void printAlphabets();
    void printNumbers(int num);

private:
    static mutex mtx;
    static condition_variable cv;
    static bool printAlphabrt;
    int start;
};

// 静态成员变量属于类本身，而不是某个特定对象，因此不能在构造函数的初始化列表中初始化。
// 静态成员变量必须在类定义外进行定义和初始化。
// 使用类名可以访问和修改静态成员变量，而不需要创建对象实例。
std::mutex print::mtx;
bool print::printAlphabrt = true;
condition_variable print::cv;

print::print()
{
    
}

print::~print()
{
    
}

void print::printAlphabets()
{
    for(char c = 'A';c <= 'Z';++c)
    {
        // 使用 std::mutex 和 std::lock_guard 确保线程安全
        unique_lock<mutex> lock(mtx);
        cv.wait(lock,[]{return !printAlphabrt;});
        cout << c;
        printAlphabrt = true;
        cv.notify_one();
    }
}

void print::printNumbers(int num)
{
    cout << start;
    for(int c = 1;c <= num;++c)
    {
        unique_lock<mutex> lock(mtx);
        cv.wait(lock,[]{return printAlphabrt;});
        cout << c;
        printAlphabrt = false;
        cv.notify_one();
    }
}

int main(void)
{
    print printvalue(0);
    int n = 26;
    
    // 非静态成员函数需要通过对象实例进行调用，不能直接绑定到 std::thread。
    // 使用 std::bind 或 lambda 表达式可以将成员函数正确绑定到线程。
    thread t1(bind(&print::printAlphabets,&printvalue));
    
    // 使用lambda表达式或std::thread构造函数，可以方便地向线程中的成员函数传递参数。
    // 捕获列表用于捕获外部变量，以便在lambda表达式中使用。
    thread t2([&printvalue,n](){printvalue.printNumbers(n);});
    
    // thread t2(bind(&print::printNumbers,&printvalue));
    
    t1.join();
    t2.join();
    
    return 1;
}

运行结果