C++ 多线程同步

技术博客 (149) 2023-09-16 15:48:01

在C++中,多线程同步是非常重要的,因为多个线程同时访问共享资源可能会导致数据竞争和不一致性。以下是一些常见的多线程同步机制:

互斥锁:互斥锁是一种最基本的同步机制,它可以保证同一时间只有一个线程可以访问共享资源。当一个线程获得了互斥锁,其他线程就必须等待该线程释放锁后才能访问共享资源。

条件变量:条件变量是一种同步机制,它可以让线程在满足某个条件时等待,而不是忙等待。条件变量通常与互斥锁一起使用,当条件不满足时,线程会释放互斥锁并等待条件变量,当条件满足时,线程会重新获得互斥锁并继续执行。

信号量:信号量是一种同步机制,它可以控制多个线程对共享资源的访问。信号量有一个计数器,当计数器为0时,线程会被阻塞,当计数器大于0时,线程可以访问共享资源并将计数器减1

屏障:屏障是一种同步机制,它可以让多个线程在某个点上等待,直到所有线程都到达该点后才继续执行。屏障通常用于分阶段的任务,每个阶段都需要等待所有线程完成后才能进入下一阶段。

以上是一些常见的多线程同步机制,不同的场景需要选择不同的同步机制来保证线程安全和正确性。

下面详细介绍,并写出例子

1. 互斥锁(mutex)

互斥锁是一种最基本的同步机制,它可以保证同一时间只有一个线程访问共享资源。在C++中,可以使用std::mutex来实现互斥锁。

```c++
#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print(int num) {

    mtx.lock();
    std::cout << "Thread " << num << " is printing." << std::endl;
    mtx.unlock();
}

int main() {

    std::thread t1(print, 1);
    std::thread t2(print, 2);
    t1.join();
    t2.join();
    return 0;
}
```

2. 条件变量(condition variable)

条件变量是一种高级的同步机制,它可以让线程在某个条件满足时才继续执行。在C++中,可以使用std::condition_variable来实现条件变量。

```c++
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

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

void print(int num) {

    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) {

        cv.wait(lock);
    }
    std::cout << "Thread " << num << " is printing." << std::endl;
}

int main() {

    std::thread t1(print, 1);
    std::thread t2(print, 2);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    ready = true;
    cv.notify_all();
    t1.join();
    t2.join();
    return 0;
}
```

3. 信号量(semaphore)

信号量是一种常用的同步机制,它可以控制同时访问共享资源的线程数量。在C++中,可以使用std::semaphore来实现信号量。

```c++
#include <iostream>
#include <thread>
#include <semaphore.h>

sem_t sem;

void print(int num) {

    sem_wait(&sem);
    std::cout << "Thread " << num << " is printing." << std::endl;
    sem_post(&sem);
}

int main() {

    sem_init(&sem, 0, 1);
    std::thread t1(print, 1);
    std::thread t2(print, 2);
    t1.join();
    t2.join();
    sem_destroy(&sem);
    return 0;
}
```

4. 屏障(barrier)

屏障是一种同步机制,它可以让多个线程在某个点上等待,直到所有线程都到达这个点后才继续执行。在C++中,可以使用std::barrier来实现屏障。

```c++
#include <iostream>
#include <thread>
#include <barrier>

std::barrier bar(2);

void print(int num) {

    std::cout << "Thread " << num << " is waiting." << std::endl;
    bar.wait();
    std::cout << "Thread " << num << " is printing." << std::endl;
}

int main() {

    std::thread t1(print, 1);
    std::thread t2(print, 2);
    t1.join();
    t2.join();
    return 0;
}

THE END

发表回复