互斥（Mutual Exclusion）详解

飞飞-躺着更舒服

于 2024-12-19 14:09:54 发布

阅读量644

点赞数 4

分类专栏： C++基础文章标签： c++

本文链接：https://blog.youkuaiyun.com/u013090854/article/details/144580835

版权

C++基础专栏收录该内容

9 篇文章

订阅专栏

互斥（Mutual Exclusion）是指在并发编程中，确保多个线程或进程在访问共享资源（如内存、文件或设备）时，不会同时进行操作的机制。通过互斥，可以避免资源竞争和数据不一致的问题。

互斥的核心思想

互斥的核心是在同一时刻只允许一个线程或进程访问共享资源。当一个线程在访问共享资源时，其他线程必须等待，直到该线程完成访问并释放互斥锁。

互斥的实现方式

常见的互斥实现方式包括：

1. 互斥锁（Mutex）

互斥锁是一种同步原语，用于在线程之间保护共享资源。

加锁（Locking）：在访问共享资源前获取锁。
解锁（Unlocking）：在访问结束后释放锁。

代码实现：

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

std::mutex mtx;  // 互斥锁
int shared_data = 0;

void increment() {
    for (int i = 0; i < 100; ++i) {
        mtx.lock();  // 加锁
        ++shared_data;
        mtx.unlock();  // 解锁
    }
}

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

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

    std::cout << "Final value of shared_data: " << shared_data << std::endl;
    return 0;
}

输出：

Final value of shared_data: 200

如果没有互斥锁，多个线程可能同时修改 shared_data，导致结果不正确。

2. 读写锁（Reader-Writer Lock）

在一些场景下，读操作不会改变资源的状态，因此可以允许多个线程同时读取，但写操作需要独占资源。读写锁可以提高效率。

多个线程可以同时读取资源。
只有写线程可以独占访问资源，且写时禁止其他线程读或写。

代码示例：

#include <iostream>
#include <shared_mutex>
#include <thread>

std::shared_mutex rw_lock;  // 读写锁
int shared_data = 0;

void reader() {
    rw_lock.lock_shared();
    std::cout << "Read shared_data: " << shared_data << std::endl;
    rw_lock.unlock_shared();
}

void writer() {
    rw_lock.lock();
    ++shared_data;
    std::cout << "Write shared_data: " << shared_data << std::endl;
    rw_lock.unlock();
}

int main() {
    std::thread t1(writer);
    std::thread t2(reader);
    std::thread t3(reader);

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

    return 0;
}

3. 信号量（Semaphore）

信号量是一种计数器，用于限制同时访问共享资源的线程数量。

二进制信号量：类似互斥锁，用于单一访问控制。
计数信号量：限制资源的最大并发访问数。

代码示例：

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

std::counting_semaphore<2> sem(2);  // 允许最多两个线程同时访问
int shared_data = 0;

void task(int id) {
    sem.acquire();  // 获取信号量
    ++shared_data;
    std::cout << "Thread " << id << " incremented shared_data to " << shared_data << std::endl;
    sem.release();  // 释放信号量
}

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

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

    return 0;
}