【3】c++多线程技术之线程同步与互斥

1、线程安全问题与数据竞争

线程安全问题与数据竞争是多线程编程中的重要概念。在C++中，线程安全问题主要涉及到多个线程对共享数据的访问，如果多个线程同时访问同一块内存区域，并且至少有一个线程对该区域进行写入操作，那么就可能发生数据竞争（Data Race）。数据竞争可能导致程序行为不可预测，甚至可能引发严重的错误。为了避免数据竞争，我们需要使用一些同步机制，如互斥锁（Mutex）和条件变量（Condition Variable）等。下面是一个简单的例子，展示了如何使用C++的std::mutex来避免数据竞争：

#include <thread>
#include <iostream>
#include <mutex>
// 定义一个全局的互斥锁
std::mutex mtx;
void print_block(int n, char c) {
    // 使用std::lock_guard自动管理锁的生命周期
    std::lock_guard<std::mutex> guard(mtx);
    for (int i=0; i<n; ++i) { 
        std::cout << c; 
    }
    std::cout << ' ';
}
int main() {
    std::thread th1(print_block,50,'*');
    std::thread th2(print_block,50,'$');
    th1.join();
    th2.join();
    return 0;
}

在这个例子中，我们创建了两个线程，它们都试图在同一时间向标准输出流写入数据。如果我们不使用互斥锁，那么这两个线程可能会同时写入数据，导致输出结果混乱。通过使用互斥锁，我们可以确保在任何时刻只有一个线程能够写入数据，从而避免了数据竞争。

2、互斥锁（std::mutex）

互斥锁（std::mutex）是C++标准库中提供的一种同步原语，用于保护共享资源在多线程环境下的访问。当多个线程需要同时访问同一个共享资源时，为了避免数据竞争和不一致的情况，可以使用互斥锁来确保在同一时刻只有一个线程能够访问该资源。下面是一个简单的示例代码，演示了如何使用std::mutex来保护共享资源的访问：

#include <iostream>
#include <thread>
#include <mutex>
// 共享资源
int shared_resource = 0;
// 互斥锁
std::mutex mtx;
// 线程函数
void threadFunction() {
    for (int i = 0; i < 100000; ++i) {
        // 加锁
        mtx.lock();
	    // 访问共享资源
        shared_resource++;        
        // 解锁
        mtx.unlock();
    }
}
int main() {
    // 创建两个线程
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    // 等待线程执行完毕
    t1.join();
    t2.join();
    // 输出共享资源的值
    std::cout << "Shared resource value: " << shared_resource << std::endl;
    return 0;
}

在上面的代码中，我们定义了一个全局变量shared_resource作为共享资源，并使用std::mutex对象mtx来保护对该资源的访问。在threadFunction函数中，我们通过调用mtx.lock()来获取互斥锁，然后对共享资源进行操作，最后调用mtx.unlock()释放互斥锁。在main函数中，我们创建了两个线程t1和t2，它们都执行相同的threadFunction函数。由于我们使用了互斥锁来保护共享资源的访问，因此即使两个线程并发执行，它们也会依次获得互斥锁，从而保证了对共享资源的互斥访问。最后，我们在主线程中等待两个子线程执行完毕后，输出共享资源的最终值。由于每个线程都会对共享资源进行100000次递增操作，所以最终的结果应该是200000。

3、std::lock_guard的使用

std::lock_guard是C++标准库中的一个类模板，用于简化互斥量的使用。它提供了一种RAII（资源获取即初始化）的方式来管理互斥量，确保在作用域结束时自动释放锁，从而避免死锁和资源泄露。

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mtx; // 定义一个互斥量
int counter = 0; // 定义一个共享资源

void increment() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 创建一个lock_guard对象，自动加锁
        ++counter; // 访问共享资源
        // 当lock_guard对象离开作用域时，析构函数会自动解锁
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

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

    std::cout << "Counter: " << counter << std::endl;

    return 0;
}

在这个示例中，我们定义了一个互斥量mtx和一个共享资源counter。我们创建了两个线程t1和t2，它们都执行increment函数。在increment函数中，我们使用std::lock_guard来管理互斥量，确保在同一时刻只有一个线程可以访问共享资源。当我们创建std::lock_guard对象时，它会自动加锁互斥量。当lock_guard对象离开作用域时，它的析构函数会自动解锁互斥量。这样可以确保在发生异常或提前返回时，互斥量仍然会被正确解锁，避免了死锁和资源泄露的问题。总之，std::lock_guard是一个非常实用的工具，可以帮助我们简化互斥量的使用，提高代码的安全性和可维护性。

4、死锁问题与避免策略

死锁问题是指在多线程编程中，两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象。当每个线程都在等待其他线程释放资源时，就会发生死锁。避免死锁的策略主要有以下几种：

• 避免循环等待：确保系统中的资源按照某种顺序获取，这样可以避免死锁。例如，如果有两个资源A和B，那么所有的线程都应该按照相同的顺序来请求这两个资源。
• 使用锁的超时机制：当一个线程尝试获取锁失败时，它可以选择等待一段时间，而不是立即失败。如果在这段时间内能够获取到锁，那么就继续执行；否则，就放弃并报告错误。
• 检测死锁并进行恢复：可以通过定期检查系统状态来检测死锁。一旦检测到死锁，就可以采取一些措施来恢复，例如终止一些线程，或者回滚一些操作。

下面是一个简单的C++代码示例，展示了如何使用std::lock函数来避免死锁。这个函数可以一次锁定两个或更多的互斥量，而且不会引发死锁。

#include <mutex>
#include <thread>

std::mutex mutex1, mutex2;

void thread_func() {
    // 使用std::lock函数一次性锁定两个互斥量
    std::lock(mutex1, mutex2);
    // 使用std::lock_guard来保证在函数退出时解锁
    std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
    std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);
    // 在这里，我们可以安全地访问共享资源
}

int main() {
    std::thread t1(thread_func);
    std::thread t2(thread_func);
    t1.join();
    t2.join();
    return 0;
}

5、递归互斥量（std::recursive_mutex）

递归互斥量（std::recursive_mutex）是C++标准库中的一种同步原语，用于保护共享资源的访问。它允许同一个线程多次获取锁，而不会导致死锁。这种特性使得递归互斥量在需要在同一线程中多次锁定和解锁的情况下非常有用。

下面是一个使用std::recursive_mutex的示例代码：

#include <iostream>
#include <mutex>
#include <thread>

std::recursive_mutex mtx; // 定义一个递归互斥量
int counter = 0; // 共享资源

void recursive_function(int n) {
    if (n <= 0) {
        return;
    }

    mtx.lock(); // 加锁
    counter++; // 访问共享资源
    std::cout << "Counter: " << counter << std::endl;
    mtx.unlock(); // 解锁

    recursive_function(n - 1); // 递归调用

    mtx.lock(); // 再次加锁
    counter--; // 访问共享资源
    std::cout << "Counter: " << counter << std::endl;
    mtx.unlock(); // 解锁
}

int main() {
    std::thread t1(recursive_function, 5); // 创建线程t1并传入参数5
    std::thread t2(recursive_function, 3); // 创建线程t2并传入参数3

    t1.join(); // 等待线程t1结束
    t2.join(); // 等待线程t2结束

    return 0;
}

在这个示例中，我们定义了一个递归函数recursive_function，它接受一个整数参数n。在函数内部，我们使用std::recursive_mutex来保护对共享资源counter的访问。当n大于0时，函数会递归地调用自身，每次调用都会对counter进行加一操作，并在控制台输出当前的counter值。然后，函数会再次对counter进行减一操作，并在控制台输出当前的counter值。

在main函数中，我们创建了两个线程t1和t2，分别传入参数5和3。这两个线程将并发地执行recursive_function函数。由于我们使用了std::recursive_mutex来保护对counter的访问，所以这些线程可以安全地同时访问共享资源，而不会导致数据竞争或死锁。

6、条件变量（std::condition_variable）

条件变量（std::condition_variable）是C++标准库中的一个同步原语，用于在多线程环境中实现线程间的等待和通知机制。它通常与互斥锁（std::mutex）一起使用，以确保在多个线程之间正确地同步对共享资源的访问。下面是一个使用条件变量的简单示例：

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

std::mutex mtx; // 互斥锁
std::condition_variable cv; // 条件变量
bool ready = false; // 标志位，表示数据是否准备好

void print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx); // 加锁
    while (!ready) { // 如果数据未准备好，则等待
        cv.wait(lck); // 等待条件变量的通知
    }
    // 数据已准备好，打印线程ID
    std::cout << "thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lck(mtx); // 加锁
    ready = true; // 设置标志位为true，表示数据已准备好
    cv.notify_all(); // 通知所有等待的线程
}

int main() {
    std::thread threads[10];
    // 启动10个线程
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_id, i);

    std::cout << "10 threads ready to race...\n";
    go(); // 通知所有线程开始竞争

    for (auto& th : threads) th.join(); // 等待所有线程结束

    return 0;
}

在这个示例中，我们创建了10个线程，每个线程都调用print_id函数。print_id函数首先获取互斥锁，然后检查ready标志位是否为true。如果ready为false，则线程将等待条件变量的通知。当主线程调用go函数时，它将设置ready为true并通知所有等待的线程。这样，所有线程都将继续执行并打印它们的线程ID。

7、生产者消费者问题

生产者消费者问题是一个经典的并发问题，涉及到多个线程之间的协作和资源共享。在这个问题中，生产者线程负责生成数据，而消费者线程负责处理这些数据。为了确保数据的一致性和线程安全，需要使用同步机制来协调生产者和消费者之间的操作。下面是一个C++代码示例，演示了如何使用条件变量和互斥锁来解决生产者消费者问题：

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

std::queue<int> dataQueue; // 用于存放数据的队列
std::mutex mtx; // 互斥锁，用于保护共享资源
std::condition_variable cvProducer, cvConsumer; // 条件变量，用于同步线程

// 生产者线程函数
void producer() {
    int count = 0;
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cvProducer.wait(lock, [] { return dataQueue.size() < 10; }); // 等待队列未满
        dataQueue.push(count);
        std::cout << "Produced: " << count << std::endl;
        count++;
        lock.unlock();
        cvConsumer.notify_one(); // 通知消费者线程
    }
}

// 消费者线程函数
void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cvConsumer.wait(lock, [] { return !dataQueue.empty(); }); // 等待队列非空
        int data = dataQueue.front();
        dataQueue.pop();
        std::cout << "Consumed: " << data << std::endl;
        lock.unlock();
        cvProducer.notify_one(); // 通知生产者线程
    }
}

int main() {
    std::thread producerThread(producer);
    std::thread consumerThread(consumer);

    producerThread.join();
    consumerThread.join();

    return 0;
}

上述代码中，dataQueue是用于存放数据的队列，mtx是互斥锁，用于保护共享资源，cvProducer和cvConsumer是条件变量，用于同步线程。

在生产者线程中，首先获取互斥锁，然后等待队列未满的条件满足后，将数据放入队列中，并打印生产的信息。然后解锁互斥锁，并通过条件变量cvConsumer通知消费者线程。

在消费者线程中，首先获取互斥锁，然后等待队列非空的条件满足后，从队列中取出数据，并打印消费的信息。然后解锁互斥锁，并通过条件变量cvProducer通知生产者线程。

通过互斥锁和条件变量的使用，可以保证生产者和消费者线程之间的同步和互斥访问共享资源，从而解决生产者消费者问题。

8、原子操作（std::atomic）

原子操作（std::atomic）是C++11引入的一种同步原语，用于确保对基本数据类型的操作在多线程环境中是原子的。原子操作可以保证在执行过程中不会被其他线程打断，从而避免了竞争条件和数据不一致的问题。

在C++中，std::atomic模板类提供了对原子操作的支持。它允许你声明一个原子类型，并使用一系列原子操作来对其进行操作。这些原子操作包括加载、存储、递增、递减等。

下面是一个使用std::atomic的示例代码：

#include <iostream>
#include <atomic>
#include <thread>

// 定义一个原子整型变量
std::atomic<int> counter(0);

void increment() {
    // 自增操作，将counter的值加1
    counter.fetch_add(1, std::memory_order_relaxed);
}

int main() {
    // 创建多个线程进行自增操作
    std::thread t1(increment);
    std::thread t2(increment);
    std::thread t3(increment);

    // 等待所有线程完成
    t1.join();
    t2.join();
    t3.join();

    // 输出最终结果
    std::cout << "Counter value: " << counter << std::endl;

    return 0;
}

在上面的代码中我们定义了一个原子整型变量counter，并将其初始化为0。

接下来，我们定义了一个名为increment的函数，该函数使用fetch_add方法对counter进行自增操作。fetch_add方法的第一个参数是要增加的值，第二个参数是内存顺序，这里使用了std::memory_order_relaxed表示不需要严格的内存顺序约束。

在main函数中，我们创建了三个线程t1、t2和t3，每个线程都调用increment函数进行自增操作。最后，我们通过join方法等待所有线程完成，并输出最终的counter值。

由于counter是一个原子类型，因此即使在多线程环境下，每次只有一个线程能够成功执行自增操作，从而保证了操作的原子性。因此，最终的输出结果应该是3，即三个线程分别执行了一次自增操作。

总结一下，std::atomic提供了一种简单而安全的方式来处理多线程中的原子操作，确保数据的一致性和同步性。

9、信号量（std::semaphore）

信号量（std::semaphore）是C++标准库中的一个同步原语，用于控制对共享资源的访问。它允许多个线程在没有竞争的情况下访问共享资源，从而避免了潜在的数据竞争和死锁问题。

下面是一个使用std::semaphore的简单示例：

#include <iostream>
#include <thread>
#include <mutex>
#include <semaphore>

// 定义一个信号量，初始值为1
std::binary_semaphore sem(1);

// 定义一个互斥量，用于保护共享资源
std::mutex mtx;

// 共享资源
int shared_resource = 0;

// 生产者线程函数
void producer() {
    for (int i = 0; i < 10; ++i) {
        // 等待信号量
        sem.acquire();

        // 获取互斥量锁
        std::unique_lock<std::mutex> lock(mtx);

        // 修改共享资源
        shared_resource += 1;
        std::cout << "Producer produced: " << shared_resource << std::endl;

        // 释放互斥量锁
        lock.unlock();

        // 释放信号量
        sem.release();
    }
}

// 消费者线程函数
void consumer() {
    for (int i = 0; i < 10; ++i) {
        // 等待信号量
        sem.acquire();

        // 获取互斥量锁
        std::unique_lock<std::mutex> lock(mtx);

        // 读取共享资源
        std::cout << "Consumer consumed: " << shared_resource << std::endl;

        // 释放互斥量锁
        lock.unlock();

        // 释放信号量
        sem.release();
    }
}

int main() {
    // 创建生产者和消费者线程
    std::thread t1(producer);
    std::thread t2(consumer);

    // 等待线程结束
    t1.join();
    t2.join();

    return 0;
}

在这个示例中，我们定义了一个信号量sem，初始值为1，表示最多允许一个线程访问共享资源。我们还定义了一个互斥量mtx，用于保护共享资源shared_resource。生产者线程和消费者线程分别通过调用sem.acquire()和sem.release()来请求和释放信号量。当信号量的值大于0时，线程可以继续执行；当信号量的值为0时，线程将被阻塞，直到信号量变得可用。

通过这种方式，我们可以确保在任何时刻只有一个线程可以访问共享资源，从而避免了潜在的数据竞争和死锁问题。