Linux环境下C++多线程如何实现同步 - 问答

在Linux环境下，C++多线程实现同步的主要方法有以下几种：

互斥锁（mutex）：互斥锁是一种用于保护共享资源的同步原语。当一个线程访问共享资源时，它需要先锁定互斥锁，其他线程在互斥锁被解锁之前无法访问该资源。C++11提供了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;
}

条件变量（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> 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 (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;
}

原子操作（atomic operation）：原子操作是一种不可中断的操作，可以确保在多线程环境下对共享变量的访问是安全的。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 t1(increment_counter);
    std::thread t2(increment_counter);

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

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

    return 0;
}

屏障（barrier）：屏障是一种同步原语，用于确保多个线程在某个点上等待，直到所有线程都到达该点。C++11没有直接提供屏障，但可以使用std::condition_variable和std::mutex实现。

示例代码：

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

class Barrier {
public:
    explicit Barrier(std::size_t count) : thread_count(count), count(count) {}

    void wait() {
        std::unique_lock<std::mutex> lock(mtx);
        int remaining_threads = --count;
        if (remaining_threads == 0) {
            cv.notify_all();
        } else {
            cv.wait(lock, [this]{ return count == 0; });
        }
    }

private:
    std::mutex mtx;
    std::condition_variable cv;
    std::size_t thread_count;
    std::size_t count;
};

Barrier barrier(2);

void print_hello() {
    std::cout << "Hello from thread " << std::this_thread::get_id() << '\n';
    barrier.wait();
    std::cout << "World from thread " << std::this_thread::get_id() << '\n';
}

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

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

    return 0;
}

这些方法可以帮助你在Linux环境下使用C++实现多线程同步。在实际应用中，你可能需要根据具体需求选择合适的同步方法。

0 赞

0 踩