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

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

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

#include 
#include 
#include 

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;
}

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

#include 
#include 
#include 

std::shared_mutex rw_mtx;

void read_block(int n, char c) {
    std::shared_lock 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 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;
}

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

#include 
#include 
#include 

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;
}

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

#include 
#include 
#include 
#include 

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

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

void go() {
    std::lock_guard 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;
}

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

#include 
#include 
#include 
#include 

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 threads;

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

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

    return 0;
}

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

以上就是关于“Linux环境下C++多线程如何实现高效同步”的相关介绍，筋斗云是国内较早的云主机应用的服务商，拥有10余年行业经验，提供丰富的云服务器、租用服务器等相关产品服务。云服务器资源弹性伸缩，主机vCPU、内存性能强悍、超高I/O速度、故障秒级恢复；电子化备案，提交快速，专业团队7×24小时服务支持！

简单好用、高性价比云服务器租用链接：https://www.jindouyun.cn/product/cvm