Linux环境下C++多线程怎样同步 - 问答

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

互斥锁（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;
}

递归互斥锁（recursive mutex）：递归互斥锁允许同一个线程多次锁定同一个互斥锁，而不会导致死锁。在C++中，可以使用std::recursive_mutex类来实现递归互斥锁。
定时锁（timed mutex）：定时锁允许在指定的时间内尝试锁定互斥锁，如果在指定时间内无法锁定，则返回一个错误。在C++中，可以使用std::timed_mutex类来实现定时锁。
条件变量（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::unique_lock<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(print_id, i);

    std::cout << "10 threads ready to race...\n";
    go();

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

    return 0;
}

读写锁（shared mutex）：读写锁允许多个线程同时读取共享资源，但在写入时会阻塞其他线程。在C++中，可以使用std::shared_mutex类来实现读写锁。
原子操作（atomic operations）：原子操作是一种无需使用锁即可实现线程安全的操作。在C++中，可以使用std::atomic模板类来实现原子操作。

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

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

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

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

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

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

    return 0;
}

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

0 赞

0 踩