C++在Linux下如何实现并发控制 - 问答

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

多线程：使用C++11标准库中的<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;
}

互斥锁：使用<mutex>头文件中的std::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;
}

条件变量：使用<condition_variable>头文件中的std::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];
    // spawn 10 threads:
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(printId, i);

    std::cout << "10 threads ready to race..." << std::endl;
    go(); // go!

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

    return 0;
}

信号量：Linux下可以使用semaphore.h中的信号量，但C++标准库中没有直接支持信号量的组件。你可以使用POSIX信号量或者自己封装一层。
读写锁：使用<shared_mutex>头文件中的std::shared_mutex（C++17及以上）来实现读写锁，允许多个读取者或者一个写入者访问共享资源。

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

std::shared_mutex rw_mtx;

void readFunction() {
    std::shared_lock<std::shared_mutex> lock(rw_mtx); // 共享锁
    std::cout << "Reading data..." << std::endl;
}

void writeFunction() {
    std::unique_lock<std::shared_mutex> lock(rw_mtx); // 排他锁
    std::cout << "Writing data..." << std::endl;
}

int main() {
    std::thread t1(readFunction);
    std::thread t2(writeFunction);

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

    return 0;
}

在使用这些并发控制机制时，需要注意避免死锁和其他并发问题。合理地设计锁的粒度和锁的使用顺序，以及使用RAII风格的锁管理（如std::lock_guard和std::unique_lock），可以帮助减少错误和提高代码的健壮性。

0 赞

0 踩