开发者社区 开发与运维 文章 正文

boost库中thread多线程详解2——mutex与lock

2014-09-01 1558
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 1. mutex对象类 mutex类主要有两种：独占式与共享式的互斥量。▲ 独占式互斥量：mutex: 独占式的互斥量，是最简单最常用的一种互斥量类型try_mutex: 它是mutex的同义词，为了与兼容以前的版本而提供timed_mutex: 它也是独占式的互斥量，但提供超时锁定功能▲ 递归式...

1. mutex对象类

mutex类主要有两种：独占式与共享式的互斥量。
▲ 独占式互斥量：
mutex: 独占式的互斥量，是最简单最常用的一种互斥量类型
try_mutex: 它是mutex的同义词，为了与兼容以前的版本而提供
timed_mutex: 它也是独占式的互斥量，但提供超时锁定功能
▲ 递归式互斥量：
recursive_mutex: 递归式互斥量，可以多次锁定，相应地也要多次解锁
recursive_try_mutex: 它是recursive_mutex 的同义词，为了与兼容以前的版本而提供
recursive_timed_mutex: 它也是递归式互斥量，基本功能同recursive_mutex, 但提供超时锁定功能
▲ 共享式互斥量：
shared_mutex: multiple-reader/single-writer 型的共享互斥量(又称读写锁)。
其中mutex有lock和unlock方法，shared_mutex除了提供lock和unlock方法外，还有shared_lock和shared_unlock方法。

2. lock模板类

▲ 独占锁：
boost::unique_lock<T>，其中T可以mutex中的任意一种。
  如果T为mutex，那么boost::unique_lock<boost::mutex>，构造与析构时则分别自动调用lock和unlock方法。
  如果T为shared_mutex，那么boost::unique_lock<boost::shared_mutex>，构造与析构时则分别调用shared_mutex的shared_lock和shared_unlock方法。
注意：scoped_lock也是独占锁，其源代码中定义如下；
  typedef unique_lock<mutex> scoped_lock;
  typedef unique_lock<timed_mutex> scoped_timed_lock;
▲ 共享锁：
boost::shared_lock<T>，其中的T只能是shared_mutex类。
当然还有其他一些锁：lock_guard, upgrade_lock等。

3. 读写锁的实现

[cpp]  view plain copy print ?
 
  1. typedef boost::shared_lock<boost::shared_mutex> readLock;  
  2. typedef boost::unique_lock<boost::shared_mutex> writeLock;  
  3. boost::shared_mutex rwmutex;  
  4.   
  5. void readOnly()  
  6. {  
  7.   readLock rdlock(rwmutex);  
  8.   // do something  
  9. }  
  10.   
  11. void writeOnly()  
  12. {  
  13.   writeLock wtlock(rwmutex);  
  14.   // do something  
  15. }  

对同一个rwmutex，线程可以同时有多个readLock，这些readLock会阻塞任意一个企图获得writeLock的线程，直到所有的readLock对象都析构。如果writeLock首先获得了rwmutex，那么它会阻塞任意一个企图在rwmutex上获得readLock或者writeLock的线程。

4. boost::lock_guard<>和boost::unique_lock<>的区别

[cpp]  view plain copy print ?
 
  1. boost::mutex m;  
  2. void foo( )  
  3. {  
  4.   boost::lock_guard<boost::mutex> lk(m);  
  5.   process(data);  
  6. };  
  7.   
  8. // lock_guard只能像上面这样使用，而unique_lock允许设置超时，推迟锁定lock以及在对象销毁之前unlock。  
  9. {  
  10.   boost::unique_lock<boost::mutex> lk( m );  
  11.   process( data );  
  12.   lk.unlock( );  
  13.   // do other thing  
  14. };  
  15.   
  16. // 设置锁超时  
  17. {  
  18.   boost::unique_lock<boost::timed_mutex> lk(m, std::chrono::milliseconds(3)); // 超时3秒  
  19.   if(lk)  
  20.     process( data );  
  21. };  

 

5. 简单示例

[cpp]  view plain copy print ?
 
    1. namespace  
    2. {  
    3.     boost::mutex mutex;  
    4.     boost::shared_mutex shared_mutex;  
    5.   
    6.     void wait(int seconds)  
    7.     {  
    8.         boost::this_thread::sleep(boost::posix_time::seconds(seconds));  
    9.     }  
    10.   
    11.     void threadfun1()  
    12.     {  
    13.         for (int i = 0; i < 5; ++i)  
    14.         {  
    15.             wait(1);  
    16.             mutex.lock();  
    17.             PRINT_DEBUG(i);  
    18.             mutex.unlock();  
    19.         }  
    20.     }  
    21.   
    22.     void threadfun2()  
    23.     {  
    24.         for (int i = 0; i < 5; ++i)  
    25.         {  
    26.             wait(1);  
    27.             boost::lock_guard<boost::mutex> lock(mutex);  
    28.             PRINT_DEBUG(i);  
    29.         }  
    30.     }  
    31.       
    32.     void threadfun3()  
    33.     {  
    34.         for (int i = 0; i < 5; ++i)  
    35.         {  
    36.             wait(1);  
    37.             // unique_lock<boost::mutex> = scoped_lock  
    38.             boost::unique_lock<boost::mutex> lock(mutex);  
    39.             std::cout << lock.owns_lock() << std::endl;  
    40.             PRINT_DEBUG(i);  
    41.         }  
    42.     }  
    43. }  
    44.   
    45. // 1. mutex例子  
    46. void test_thread_syn1()  
    47. {  
    48.     boost::thread t1(&threadfun1);  
    49.     boost::thread t2(&threadfun1);  
    50.   
    51.     t1.join();  
    52.     t2.join();  
    53. }  
    54.   
    55. //  2. lock_guard例子  
    56. void test_thread_syn2()  
    57. {  
    58.     boost::thread t1(&threadfun2);  
    59.     boost::thread t2(&threadfun2);  
    60.   
    61.     t1.join();  
    62.     t2.join();  
    63. }  
    64.   
    65. // 3. scoped_lock例子  
    66. void test_thread_syn3()  
    67. {  
    68.     boost::thread t1(&threadfun3);  
    69.     boost::thread t2(&threadfun3);  
    70.   
    71.     t1.join();  
    72.     t2.join();  
    73. }  
文章标签：
C++
关键词：
thread线程
线程lock
线程mutex
boost thread线程
double2li
目录
相关文章
刘大猫.
|
10月前
|
Arthas 监控 Java
Arthas thread（查看当前JVM的线程堆栈信息）
Arthas thread（查看当前JVM的线程堆栈信息）
刘大猫.
1755 10
kaixin321-44007
|
Java C# Python
线程等待（Thread Sleep）
线程等待是多线程编程中的一种同步机制，通过暂停当前线程的执行，让出CPU时间给其他线程。常用于需要程序暂停或等待其他线程完成操作的场景。不同语言中实现方式各异，如Java的`Thread.sleep(1000)`、C#的`Thread.Sleep(1000)`和Python的`time.sleep(1)`。使用时需注意避免死锁，并考虑其对程序响应性的影响。
kaixin321-44007
380 8
东方睿赢
|
Java 开发者
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
东方睿赢
205 4
龙大吉
|
Java 开发者
在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱，帮助你更好地理解和选择适合项目需求的线程创建方式。
龙大吉
306 3
三三是该溜子
|
Java 程序员 调度
【JavaEE】线程创建和终止，Thread类方法，变量捕获（7000字长文）
创建线程的五种方式，Thread常见方法（守护进程.setDaemon() ，isAlive），start和run方法的区别，如何提前终止一个线程，标志位，isinterrupted，变量捕获
三三是该溜子
907 0
三三是该溜子
|
安全 Java API
【JavaEE】多线程编程引入——认识Thread类
Thread类，Thread中的run方法，在编程中怎么调度多线程
三三是该溜子
234 0
东方睿赢
|
Java
在Java多线程编程中，实现Runnable接口通常优于继承Thread类
【10月更文挑战第20天】在Java多线程编程中，实现Runnable接口通常优于继承Thread类。原因包括：1) Java只支持单继承，实现接口不受此限制；2) Runnable接口便于代码复用和线程池管理；3) 分离任务与线程，提高灵活性。因此，实现Runnable接口是更佳选择。
东方睿赢
398 2
东方睿赢
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析：线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景，帮助读者更好地理解和掌握多线程编程技术，为复杂任务的高效处理奠定基础。
东方睿赢
254 2
龙大吉
|
Java 开发者
Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点，重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
龙大吉
375 1
东方睿赢
|
Java 开发者
在 Java 多线程编程中，Lock 接口正逐渐取代传统的 `synchronized` 关键字，成为高手们的首选
【10月更文挑战第6天】在 Java 多线程编程中，Lock 接口正逐渐取代传统的 `synchronized` 关键字，成为高手们的首选。相比 `synchronized`，Lock 提供了更灵活强大的线程同步机制，包括可中断等待、超时等待、重入锁及读写锁等高级特性，极大提升了多线程应用的性能和可靠性。通过示例对比，可以看出 Lock 接口通过 `lock()` 和 `unlock()` 明确管理锁的获取和释放，避免死锁风险，并支持公平锁选择和条件变量，使其在高并发场景下更具优势。掌握 Lock 接口将助力开发者构建更高效、可靠的多线程应用。
东方睿赢
124 2

热门文章

最新文章

  • 1
    C#与JAVA线程间同步实现比较
  • 2
    Android的进程与线程（2）按重要性划分等级的5种进程
  • 3
    艾伟：C#多线程学习(六) 互斥对象
  • 4
    工作线程数究竟要设置为多少 | 架构师之路
  • 5
    Java5线程池潜规则研究
  • 6
    高并发之——多线程的三大特性（原子性、可见性和有序性）
  • 7
    进程与线程 thread （二）——线程概念
  • 8
    Linux线程同步之读写锁
  • 9
    HashMap的底层原理和线程安全的替代方案
  • 10
    多线程简单示例
  • 1
    Python threading模块：多线程编程的实战指南
    513
  • 2
    什么是线程池？它的工作原理？
    348
  • 3
    如何在Java中进行多线程编程
    245
  • 4
    【JUC】（6）带你了解共享模型之 享元和不可变 模型并初步带你了解并发工具 线程池Pool，文章内还有饥饿问题、设计模式之工作线程的解决于实现
    327
  • 5
    【JUC】（3）常见的设计模式概念分析与多把锁使用场景！！理解线程状态转换条件！带你深入JUC！！文章全程笔记干货！！
    397
  • 6
    【JUC】（1）带你重新认识进程与线程！！让你深层次了解线程运行的睡眠与打断！！
    845
  • 7
    【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
    277
  • 8
    【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
    296
  • 9
    JUC系列之《CountDownLatch：同步多线程的精准发令枪 》
    534
  • 10
    NDM多线程下载器!实用的下载器,绿色版下载及安装教程
    2204

    • 相关电子书

    更多
  • 多IO线程优化版
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    云安全中心：病毒查杀