码迷,mamicode.com
首页 > 其他好文 > 详细

UVW源码漫谈(三)

时间:2017-09-28 19:12:27      阅读:251      评论:0      收藏:0      [点我收藏+]

标签:自己   event   表达   一起   source   elf   nbsp   解释   一个   

咱们继续看uvw的源码,这次看的东西比较多,去除底层的一些东西,很多代码都是连贯的,耦合度也比较高了。主要包括下面几个文件的代码:

underlying_type.hpp  resource.hpp  loop.hpp  handle.hpp  stream.hpp  tcp.hpp

代码我就不都贴出了,说到哪儿贴哪儿的代码。如果有兴致可以打开源码对照看看。另外代码也比较多,我先大概分析下源码的结构,再说一些细节的和项目基本无关的东西。

 

源码很好玩

1、保存自己的share_ptr——通过这个问题来通览一下源码。

在第一篇给大家介绍uvw用法的时候,不知道大家有没有注意到(算了,肯定没注意),我把大概的代码贴出来给大家看一下:

 1 void listen(uvw::Loop &loop) {
 2     std::shared_ptr<uvw::TcpHandle> tcp = loop.resource<uvw::TcpHandle>();
 3 
 4 。。。。。。
 5 
 6 }
 7 
 8 void conn(uvw::Loop &loop) {
 9     auto tcp = loop.resource<uvw::TcpHandle>();
10 。。。。。。
11 
12 }
13 
14 void g() {
15     auto loop = uvw::Loop::getDefault();
16     listen(*loop);
17     conn(*loop);
18     loop->run();
19     loop = nullptr;
20 }
21 
22 int main() {
23     g();
24 }

这儿listen和conn函数中,都有一个tcp变量,但是这个变量在函数内部,按道理说,按照g()中的顺序走下去,这两个局部变量应该早已经被自动销毁了,但是为什么还能再回调到事件处理函数?有的看官可能会猜测,是不是他们都保存在loop中,其实我一开始也这么认为,毕竟是调用loop的resource方法创建的。那就先看看resource的代码:

源码1  loop.hpp  266-270

1     template<typename R, typename... Args>
2     std::enable_if_t<not std::is_base_of<BaseHandle, R>::value, std::shared_ptr<R>>
3     resource(Args&&... args) {
4         return R::create(shared_from_this(), std::forward<Args>(args)...);
5     }

我们把TcpHandle的模板参数带进去看,哦,看来这边是调用的TcpHandle::create()这个静态函数,难道这就证明了loop没有保存TcpHandle? 但是create中明明传入了shared_from_this()参数,于是不死心,继续找create的实现,话说这么多类拐来拐去的,着实找了一阵子,终于找到了:

源码2  underlying_type.hpp  76-79

1     template<typename... Args>
2     static std::shared_ptr<T> create(Args&&... args) {
3         return std::make_shared<T>(ConstructorAccess{0}, std::forward<Args>(args)...);
4     }

看到这里,我就懵比了,传进来的 std::shared_ptr<Loop> 难道是跟 args 一起,被 std::forward 给吃了?好吧,那既然是要创建一个 std::shared_ptr<TcpHandle>,而且还传入了一堆参数,肯定是有TcpHandle的构造函数的吧。于是我把TcpHandle类的八辈儿祖宗都找了一遍,终于还是在underlying_type.hpp中找到了:

源码3  underlying_type.hpp  57-59

1     explicit UnderlyingType(ConstructorAccess, std::shared_ptr<Loop> ref) noexcept
2         : pLoop{std::move(ref)}, resource{}
3     {}

话说这个构造函数里也什么都没干,只是把loop保存了一下啊。那上面的问题怎么解释。于是我又看了一遍,原来Loop::resource还有一个实现:

源码4  loop.hpp  248-254

1     template<typename R, typename... Args>
2     std::enable_if_t<std::is_base_of<BaseHandle, R>::value, std::shared_ptr<R>>
3     resource(Args&&... args) {
4         auto ptr = R::create(shared_from_this(), std::forward<Args>(args)...);
5         ptr = ptr->init() ? ptr : nullptr;
6         return ptr;
7     }

这个实现与源码1 长的特别像,这在下面会说到。来看看这个实现里面。果然,多调用了一个init,而这个init貌似是TcpHandler的成员函数,来看看init里面有什么东西,

源码5  tcp.hpp  62-66

1     bool init() {
2         return (tag == FLAGS)
3                 ? initialize(&uv_tcp_init_ex, flags)
4                 : initialize(&uv_tcp_init);
5     }

源码6  handle.hpp  45-58

 1     template<typename F, typename... Args>
 2     bool initialize(F &&f, Args&&... args) {
 3         if(!this->self()) {
 4             auto err = std::forward<F>(f)(this->parent(), this->get(), std::forward<Args>(args)...);
 5 
 6             if(err) {
 7                 this->publish(ErrorEvent{err});
 8             } else {
 9                 this->leak();
10             }
11         }
12 
13         return this->self();
14     }

这里面其实就是用 uv_tcp_init 来做了一下初始化,可以看到第4行,this->parent就是loop指针,this->get就是uv_tcp_t,我就不贴代码了,大家从源码里翻看一下。这里如果初始化成功是肯定会调用leak的,继续往下看

源码7  resource.hpp  27-29

1     void leak() noexcept {
2         sPtr = this->shared_from_this();
3     }

这里就一个作用,把 this->shared_from_this() 赋给了自己的成员变量。难道这就是问题的关键所在?

 

我不服,怎么可能有这种操作,于是我做了个实验,代码如下:

 1 #include <iostream>
 2 #include <thread>
 3 #include <mutex>
 4 #include <condition_variable>
 5 
 6 std::mutex g_mutex;
 7 std::condition_variable g_cond;
 8 
 9 class C : public std::enable_shared_from_this<C> {
10 public:
11     C() {
12         std::cout << "C" << std::endl;
13         msg = "Hello World";
14     }
15 
16     ~C() {
17         std::cout << "~C" << std::endl;
18     }
19 
20     void init() {
21         local = this->shared_from_this();
22     }
23 
24     void thread_fun() {
25         while(true) {
26             std::unique_lock<std::mutex> lk(g_mutex);
27             g_cond.wait(lk);
28             std::cout << msg << std::endl;
29         }
30     }
31 
32     void print() {
33         th = std::thread(&C::thread_fun, this);
34         th.detach();
35     }
36 
37 private:
38     std::shared_ptr<C> local;
39     std::thread th;
40     std::string msg;
41 };
42 
43 void fun() {
44     shared_ptr<C> c = std::make_shared<C>();
45     c->init();
46     c->print();
47 }
48 
49 
50 int main(int argc, char* argv[])
51 {
52     fun();
53     std::cout << "fun finish" << std::endl;
54     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
55 
56     for(int i = 0; i < 4; i++) {
57         g_cond.notify_all();
58         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
59     }
60 
61     return 0;
62 }

这个测试代码基本是模拟了源码中的情况,用线程加条件变量来模拟信号的产生,输出结果如下:

1 C
2 fun finish
3 Hello World
4 Hello World
5 Hello World
6 Hello World

如果把上面代码的第45行注释掉,输出结果:

1 C
2 ~C
3 fun finish
4
5
6
7

注意,下面4行是打印出来的,对比一下这两个运行结果,第一种情况在fun结束之前是没有调用C类析构函数的,直到程序运行结束。而第二种情况在fun结束之前就调用了析构函数。这还不够,虽然两种情况中线程一直都在运行,但是第二种没有打印出“Hello World”,更加说明了上面的假设。

然后就是怎么来解释这种情况,我把fun函数改造一下:

1 void fun() {
2     shared_ptr<C> c = std::make_shared<C>();
3     std::cout << "use count: " << c.use_count() << std::endl;
4     c->init();
5     std::cout << "use count: " << c.use_count() << std::endl;
6     c->print();
7 }

大家可以试一下,第一次打印,引用计数是1,第二次打印,引用计数是2。当fun结束时,c被销毁,引用计数-1,还剩下1,保存在类中的local中,所以还不能够释放内存。或者说,在fun中构造的c,永远都不会释放,直到程序结束,程序所用的内存会由操作系统自动回收。

可能有些人见过这种用法,但是我确实是第一次碰到。不管各位看官感觉怎么样,反正我是觉得作者棒棒哒,简直就是一个心机boy,KeKe~~

看到这里,还有一个问题,为什么作者不把Handle保存在Loop中,而要以这种方式来处理呢?其实我们可以在Loop中声明一个

1     std::vector<std::shared_ptr<void>> handles;

这样不就可以保存Handle了,或许作者还有其他的考虑,我们以后再看。

 

2、代码的结构

其实如果有看官跟着上面的步骤走一下,基本上应该是把这个项目的大部分东西都了解了一下,项目的大概的继承关系也会比较清楚了,其他的其实就是一些对libuv东西的封装和使用,有兴趣把源码来回翻看一下。我相信对于接触c++时间较短或者对c++11,14标准比较生疏的会受益匪浅。同时,如果你是libuv的使用者,你可能会从里面学到一些其他的使用方法。

很多同学会自己看一些项目的源代码,但是很多人看一半,或者看一丢丢对自己有用的,就放下了。对于我们程序员来说,看质量好的源代码是非常重要的,我们可以从中了解作者的思想,作者解决问题的思路和方法,作者每行代码的企图,以及项目的设计和规划,还有其他好多好多东西,就算再不行,我们也可以借鉴人家的代码,进行修改,这也是一种学习方式。

说了这么多废话,就一个意思,很多东西我写出来,一是表达不好,二是大家看了也是一头雾水,所以有兴趣的还是看源码来的彻底。

来看一下这边代码结构和继承关系是怎么的:

技术分享

 这是从代码生成的docxgen文档中截的,文档下载链接:https://files.cnblogs.com/files/yxfangcs/uvw_html.zip

 

一些C++的东东

1、std::unique_ptr

上次有跟大家提到过一点智能指针的东东,给了一个链接回顾一下的。但是有些东西没说到,今天一起看一下。先看代码:

源码8  loop.hpp  184-202

 1     static std::shared_ptr<Loop> getDefault() {
 2         static std::weak_ptr<Loop> ref;
 3         std::shared_ptr<Loop> loop;
 4 
 5         if(ref.expired()) {
 6             auto def = uv_default_loop();
 7 
 8             if(def) {
 9                 auto ptr = std::unique_ptr<uv_loop_t, Deleter>(def, [](uv_loop_t *){});
10                 loop = std::shared_ptr<Loop>{new Loop{std::move(ptr)}};
11             }
12 
13             ref = loop;
14         } else {
15             loop = ref.lock();
16         }
17 
18         return loop;
19     }

且先不看这个函数是干嘛的,看到第9行。我们正常用std::unique_ptr基本就是这样的:

1 std::unique_ptr<uv_loop_t> ptr = std::make_unique<uv_loop_t>();

然后我们也知道,unique_ptr要用move来传递,我们也知道,这个智能指针会在离开作用域的时候自动释放。像第9行这样的用法大家可能就很少看到了,先来看看unique_ptr的原形:

1 template<
2     class T,
3     class Deleter = std::default_delete<T>
4 > class unique_ptr;
5 
6 template <
7     class T,
8     class Deleter
9 > class unique_ptr<T[], Deleter>;

哦,这下就知道了,原来是有这么个东西存在的,这里的模板变量T就是我们正常传入的类型,而Deleter是有一个默认值的,std::default_delete<T> 基本上就类似于delete了,这里我们也是可以自定义的,像上面用法中的Deleter我们可以在代码中找到:

源码9  loop.hpp  143

1     using Deleter = void(*)(uv_loop_t *);

这个using的用法在之前的博客中有写过。在这个用法中,我们可以自行定义unique_ptr的构造和销毁的操作,看下面的例子:

1 std::unique_ptr<std::FILE, decltype(&std::fclose)> fp(std::fopen("demo.txt", "r"), &std::fclose);
3 if(fp)
4   std::cout << (char)std::fgetc(fp.get()) << ‘\n‘;

(这段来自:http://en.cppreference.com/w/cpp/memory/unique_ptr 有兴趣可以点开看看)

怎么样,这样用是不是特别舒服。在离开fp的作用域后,unique_ptr会自动调用fclose来关闭文件。这里面有一个decltype,这个东西其实就是来返回参数的类型的,比如上面我不知道fclose的原形是什么,那么我可以直接用decltype来返回它的类型。举个例子:

1 auto fun1 = [](int a){return a;};
2 decltype(fun1) fun2 = fun1;

再看到源码1的第10行,这儿用{}来初始化,在之前博客中也说到过,叫列表初始化,上面打开文件的例子也可以这样写:

1 std::unique_ptr<std::FILE, decltype(&std::fclose)> fp{std::fopen("demo.txt", "r"), &std::fclose};
2 if(fp)
3    std::cout << (char)std::fgetc(fp.get()) << ‘\n‘;

也是没关系的。

 

2、std::enable_if_t

把上面代码再贴一下,方便看

源码10  loop.hpp  248-254

1     template<typename R, typename... Args>
2     std::enable_if_t<std::is_base_of<BaseHandle, R>::value, std::shared_ptr<R>>
3     resource(Args&&... args) {
4         auto ptr = R::create(shared_from_this(), std::forward<Args>(args)...);
5         ptr = ptr->init() ? ptr : nullptr;
6         return ptr;
7     }

这边的enable_if_t的原型是:

1 template<bool B, class T = void>
2 struct enable_if;
3 
4 template< bool B, class T = void >
5 using enable_if_t = typename enable_if<B,T>::type;

enable_if 的主要作用就是当某个 成立时,enable_if可以提供某种类型。但是当 不满足的时候,enable_if<>::type 就是未定义的,当用到模板相关的场景时,只会实例化失败,不会编译错误。

对于上面的例子,意思就是,如果R的基类是BaseHandle,那返回的类型就是std::share_ptr<R>,否则返回的类型是未定义的,也就是说resource函数模板会实例化失败,程序运行错误。具体可以看:http://en.cppreference.com/w/cpp/types/enable_if

那如果实例化失败那程序不就挂了,所以作者又给了下面的一段实现:

源码11  loop.hpp  266-270

1 template<typename R, typename... Args>
2     std::enable_if_t<not std::is_base_of<BaseHandle, R>::value, std::shared_ptr<R>>
3     resource(Args&&... args) {
4         return R::create(shared_from_this(), std::forward<Args>(args)...);
5     }

意思就是如果R的基类不是BaseHandle就用这个函数模板,这个函数模板里就没有源码10中的对init的调用,可见作者还是考虑的非常详尽的。

 

下一篇

下一篇就来看一下项目中其他文件中的一些东西,看看有没什么好玩的介绍给大家,可能再写个一两篇就可以结束了。文中有不当或有可改进之处,希望大家不吝赐教,谢谢。

UVW源码漫谈(三)

标签:自己   event   表达   一起   source   elf   nbsp   解释   一个   

原文地址:http://www.cnblogs.com/yxfangcs/p/7607806.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!