关于互斥锁的理解

最新推荐文章于 2025-10-23 16:37:59 发布
转载 最新推荐文章于 2025-10-23 16:37:59 发布 · 698 阅读 · 1

参考文档

  1. https://blog.youkuaiyun.com/google19890102/article/details/62047798
  2. https://blog.youkuaiyun.com/tennysonsky/article/details/46494077

互斥锁
互斥锁是通过锁的机制来实现线程间的同步问题。互斥锁的基本流程为：

初始化一个互斥锁：pthread_mutex_init() 函数
加锁：pthread_mutex_lock()函数或者pthread_mutex_trylock()函数
对共享资源的操作
解锁：pthread_mutex_unlock()函数
注销互斥锁：pthread_mutex_destory()函数

其中，在加锁过程中，pthread_mutex_lock()函数和pthread_mutex_trylock()函数的过程略有不同：
当使用pthread_mutex_lock()函数进行加锁时，若此时已经被锁，则尝试加锁的线程会被阻塞，直到互斥锁被其他线程释放，当pthread_mutex_lock()函数有返回值时，说明加锁成功；
而使用pthread_mutex_trylock()函数进行加锁时，若此时已经被锁，则会返回EBUSY的错误码。

同时，解锁的过程中，也需要满足两个条件：
解锁前，互斥锁必须处于锁定状态； 必须由加锁的线程进行解锁。

当互斥锁使用完成后，必须进行清除。

什么是互斥锁？怎么运用互斥锁？
weixin_45824067的博客
08-02 6689
互斥锁是（Mutex）是一种用于的同步原语，用于确保在。在多线程环境中，当多个线程同时访问共享资源时，可能会导致数据的竞争和不一致问题。为了避免这种问题，需要确保在任何时候只有一个线程能够访问共享资源，而其他线程需要等待直到资源可用。互斥锁提供这样一种机制，即在某个线程访问共享资源时，它会有互斥锁，其他线程需要等待互斥锁的释放才能访问共享资源。一旦线程完成对共享资源的访问，它会释放互斥锁，以便其他线程可以获取互斥锁并访问共享资源。
c语言互斥锁和条件变量,条件变量，条件锁，互斥锁的简单理解
weixin_30668061的博客
05-23 930
看了一些网上有关条件锁的讲解，一般都讲得晦涩难懂，都是术语的感觉，看了让人似乎明白了一点，又有很多疑惑，所以我决定写下我自己的简单理解。在写条件锁之前，先讲讲互斥锁，请看例子：1，不使用互斥锁的情况：#include #include #include #include #include pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;void p...
互斥锁的理解
业精于勤,荒于嬉;行成于思,毁于随
03-30 1335
互斥锁（英语：英语：Mutual exclusion，缩写 Mutex）是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区域（critical section）达成。临界区域指的是一块对公共资源进行访问的代码，并非一种机制或是算法。一个程序、进程、线程可以拥有多个临界区域，但是并不一定会应用互斥锁。 需要此机制的资
互斥锁、读写锁、ref()函数使用
YQ20210216的博客
10-23 648
互斥锁（Mutual Exclusion Lock）是最基本的同步机制，用于保护共享资源。它确保在同一时刻只有一个线程能够访问被保护的资源。创建引用包装器，确保按引用传递，线程使用了&,传参的时候就要用ref()或cref()。即使线程函数的参数是引用类型，直接传递变量也会被复制，而不是真正的引用传递。到新线程的上下文中。类，配合RAII机制的。在C++中创建线程时，
第六章节 - 理解互斥锁
u012596785的博客
07-18 568
理解互斥锁 - 章节 介绍Mutual Exclusion - Mutexes(互斥锁) - 小节 在最后一节… 了解了如何安全地共享内存和避免数据争用 - 用volatile - 发布不可变对象 这是我们唯一的担心吗? 竞态条件 竞态条件导致: - 不一致的数据 - Invariants broken volatile不能帮助 如果只有一个线程可以编写，那么发布对象将有所帮助 ...
互斥锁的认知
Alingjiu的博客
04-06 262
互斥锁用来将读写进行锁住，以防止其它线程提取进行进行完读写，自己线程往后延迟进行读写导致数据出现紊乱。注意点：借用一个对象的锁要注意借用的那个对象是个固定对象，不是固定对象的话，当第一条线程在执行的时候，第二条线程也能执行开锁区的代码，那就可能会造成同读同写，明明数据是变化了两次，结果只变化了一次的错误 while (1) {//UIView *view = [[UIView alloc] ini...
简单的JavaScript互斥锁分享
10-26
此外，该实现通过添加注释以及合理的命名，使得其他开发者可以更容易地理解和使用这些互斥锁功能。 综上所述，文件内容中展示的简单JavaScript互斥锁，提供了一种在单线程环境下模拟互斥锁行为的方法。其原理和实现...
互斥锁与事件锁
02-26
在多线程编程中，互斥锁（Mutex）和事件锁（Event）是两种常见的同步机制，用于确保多个线程安全地访问共享资源。本文将深入探讨这两种锁的工作原理、使用场景及其优缺点。 首先，互斥锁是线程同步的基础工具之一。...
Python的互斥锁与信号量详解
09-18
本文通过多个实例代码详细介绍了互斥锁和信号量在Python中的实现与应用，对于理解多线程同步机制及其在实际问题中的运用有着重要的帮助，对于学习多线程编程具有参考价值。希望本文内容能够帮助更多的人深入理解和...
互斥锁与条件变量详解 疑问全解
08-11
互斥锁与条件变量详解 互斥锁（Mutex）是多线程编程中最基本的同步机制之一，它用于保护共享资源免受多个线程同时访问的干扰。条件变量（Condition Variable）则是另一个重要的同步机制，它允许线程在满足特定条件...
互斥锁
qq_42185762的博客
03-24 146
1.什么是锁的可重入性？ Concurrent包中所有的锁都是可重入锁，一般都命名为 ReentrantX，通常所有的锁都要设计成可重入的，可重入锁是指在互斥区中当再次进行加锁操作时，线程仍然可以拿到该锁。 synchronized就是可重入锁，想象以下场景，f1()是synchronized函数，在f1()中调用synchronized函数f2()，此时锁中记录了两个线程的信息。 2.请简述互斥锁中相关类的继承层次？ 上图是ReentrantLock相关类之间的继承层次，表示ReentrantLock实
多线程-------互斥锁
rickypc的专栏
08-18 497
http://baike.baidu.com/view/1461738.htm
进程互斥锁的初步实现(下)
qq_52484093的博客
12-12 158
问题 内核中如何实现任务的阻塞？ 把执行队列中的任务放入等待队列。 再论任务状态 由互斥锁触发的内核操作 当任务获取锁失败 将当前任务移入等待队列 (进入阻塞态) 调度下一任务执行 当互斥锁被标记为空闲 将等待队列中的任务移入就绪队列 (脱离阻塞态) 互斥锁与任务调度一 互斥锁与任务调度二 互斥锁与任务调度三 互斥锁与任务调度 task.h enum { WAIT, NOTIFY }; task.c static void...
关于互斥锁
ko999123的博客
12-02 378
顾名思义，在多线程下，用来锁定资源使用权限。 我们先看一段代码： #include #include #include #include int count =0; void *func(void* argc) { for(int i=0; i<3; i++) { printf("[before] tid:%d count:%d\n", pthread_self(), co
互斥锁的实现细节
qq_42185762的博客
03-25 863
***首先，一个互斥锁要实现什么功能？*** 一个互斥锁需要有阻塞和唤醒功能，实现阻塞和唤醒功能需要哪些要素？ ①需要有一个标记锁状态的state变量。 ②需要记录哪个线程持有了锁。 ③需要有一个队列维护所有的线程。 另外，state和队列中为了实现线程安全都用到了CAS。 有了以上三个条件，可以实现对线程的阻塞和唤醒。 ***那么，Java中是如何实现一把互斥锁的？*** 首先，因为所有的锁基本都要实现重入功能，那么Java中的互斥锁由ReentrantLock类来定义，也就是可重入锁，也就是说Re
linux内核 信号量、自旋锁、completion、互斥体、延时函数
lxllinux的博客
11-20 1957
      访问共享资源的代码区域称为临界区（ critical sections），临界区需要被以某种互斥机制加以保护，方法有中断屏蔽、原子操作、自旋锁和信号量等。        在驱动程序中，当多个线程同时访问相同的资源时（驱动程序中的全局变量是一种典型的共享资源），可能会引发"竞态"，因此我们必须对共享资源进行并发控制。Linux内核中解决并发控制的最常用方法是自旋锁与信号量（绝大多数时候...
锁
u012632105的博客
03-07 390
Java中的锁主要用于保障多并发线程情况下数据的一致性。在多线程编程中为保障数据一致性，我们常需要在使用对象或方法之前加锁。这时若有其他线程也需要使用此对象或該方法，则产生要获得锁。如果某个线程发现锁正被其他线程使用，就会进入阻塞队列等待锁的释放，直到其它线程执行完毕并释放锁，該线程才有机会再次获取锁进行操作。这就保障了在同一时刻只有一个线程持有该对象的锁并修改对象，从而保障数据安全。 锁可分为...
简述python多线程中的互斥锁
feilzhang的博客
05-04 3753
        在编程中，为了保证共享数据操作的完整性，引入了互斥锁的概念。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。在python中由于多线程的存在，并且对全局变量作用时有可能产生全局变量紊乱问题，所以也加入了同步和互斥等方法，但是我们主要讲解互斥锁：如下代码定义了一个my_num的全局变量，而函数sum1和函数sum2都执行对my_n...
C++互斥锁理解
最新发布
12-19
<think>我们即将讨论C++中的互斥锁（Mutex）。互斥锁是并发编程中用于保护共享资源不被多个线程同时访问的同步机制。在C++中，互斥锁主要通过`<mutex>`头文件提供。 我们将涵盖以下几个方面： 1. 基本互斥锁（std::mutex） 2. 锁守卫（std::lock_guard）和唯一锁（std::unique_lock） 3. 其他类型的互斥锁：递归互斥锁（std::recursive_mutex）、定时互斥锁（std::timed_mutex）等 4. 死锁预防（std::lock和std::try_lock） 5. 条件变量（std::condition_variable）与互斥锁的配合使用 下面我们通过代码示例来详细解释。 </think> # C++互斥锁(Mutex)详解 在C++中，互斥锁(mutex)是同步原语，用于保护共享资源不被多个线程同时访问，防止数据竞争(data race)。以下是C++互斥锁的全面解析和代码示例。 ## 1. 基本互斥锁(std::mutex) ```cpp #include <iostream> #include <thread> #include <mutex> std::mutex mtx; // 全局互斥锁 int shared_data = 0; // 共享资源 void increment(int n) { for (int i = 0; i < n; ++i) { mtx.lock(); // 获取锁 ++shared_data; // 临界区操作 mtx.unlock(); // 释放锁 } } int main() { const int iterations = 100000; std::thread t1(increment, iterations); std::thread t2(increment, iterations); t1.join(); t2.join(); std::cout << "最终值: " << shared_data << " (应为: " << 2 * iterations << ")\n"; return 0; } ``` **关键点**： - `lock()`: 阻塞直到获取锁 - `unlock()`: 释放锁 - 必须成对使用，否则可能导致死锁 - 不推荐直接使用，更推荐RAII包装器 ## 2. RAII包装器：lock_guard ```cpp void safe_increment(int n) { for (int i = 0; i < n; ++i) { std::lock_guard<std::mutex> lock(mtx); // 自动加锁解锁 ++shared_data; // 离开作用域自动解锁 } } ``` **优势**： - 异常安全：即使发生异常也能保证解锁 - 避免忘记解锁 - 作用域结束自动释放 ## 3. 更灵活的unique_lock ```cpp void transfer(int amount, int& from, int& to) { std::unique_lock<std::mutex> lock1(mtx1, std::defer_lock); std::unique_lock<std::mutex> lock2(mtx2, std::defer_lock); // 避免死锁的加锁方式 std::lock(lock1, lock2); // 原子性地获取多个锁 from -= amount; to += amount; // 自动解锁 } ``` **特性**： - 延迟锁定(`std::defer_lock`) - 转移所有权 - 手动锁定/解锁 - 支持条件变量 ## 4. 递归互斥锁(std::recursive_mutex) ```cpp std::recursive_mutex rec_mtx; void recursive_function(int depth) { std::lock_guard<std::recursive_mutex> lock(rec_mtx); if (depth > 0) { recursive_function(depth - 1); } } int main() { std::thread t(recursive_function, 3); t.join(); return 0; } ``` **适用场景**： - 递归函数需要多次加锁 - 同一个线程需要多次获取同一锁 - 普通mutex会导致死锁的情况 ## 5. 定时互斥锁(std::timed_mutex) ```cpp std::timed_mutex timed_mtx; void timed_access() { auto timeout = std::chrono::milliseconds(100); if (timed_mtx.try_lock_for(timeout)) { std::cout << "获取锁成功\n"; // 执行操作... timed_mtx.unlock(); } else { std::cout << "获取锁超时\n"; // 替代方案... } } ``` **方法**: - `try_lock()`: 尝试获取锁，立即返回 - `try_lock_for()`: 尝试获取锁，带超时 - `try_lock_until()`: 尝试获取锁，直到指定时间点 ## 6. 共享互斥锁(std::shared_mutex) C++17 ```cpp #include <shared_mutex> std::shared_mutex sh_mtx; std::string shared_resource; // 读操作（多个线程可同时读） void reader(int id) { std::shared_lock lock(sh_mtx); std::cout << "Reader " << id << ": " << shared_resource << "\n"; } // 写操作（独占访问） void writer(const std::string& data) { std::unique_lock lock(sh_mtx); shared_resource = data; } int main() { std::thread readers[5]; for (int i = 0; i < 5; ++i) { readers[i] = std::thread(reader, i); } std::thread writer_thread(writer, "New Data"); for (auto& t : readers) t.join(); writer_thread.join(); } ``` **特性**： - 多个线程可同时获取共享锁（读锁） - 只有一个线程可获取独占锁（写锁） - 读写锁模式提高并发性能 ## 7. 避免死锁的最佳实践 1. **锁定顺序**：所有线程按相同顺序获取锁 2. **使用std::lock**：原子性地锁定多个互斥锁 3. **RAII包装器**：优先使用lock_guard/unique_lock 4. **避免嵌套锁**：减少锁定范围 5. **超时机制**：使用try_lock避免无限等待 ```cpp // 安全的多锁获取 void safe_multilock() { std::mutex mtx1, mtx2; // 方法1：使用std::lock std::unique_lock lock1(mtx1, std::defer_lock); std::unique_lock lock2(mtx2, std::defer_lock); std::lock(lock1, lock2); // 原子锁定 // 方法2：固定顺序 std::lock_guard lockA(mtx1); std::lock_guard lockB(mtx2); } ``` ## 8. 条件变量配合互斥锁 ```cpp std::mutex mtx; std::condition_variable cv; bool data_ready = false; // 生产者 void producer() { std::lock_guard<std::mutex> lock(mtx); // 准备数据... data_ready = true; cv.notify_one(); // 通知消费者 } // 消费者 void consumer() { std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, []{ return data_ready; }); // 等待通知 // 消费数据... data_ready = false; } ``` **工作流程**： 1. 消费者线程等待条件变量 2. 生产者修改条件并通知 3. 消费者被唤醒并检查条件 4. 条件满足则继续执行 ## 9. 性能考虑 1. **锁粒度**：尽量减小临界区范围 ```cpp // 错误：锁定时间过长 { std::lock_guard lock(mtx); auto data = get_data(); // 耗时操作 process(data); // 应在锁外执行 } // 正确：仅保护共享访问 auto data = get_data(); // 锁外执行 { std::lock_guard lock(mtx); update_shared_state(data); } ``` 2. **锁争用**：使用读写锁减少竞争 3. **无锁编程**：对于简单操作用原子变量替代 ```cpp std::atomic<int> counter(0); // 不需要锁的线程安全操作 counter.fetch_add(1, std::memory_order_relaxed); ``` ## 10. C++20新增特性 1. **std::scoped_lock**：改进的多锁RAII包装器 ```cpp std::mutex mtx1, mtx2; { std::scoped_lock lock(mtx1, mtx2); // C++17支持 // 自动解锁 } ``` 2. **等待通知增强**： ```cpp std::atomic<bool> ready(false); std::condition_variable cv; // C++20 等待通知 cv.wait(lock, std::atomic_wait, ready, false); ``` ---
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值