C++在Linux上如何实现并发控制

在Linux上使用C++实现并发控制，可以采用多种方法，包括线程、互斥锁、条件变量、信号量、读写锁等。以下是一些基本的实现方式：

1. 使用C++11标准库中的线程支持

C++11引入了线程库，提供了std::thread类来创建和管理线程。

#include <iostream>
#include <thread>

void helloFunction() {
    std::cout << "Hello from a thread!" << std::endl;
}

int main() {
    std::thread t(helloFunction);
    t.join(); // 等待线程完成
    return 0;
}

2. 使用互斥锁（mutex）

互斥锁用于保护共享资源，确保同一时间只有一个线程可以访问。

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

std::mutex mtx; // 创建一个互斥锁

void printMessage(const std::string& msg) {
    mtx.lock(); // 加锁
    std::cout << msg << std::endl;
    mtx.unlock(); // 解锁
}

int main() {
    std::thread t1(printMessage, "Hello from thread 1");
    std::thread t2(printMessage, "Hello from thread 2");

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

    return 0;
}

3. 使用条件变量（condition_variable）

条件变量用于线程间的同步，允许一个或多个线程等待某个条件的发生。

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

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void printId(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    cv.wait(lck, []{return ready;}); // 等待条件变量
    std::cout << "Thread " << id << std::endl;
}

void go() {
    std::lock_guard<std::mutex> lck(mtx);
    ready = true;
    cv.notify_all(); // 通知所有等待的线程
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(printId, i);

    std::cout << "10 threads ready to race..." << std::endl;
    go(); // 改变条件变量

    for (auto& th : threads)
        th.join();

    return 0;
}

4. 使用信号量（semaphore）

信号量是一种更底层的同步机制，可以用来控制对共享资源的访问。

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

std::binary_semaphore sem(1); // 创建一个二进制信号量

void critical_section() {
    sem.acquire(); // 获取信号量
    // 访问共享资源
    std::cout << "In critical section" << std::endl;
    sem.release(); // 释放信号量
}

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

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

    return 0;
}

5. 使用读写锁（shared_mutex）

读写锁允许多个线程同时读取共享资源，但只允许一个线程写入。

#include <iostream>
#include <thread>
#include <shared_mutex>

std::shared_mutex rw_mtx;
int shared_data = 0;

void read_data() {
    std::shared_lock<std::shared_mutex> lock(rw_mtx); // 共享锁
    std::cout << "Read data: " << shared_data << std::endl;
}

void write_data(int new_value) {
    std::unique_lock<std::shared_mutex> lock(rw_mtx); // 排他锁
    shared_data = new_value;
    std::cout << "Write data: " << shared_data << std::endl;
}

int main() {
    std::thread t1(read_data);
    std::thread t2(write_data, 42);

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

    return 0;
}

在使用这些并发控制机制时，需要注意避免死锁和其他同步问题。合理设计程序的结构和使用适当的同步原语是确保线程安全的关键。