Linux下C++的并发控制怎样做

在 Linux 下，C++ 的并发控制可以通过多种方法实现，这里列举一些常用的方法：

1. 互斥锁（Mutex）：互斥锁是用于保护共享资源的一种同步机制，确保同一时刻只有一个线程可以访问共享资源。在 C++ 中，可以使用 std::mutex 和 std::lock_guard 或 std::unique_lock 来实现互斥锁。

示例代码：

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

std::mutex mtx; // 全局互斥锁

void print_block(int n, char c) {
    mtx.lock(); // 加锁
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << std::endl;
    mtx.unlock(); // 解锁
}

int main() {
    std::thread th1(print_block, 50, '*');
    std::thread th2(print_block, 50, '$');

    th1.join();
    th2.join();

    return 0;
}

2. 信号量（Semaphore）：信号量是一种计数器，用于控制对共享资源的访问数量。在 C++ 中，可以使用 POSIX 信号量（如 sem_t）或 C++17 中的 std::counting_semaphore。

示例代码（使用 POSIX 信号量）：

#include <iostream>
#include <thread>
#include <semaphore.h>

sem_t sem; // 全局信号量

void print_block(int n, char c) {
    sem_wait(&sem); // 等待信号量
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << std::endl;
    sem_post(&sem); // 释放信号量
}

int main() {
    sem_init(&sem, 0, 1); // 初始化信号量，计数为 1

    std::thread th1(print_block, 50, '*');
    std::thread th2(print_block, 50, '$');

    th1.join();
    th2.join();

    sem_destroy(&sem); // 销毁信号量

    return 0;
}

3. 条件变量（Condition Variable）：条件变量用于线程间的同步，允许线程在特定条件下等待或通知其他线程。在 C++ 中，可以使用 std::condition_variable 和 std::unique_lock。

示例代码：

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

std::mutex mtx; // 全局互斥锁
std::condition_variable cv; // 全局条件变量
bool ready = false; // 全局标志位

void print_block(int n, char c) {
    std::unique_lock<std::mutex> lock(mtx); // 加锁
    cv.wait(lock, []{ return ready; }); // 等待条件变量

    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << std::endl;
    ready = false; // 重置标志位
    cv.notify_one(); // 通知其他线程
}

void go() {
    std::unique_lock<std::mutex> lock(mtx); // 加锁
    ready = true; // 设置标志位
    cv.notify_one(); // 通知其他线程
}

int main() {
    std::thread th1(print_block, 50, '*');
    std::thread th2(print_block, 50, '$');
    std::thread th3(go);

    th1.join();
    th2.join();
    th3.join();

    return 0;
}

4. 原子操作（Atomic Operations）：原子操作是一种不可中断的操作，用于在多线程环境下保证数据的一致性。在 C++11 及以后的版本中，可以使用 std::atomic 库实现原子操作。

示例代码：

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

std::atomic<int> counter(0); // 全局原子计数器

void print_block(int n, char c) {
    for (int i = 0; i < n; ++i) {
        while (!counter.compare_exchange_weak(0, 1)) {
            // 自旋等待
        }
        std::cout << c;
        counter.store(0); // 重置计数器
    }
    std::cout << std::endl;
}

int main() {
    std::thread th1(print_block, 50, '*');
    std::thread th2(print_block, 50, '$');

    th1.join();
    th2.join();

    return 0;
}

这些方法可以根据实际需求进行组合使用，以实现更复杂的并发控制。在实际编程过程中，还需要注意避免死锁、竞态条件等问题。