多线程同步

实现线程同步是确保多个线程在访问共享资源时不会产生竞争条件或数据不一致的关键。

1.互斥量

是一种同步原语，用于保护共享资源，使得在任意时刻只有一个线程可以访问该资源。

实现方式：

• C++11（及以上）：std::mutex、std::lock_guard、std::unique_lock

2.读写锁（Read-Write Lock）

概念：

读写锁允许多个线程同时读取共享资源，但在写操作时只有一个线程可以进行写操作，读操作会被阻塞。

3.条件变量（Condition Variable）

概念：

条件变量用于线程间的协调，允许线程在某个条件发生时通知其他线程

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

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

void wait_for_signal() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });
    std::cout << "Signal received!" << std::endl;
}

void send_signal() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one(); // 通知等待的线程
}

int main() {
    std::thread waiter(wait_for_signal);
    std::thread signaler(send_signal);

    waiter.join();
    signaler.join();

    return 0;
}

4. 信号量（Semaphore）

概念：

信号量用于控制对共享资源的访问量，能够限制同时访问共享资源的线程数量。

#include <iostream>
#include <thread>
#include <semaphore>

std::counting_semaphore<2> sem(2); // 初始计数为 2

void access_resource(int id) {
    sem.acquire(); // 请求信号量
    std::cout << "Thread " << id << " accessing resource." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread " << id << " releasing resource." << std::endl;
    sem.release(); // 释放信号量
}

int main() {
    std::thread t1(access_resource, 1);
    std::thread t2(access_resource, 2);
    std::thread t3(access_resource, 3);

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

    return 0;
}

5. 自旋锁（Spinlock）

概念：

自旋锁是一种轻量级的锁，它在尝试获取锁时会不断检查锁的状态，而不是进行阻塞。适用于锁持有时间非常短的场景。

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

std::atomic_flag lock = ATOMIC_FLAG_INIT;

void work(int id) {
    while (lock.test_and_set(std::memory_order_acquire)) {
        // 自旋等待
    }
    std::cout << "Thread " << id << " working." << std::endl;
    lock.clear(std::memory_order_release);
}

int main() {
    std::thread t1(work, 1);
    std::thread t2(work, 2);

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

    return 0;
}