C++多线程库函数并发控制策略

C++ 多线程库提供了一些函数和类来实现并发控制策略，主要包括互斥锁（mutex）、条件变量（condition variable）和原子操作（atomic operations）等

1. 互斥锁（mutex）：互斥锁是最基本的同步机制，用于保护共享资源免受多个线程的同时访问。当一个线程获得互斥锁时，其他线程必须等待该线程释放锁后才能继续访问共享资源。C++ 标准库中的 std::mutex 类提供了互斥锁的实现。

示例代码：

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

std::mutex mtx; // 全局互斥锁
int shared_data = 0; // 共享数据

void thread_function() {
    std::unique_lock<std::mutex> lock(mtx); // 获取互斥锁
    ++shared_data; // 修改共享数据
    lock.unlock(); // 释放互斥锁
}

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

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

    std::cout << "Shared data: "<< shared_data<< std::endl;
    return 0;
}

2. 条件变量（condition variable）：条件变量通常与互斥锁一起使用，以实现线程间的同步和通信。当一个线程需要等待另一个线程完成某个操作时，可以使用条件变量。C++ 标准库中的 std::condition_variable 类提供了条件变量的实现。

示例代码：

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

std::mutex mtx;
std::condition_variable cv;
bool ready = false; // 共享状态

void worker_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) { // 如果共享状态为 false，则等待
        cv.wait(lock);
    }
    std::cout << "Worker thread is ready."<< std::endl;
}

void main_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟延迟
    {
        std::unique_lock<std::mutex> lock(mtx);
        ready = true; // 修改共享状态
    }
    cv.notify_one(); // 唤醒等待的线程
}

int main() {
    std::thread worker(worker_thread);
    main_thread();
    worker.join();
    return 0;
}

3. 原子操作（atomic operations）：原子操作是一种不可分割的操作，它可以在没有锁的情况下实现线程安全。C++ 标准库中的 std::atomic 类模板提供了原子操作的实现。原子操作通常用于实现无锁数据结构和高性能的并发算法。

示例代码：

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

std::atomic<int> shared_data(0); // 原子整数类型的共享数据

void thread_function() {
    ++shared_data; // 原子操作，自增 1
}

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

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

    std::cout << "Shared data: "<< shared_data.load()<< std::endl;
    return 0;
}

这些并发控制策略可以根据具体的应用场景和需求进行组合使用，以实现高效、安全的多线程编程。