Linux环境下C++多线程如何实现高效同步

在Linux环境下，C++多线程实现高效同步可以通过以下几种方式：

互斥锁（mutex）：互斥锁是最基本的同步原语，用于保护共享资源。当一个线程访问共享资源时，需要先获取互斥锁，其他线程则需要等待锁释放。C++11提供了std::mutex和std::lock_guard来实现互斥锁。

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

std::mutex mtx;

void print_block(int n, char c) {
    mtx.lock();
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << '\n';
    mtx.unlock();
}

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

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

    return 0;
}

读写锁（shared_mutex）：读写锁允许多个线程同时读取共享资源，但只允许一个线程写入。这在读操作远多于写操作的场景下可以提高性能。C++17提供了std::shared_mutex和std::shared_lock来实现读写锁。

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

std::shared_mutex rw_mtx;

void read_block(int n, char c) {
    std::shared_lock<std::shared_mutex> lock(rw_mtx);
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << '\n';
}

void write_block(int n, char c) {
    std::unique_lock<std::shared_mutex> lock(rw_mtx);
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << '\n';
}

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

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

    return 0;
}

原子操作（atomic）：原子操作是一种无需使用锁即可实现线程安全的操作。C++11提供了std::atomic模板类来实现原子操作。

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

std::atomic<int> counter(0);

void increment_counter() {
    for (int i = 0; i < 100000; ++i) {
        ++counter;
    }
}

int main() {
    std::thread th1(increment_counter);
    std::thread th2(increment_counter);

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

    std::cout << "Counter: " << counter << '\n';

    return 0;
}

条件变量（condition_variable）：条件变量用于在多个线程之间传递信号，以便在某个条件满足时唤醒等待的线程。C++11提供了std::condition_variable来实现条件变量。

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

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

void print_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });
    std::cout << "Thread " << id << '\n';
}

void go() {
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all();
}

int main() {
    std::thread threads[10];

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

    std::this_thread::sleep_for(std::chrono::seconds(1));
    go();

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

    return 0;
}

屏障（barrier）：屏障用于同步多个线程，使它们在某个点上等待，直到所有线程都到达该点。C++20提供了std::barrier来实现屏障。

#include <iostream>
#include <barrier>
#include <thread>
#include <vector>

std::barrier sync_point(3);

void do_work(int id) {
    std::cout << "Thread " << id << " before sync_point\n";
    sync_point.arrive_and_wait();
    std::cout << "Thread " << id << " after sync_point\n";
}

int main() {
    std::vector<std::thread> threads;

    for (int i = 0; i < 3; ++i) {
        threads.emplace_back(do_work, i);
    }

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

    return 0;
}

根据实际需求选择合适的同步原语，以实现高效的多线程同步。

亿速云「云服务器」，即开即用、新一代英特尔至强铂金CPU、三副本存储NVMe SSD云盘，价格低至29元/月。点击查看>>

最新问答

相关标签