Linux环境下C++多线程如何同步

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

1. 互斥锁（mutex）：互斥锁是一种同步原语，用于确保多个线程不会同时访问共享资源。在C++中，可以使用std::mutex类来实现互斥锁。

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

}
    

1. 递归互斥锁（recursive mutex）：递归互斥锁允许同一个线程多次锁定同一个互斥锁，而不会导致死锁。在C++中，可以使用std::recursive_mutex类来实现递归互斥锁。

2. 定时锁（timed mutex）：定时锁允许在指定的时间内尝试锁定互斥锁，如果在指定时间内无法锁定，则返回一个错误。在C++中，可以使用std::timed_mutex类来实现定时锁。

3. 条件变量（condition variable）：条件变量允许线程等待某个条件成立，同时释放互斥锁。当其他线程改变了共享状态并通知条件变量时，等待的线程会被唤醒。在C++中，可以使用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>
     lck(mtx);

    cv.wait(lck, []{
    return ready;
}
    );
    
    std::cout <
    <
     "Thread " <
    <
     id <
    <
     '\n';

}


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

}


int main() {
    
    std::thread threads[10];
    
    for (auto&
 th : threads) {
    
        th = std::thread(print_id, &
    th - &
    threads[0]);

    }
    

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

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

    }
    

    return 0;

}
    

1. 读写锁（shared mutex）：读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。在C++中，可以使用std::shared_mutex类来实现读写锁。

2. 原子操作（atomic operations）：原子操作是一种无需使用互斥锁即可实现线程安全的操作。在C++中，可以使用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 t1(increment_counter);
    
    std::thread t2(increment_counter);
    

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

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

    return 0;

}
    

这些同步方法可以根据实际需求进行选择和使用，以确保多线程程序的正确性和性能。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！