muduo网络库学习之MutexLock类、MutexLockGuard类、Condition类、CountDownLatch类封装中的知识点

最新推荐文章于 2023-05-21 20:26:34 发布
最新推荐文章于 2023-05-21 20:26:34 发布
阅读量3.7k 收藏 1
点赞数 2
分类专栏： muduo网络库学习 文章标签： muduo mutex condition countdownlatch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jnu_simba/article/details/13780697
版权

一、MutexLock 类

class  MutexLock  :  boost::noncopyable

二、MutexLockGuard类

class  MutexLockGuard  :  boost::noncopyable


三、Condition类

class  Condition  :  boost::noncopyable


某个线程：
加锁                                    
     while (条件)
          wait(); //1、解锁；2、等待通知；3、得到通知返回前重新加锁
解锁

另一个线程：
加锁
     更改条件
     通知notify（可以移到锁外）
解锁

四、CountDownLatch类

class  CountDownLatch  :  boost::noncopyable

既可以用于所有子线程等待主线程发起 “起跑”
也可以用于主线程等待子线程初始化完毕才开始工作

下面写两个程序测试一下CountDownLatch 的作用：

CountDownLatch_test1:
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
#include <muduo/base/CountDownLatch.h>
#include <muduo/base/Thread.h>

#include <boost/bind.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <string>
#include <stdio.h>

using  namespace muduo;

class Test
{
public:
    Test( int numThreads)
        : latch_( 1),
          threads_(numThreads)
    {
         for ( int i =  0; i < numThreads; ++i)
        {
             char name[ 32];
            snprintf(name,  sizeof name,  "work thread %d", i);
            threads_.push_back( new muduo::Thread(
                                   boost::bind(&Test::threadFunc,  this), muduo::string(name)));
        }
        for_each(threads_.begin(), threads_.end(), boost::bind(&Thread::start, _1));
    }

     void run()
    {
        latch_.countDown();
    }

     void joinAll()
    {
        for_each(threads_.begin(), threads_.end(), boost::bind(&Thread::join, _1));
    }

private:

     void threadFunc()
    {
        latch_.wait();
        printf( "tid=%d, %s started\n",
               CurrentThread::tid(),
               CurrentThread::name());



        printf( "tid=%d, %s stopped\n",
               CurrentThread::tid(),
               CurrentThread::name());
    }

    CountDownLatch latch_;
    boost::ptr_vector<Thread> threads_;
};

int main()
{
    printf( "pid=%d, tid=%d\n", ::getpid(), CurrentThread::tid());
    Test t( 3);
    sleep( 3);
    printf( "pid=%d, tid=%d %s running ...\n", ::getpid(), CurrentThread::tid(), CurrentThread::name());
    t.run();
    t.joinAll();

    printf( "number of created threads %d\n", Thread::numCreated());
}



执行结果如下：

simba@ubuntu:~/Documents/build/debug/bin$ ./countdownlatch_test1
pid=2994, tid=2994
pid=2994, tid=2994 main running ...
tid=2997, work thread 2 started
tid=2997, work thread 2 stopped
tid=2996, work thread 1 started
tid=2996, work thread 1 stopped
tid=2995, work thread 0 started
tid=2995, work thread 0 stopped
number of created threads 3
simba@ubuntu:~/Documents/build/debug/bin$ 

可以看到其他三个线程一直等到主线程睡眠完执行run()，在里面执行latch_.countDown() 将计数减为0，进而执行notifyall 唤醒后，才开始执行下来。


CountDownLatch_test2:
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
#include <muduo/base/CountDownLatch.h>
#include <muduo/base/Thread.h>

#include <boost/bind.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <string>
#include <stdio.h>

using  namespace muduo;

class Test
{
public:
    Test( int numThreads)
        : latch_(numThreads),
          threads_(numThreads)
    {
         for ( int i =  0; i < numThreads; ++i)
        {
             char name[ 32];
            snprintf(name,  sizeof name,  "work thread %d", i);
            threads_.push_back( new muduo::Thread(
                                   boost::bind(&Test::threadFunc,  this), muduo::string(name)));
        }
        for_each(threads_.begin(), threads_.end(), boost::bind(&muduo::Thread::start, _1));
    }

     void wait()
    {
        latch_.wait();
    }

     void joinAll()
    {
        for_each(threads_.begin(), threads_.end(), boost::bind(&Thread::join, _1));
    }

private:

     void threadFunc()
    {
        sleep( 3);
       printf( "tid=%d, %s started\n" ,
               CurrentThread::tid(),
               CurrentThread::name());

        latch_.countDown();
     

        printf( "tid=%d, %s stopped\n",
               CurrentThread::tid(),
               CurrentThread::name());
    }

    CountDownLatch latch_;
    boost::ptr_vector<Thread> threads_;
};

int main()
{
    printf( "pid=%d, tid=%d\n", ::getpid(), CurrentThread::tid());
    Test t( 3);
    t.wait();
    printf( "pid=%d, tid=%d %s running ...\n", ::getpid(), CurrentThread::tid(), CurrentThread::name());
    t.joinAll();

    printf( "number of created threads %d\n", Thread::numCreated());
}



执行结果输出如下：

simba@ubuntu:~/Documents/build/debug/bin$ ./countdownlatch_test2
pid=4488, tid=4488
tid=4491, work thread 2 started
tid=4491, work thread 2 stopped
tid=4490, work thread 1 started
tid=4490, work thread 1 stopped
tid=4489, work thread 0 started
pid=4488, tid=4488 main running ...
tid=4489, work thread 0 stopped
number of created threads 3

可以看出当其他三个线程都启动后，各自执行一次 latch_.countDown()，主线程wait() 返回继续执行下去。


参考：
muduo manual.pdf
《linux 多线程服务器编程：使用muduo c++网络库》

s1mba
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++(11)：通过lock_guard使用mutex
风静如云的博客
05-04 2012
使用mutex时，如果加锁后忘记解锁，或者在使用的过程中出现异常，而没有在异常处理中解锁，那么锁会一直处于加锁状态，而无法解锁。 lock_guard类通过在对象构造的时候对mutux进行加锁，当对象离开作用域时自动解锁，从而避免加锁后没有解锁的问题： #include <iostream> #include <thread> #include <mutex> using namespace std; int g_d{0}; void tFunc(mutex&a
浅谈 non-blocking I/O Multiplexing + poll/epoll 的正确使用
热门推荐
Meditation
10-09 1万+
在前面的文章中曾经粗略讲过poll，那时是用阻塞IO实现，在发送和接收数据量都较小情况下和网络状况良好的情况下是基本没有问题的，read 不会只接收部分数据，write 也不会一直阻塞。但实际上poll IO复用经常是跟非阻塞IO一起使用的，想想如果现在接收缓冲区一点数据没有，read 阻塞了，或者发送缓冲区不够空间存放数据，write 阻塞了，那整个事件循环就会延迟响应，比如现在又有一个新连
基于muduo网络库和C++实现的集群聊天服务器源码+使用说明.zip
最新发布
12-20
《项目介绍》 基于muduo网络库和C++实现的集群聊天服务器源码+使用说明.zip 编译： cd /build rm -rf * cmake .. make 负载均衡配置： nginx tcp loadbalance config stream { upstream MyServer{ server 127.0.0.1:6000 weight=1 max_fails=3 fail_timeout=30s; server 127.0.0.1:6000 weight=1 max_fails=3 fail_timeout=30s; } server { proxy_connect_timeout ls; listen 8000; # nginx监听的端口号 proxy_pass MyServer; # 标记 tcp_nodelay on; } } 【注】 1.项目代码均经过功能验证ok，确保稳定可靠运行。欢迎下载使用体验！ 2.主要针对各个计算机相关专业，包括计算机科学、信息安全、数据科学与大数据技术、人工智能、通信、物联网等领域的在校学生、专业教师、企业员工。 3.项目具有丰富的拓展空间，不仅可作为入门进阶，也可直接作为毕设、课程设计、大作业、初期项目立项演示等用途。 4.当然也鼓励大家基于此进行二次开发。在使用过程中，如有问题或建议，请及时沟通。 5.期待你能在项目中找到乐趣和灵感，也欢迎你的分享和反馈！
muduo : MutexLock
Huntinux
07-25 1138
介绍 https://github.com/chenshuo/muduo/blob/master/muduo/base/Mutex.h MutexLock是对互斥锁的封装，使用时用作一个类的成员变量，保护另一个常用被互斥访问。成员变量 pthread_mutex_t mutex_; pid_t holder_; // 由哪个线程持有default构造函数： MutexLock()
【Window】互斥锁——Mutex，lock_guard，unique_lock
萧海的博客
05-16 1725
1 互斥锁Mutex 1.1 基本概念 在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。比如说，同一个文件，可能一个线程会对其进行写操作，而另一个线程需要对这个文件进行读操作，可想而知，如果写线程还没有写结束，而此时读线程开始了，或者读线程还没有读结束而写线程开始了，那么最终的结果显然会是混乱的。为了保护共享资源，在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。 在多线程
muduo网络库：04---线程同步精要之（封装MutexLock、MutexLockGuard、Condition）
董哥的黑板报
03-15 1023
本文内容衔接于前一篇文章（互斥器、条件变量、读写锁、信号量、sleep）：https://blog.csdn.net/qq_41453285/article/details/104859230 MutexLock、MutexLockGuard、Condition等class完整代码在muduo/base中都可以找到，这几个class都不允许拷贝构造和赋值 一、MutexLock、MutexLoc...
线程间互斥-mutex互斥锁和lock_guard
qq_42120843的博客
05-10 722
某一时刻ticketCount = 99，thread1此时调用ticketCount–,执行到sub eax时执行线程切换到另一个线程thread2中，此时ticketCount仍为99，执行完3条汇编后ticketCount = 98，此时再切换回thread1，继续执行完后面汇编，也使ticketCount = 98,这里就导致同时输出两次98；竟态条件：多线程程序执行的结果一致，不会随着CPU对线程不同的调用顺序。输出的部分结果里有很多重复的数字，相当于同一张票被卖出多次，原因在于。
base5. MutexLock和MutexLockGuard互斥量类、Condition条件变量类、CountDownLatch倒计时门栓类（计数类）
TABE_的博客
03-22 383
MutexLock类图 数据成员： pthread_mutex_t mutex_：pthread_mutex_t类型的线程互斥量mutex_ pid_t holder_：holder_用于保存锁拥有者的线程tid 成员函数： MutexLock()：构造函数，初始化mutex_ ~MutexLock()：析构函数，销毁mutex_ bool isLockedByThisThread()：判断当前线程是否拥有该锁 void assertLocked()：断言当前线程拥有该锁 void lock()：加锁，并
C++多线程（二）---- mutex互斥量、lock_guard＜mutex＞、unique_lock＜mutex＞的使用和各种方式加锁的区别(详细解析~~~)
weixin_43978744的博客
05-21 4085
C++多线程（二）---- 多线程资源竞争、std::mutex互斥量、lock_guard、unique_lock的使用和各种方式加锁的区别(详细解析~~~)
学习muduo库（4）之门闩类CountDownLatch
请叫我少爷的博客
12-19 235
UML： 解释： CountDownLatch类是一个通过条件变量类condition，来实现让多个子线程同时起跑的。其实count_是表示需要建立的线程数，当count_大于零时，线程会被条件变量挂起。每建立一个线程count_都会减一，当最后一个线程建立成功后，count_减为零。这个时候就唤起所有被条件变量挂起的线程。这些线程同时起跑。关键的代码如下： void CountD...
C++ 标准库 互斥体mutex、lock_guard、recursive_mutex、timed_mutex、recursive_timed_mutex、unique_lock
虫字的博客
04-26 1297
一、mutex mutex全名mutual exclusion（互斥体），是个object，用来协助采取独占排他方式控制“对资源的并发访问” 例如，下面对一份资源进行锁定 void f(int val); int val; //共享资源 std::mutex valMutex; //互斥体 void func() { //锁定，然后操作共享资源 valMutex.lock(); if (val >= 0) f(val);
完整muduo网络库
04-01
完整版muduo网络库，仅供学习使用
Muduo_网络库使用手册
09-12
专门讲muduo网络库使用方法
muduo网络库/网络库/网络库.rar
08-18
muduo网络库/网络库/网络库.rar
muduo网络库实用知识库分享知识分享
10-13
资源muduo网络库实用知识库分享知识分享
muduo网络库学习之EventLoop（一）：事件循环类图简介和muduo 定时器TimeQueue
Meditation
11-07 1万+
1、EventLoop、Channel、Poller 等类图如下： 黑色菱形：组合；白色菱形：聚合；白色三角形：继承；实线：关联； Channel是selectable IO channel，负责注册与响应IO 事件，它不拥有file descriptor。 Channel是Acceptor、Connector、EventLoop、TimerQueue、TcpConn
阻塞/非阻塞读写总结、tcp网络编程的本质、muduo::Buffer设计简介
Meditation
11-07 9891
一、阻塞/非阻塞读写总结 1、对于read 调用，如果接收缓冲区中有 20字节，请求读 100个字节，就会返回 20；对于 write调用，如果请求写 100个字节，而发送缓冲区中只有 20个字节的空闲位置，那么 write会阻塞，直到把 100个字节全部交给发送缓冲区才返回。但如果 socket文件描述符有 O_NONBLOCK标志，则 write不阻塞，直接返回 20；此时非
大型网站架构演变过程、大并发服务器架构
Meditation
11-14 9319
大型网站架构演变过程： [Step1]web server与数据库分离 web动静资源分离 静态请求：如html, js, css, img 动态请求：如jsp, php [Step2]缓存处理 客户端（浏览器）缓存 前端页面缓存（squid） 页面片段缓存ESI(Edge Side Includes)
常见多线程与并发服务器设计方案举例
Meditation
11-04 8145
一、3点基础知识 1、一个主机的端口号为所有进程所共享，但普通用户进程绑定不了一些特殊端口号如20、80等。  2、每个进程都有自己的文件描述符（包括file fd, socket fd, timer fd, event fd, signal fd），一般是1024，可以通过ulimit -n 设置，但所有进程打开的文件描述符总数有上限，跟主机的内存有关。 3、一个进
介绍一下muduo库中的timer类
05-19
muduo库中的Timer类是一个定时器类，用于在一定时间后执行指定的操作。它可以实现定时执行某个任务的功能。 Timer类的主要成员函数有： 1. start：启动定时器，参数为超时时间、超时时的回调函数和定时器间隔时间...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值