Qt QtPromise源码剖析

Promise概念

Promise是一种异步编程的解决方案.

Promises 是用于传递异步计算结果的回调的替代方法.

QtPromise开源模板库

使用Qt框架的朋友如果对异步编程有需求，建议可使用此模板库对异步操作做处理。

下文对QtPromise模板库的源码做一些分析以及其所用到的一些CPP的技巧共同做些探讨。

本文并不会教你如何更好的使用QPromise而是分享其内部实现的思想和流程。

QtPromise模板库中所使用的设计模式
1. QtPromise中的构建模式
a. 一般我们在构造复杂对象时为了简化初始化通常会把多个成员属性拆分成多个set/with成员方法来用于构造对象。

b. 同样为了让QPromise的调用更加符合Promise风格和达到链式调用的目的。QPromise类对外接口也都是基于此模式的变种。

QPromise 父类QPromiseBase源码示例：

 1 // 摘自QPromise类的部分成员函数声明
 2 template<typename T>
 3 class QPromiseBase {
 4     template<typename TFulfilled, typename TRejected>
 5     inline typename QtPromisePrivate::PromiseHandler<T, TFulfilled>::Promise
 6     then(const TFulfilled& fulfilled, const TRejected& rejected) const;
 7  
 8     template<typename TFulfilled>
 9     inline typename QtPromisePrivate::PromiseHandler<T, TFulfilled>::Promise
10     then(TFulfilled&& fulfilled) const;
11  
12     template<typename TRejected>
13     inline typename QtPromisePrivate::PromiseHandler<T, std::nullptr_t>::Promise
14     fail(TRejected&& rejected) const;
15  
16     template<typename THandler>
17     inline QPromise<T> finally(THandler handler) const;
18  
19     template<typename THandler>
20     inline QPromise<T> tap(THandler handler) const;
21  
22     template<typename THandler>
23     inline QPromise<T> tapFail(THandler handler) const;
24  
25     template<typename E = QPromiseTimeoutException>
26     inline QPromise<T> timeout(int msec, E&& error = E{}) const;
27  
28     template<typename E = QPromiseTimeoutException>
29     inline QPromise<T> timeout(std::chrono::milliseconds msec, E&& error = E{}) const;
30  
31     inline QPromise<T> delay(int msec) const;
32     inline QPromise<T> delay(std::chrono::milliseconds msec) const;
33  
34     inline QPromise<T> wait() const;
35 };

我们看到QPromiseBase大部分函数都返回了QPromise实例对象符合构建模式的思想但与构建模式又存在一定区别，构建模式的设置方法是作用于同一对象且返回的也是同一对象。但QPromiseBase中每次返回是一个新的Promise实例对象。

2. QtPromise中的装饰模式
a. 业务逻辑请使用组合方式来实现。 -- 摘自微服务架构设计模式一书

组合模式带来的好处：

类型间更弱的耦合
运行期灵活性更好，能够根据业务需要随时替换组合对象
对于客户代码更加友好
b. 基于PromiseResolver的装饰

我们先来看看PromiseResolver类的源码

  1 template<typename T>
  2 class PromiseResolver
  3 {
  4 public:
  5     PromiseResolver(QtPromise::QPromise<T> promise) : m_d{new Data{}}
  6     {
  7         m_d->promise = new QtPromise::QPromise<T>{std::move(promise)};
  8     }
  9  
 10     template<typename E>
 11     void reject(E&& error)
 12     {
 13         auto promise = m_d->promise;
 14         if (promise) {
 15             Q_ASSERT(promise->isPending());
 16             promise->m_d->reject(std::forward<E>(error));
 17             promise->m_d->dispatch();
 18             release();
 19         }
 20     }
 21  
 22     void reject()
 23     {
 24         auto promise = m_d->promise;
 25         if (promise) {
 26             Q_ASSERT(promise->isPending());
 27             promise->m_d->reject(QtPromise::QPromiseUndefinedException{});
 28             promise->m_d->dispatch();
 29             release();
 30         }
 31     }
 32  
 33     template<typename V>
 34     void resolve(V&& value)
 35     {
 36         auto promise = m_d->promise;
 37         if (promise) {
 38             Q_ASSERT(promise->isPending());
 39             promise->m_d->resolve(std::forward<V>(value));
 40             promise->m_d->dispatch();
 41             release();
 42         }
 43     }
 44  
 45     void resolve()
 46     {
 47         auto promise = m_d->promise;
 48         if (promise) {
 49             Q_ASSERT(promise->isPending());
 50             promise->m_d->resolve();
 51             promise->m_d->dispatch();
 52             release();
 53         }
 54     }
 55  
 56 private:
 57     struct Data : public QSharedData
 58     {
 59         QtPromise::QPromise<T>* promise = nullptr;
 60     };
 61  
 62     QExplicitlySharedDataPointer<Data> m_d;
 63  
 64     void release()
 65     {
 66         Q_ASSERT(m_d->promise);
 67         Q_ASSERT(!m_d->promise->isPending());
 68         delete m_d->promise;
 69         m_d->promise = nullptr;
 70     }
 71 };
 72  
 73 //
 74  
 75 template<class T>
 76 class QPromiseResolve
 77 {
 78 public:
 79     QPromiseResolve(QtPromisePrivate::PromiseResolver<T> resolver) : m_resolver{std::move(resolver)}
 80     {
 81         qDebug() << "QPromiseResolve";
 82     }
 83  
 84  
 85     ~QPromiseResolve() {
 86         qDebug() << "~QPromiseResolve";
 87     }
 88  
 89     template<typename V>
 90     void operator()(V&& value) const
 91     {
 92         m_resolver.resolve(std::forward<V>(value));
 93     }
 94  
 95     void operator()() const { m_resolver.resolve(); }
 96  
 97 private:
 98     mutable QtPromisePrivate::PromiseResolver<T> m_resolver;
 99 };
100  
101 template<class T>
102 class QPromiseReject
103 {
104 public:
105     QPromiseReject(QtPromisePrivate::PromiseResolver<T> resolver) : m_resolver{std::move(resolver)}
106     { }
107  
108     template<typename E>
109     void operator()(E&& error) const
110     {
111         m_resolver.reject(std::forward<E>(error));
112     }
113  
114     void operator()() const { m_resolver.reject(); }
115  
116 private:
117     mutable QtPromisePrivate::PromiseResolver<T> m_resolver;
118 };

从源码分析我们知道PromiseResolver的功能比较简单单一，持有一个QPromise实例，对客户代码提供操作成功和失败的方法进而把外部操作结果转发到持有的promise实例内部处理。

QPromise为了达到更加简单易用的方式(更加符合现代的函数式编程范式)以及语义上更加符合Promise风格，继续定义了QPromiseResolve&QPromiseReject类用来单独处理成功和失败的情况。我们看这三者类并不是教科书上的标准的装饰模式，但实际上QPromiseResolve&QPromiseReject类的实现组合PromiseResolver实例，重载调用()运算符(使其成为一个可调用对象)内部转发对PromiseResolver的调用基本符合了装饰模式的思想只是缺少了基类接口的存在，对外缺少统一调用接口但()操作符的重载很好的弥补了这一缺陷。

PromiseResolver&QPromiseResolve&QPromiseReject UML 类图

从Promise的使用情况看，对于客户代码只需要关心在处理结果时对于QPromiseResolve&QPromiseReject调用操作，由于QPromiseResolve&QPromiseReject类组合PromiseResolver，持有QPromise对象且存在整个QPromise执行链中。个人在这将PromiseResolver&QPromiseResolve&QPromiseReject 统一称作QPromise上下文类。

QtPromise模板库中使用到的元编程技巧
由于QtPromise是一个轻量级的模板库，内部用到了大量模板元技术。故在分析QtPromise源码前我们需对QtPromise中用到的CPP模板元技巧概念做些介绍

1. 模板元函数
a. 元函数函数特征&定义

元函数并不是一个传统的语言函数，它通常是一个struct或class.
通常返回一个或多个类型
元函数并不是语言的一部分也没有正式的语言支持它
它们作为现有语言功能的惯用用法而存在
它们的使用不是由语言强制执行的
b. 值元函数&型别元函数

值元函数通常返回一个值

1 template<class T>
2 class ValueMetaFunction {
3     static constexpr int value = 100;
4 };

我们声明&定义了一个名为ValueMetaFunction的元函数，返回了一个value为int的值.

值元函数的plus版本

1 template<auto T>
2 class ValueMetaFunction {
3     static constexpr auto value = 100;
4 };
5  
6 template<class T, T value>
7 class ValueMetaFunction {
8     static constexpr T value = value
9 };

型别元函数通常返回一个类型

1 template<class T>
2 class TypeMetaFunction {
3     using type = T;
4 };

声明&定义一个名为TypeMetaFunction的元函数，返回了一个型别为T的type类型

c. 元函数的调用

针对于上述的示例代码我们现在来获取元函数的返回值

1 ValueMetaFunction<int>::value
2 ValueMetaFunction<int, 100>::value
3 TypeMetaFunction<int>::type  --> typename TypeMetaFunction<int>::type

我们在调用元函数返回值时一般书写都比较长,阅读起来也比较不友好。CPP提供了using关键字可以用于定义更加便捷的调用方式。

使用using关键字为模板(元函数)定义别名。

通常value元函数使用以 _v结尾的变量模板

1 template<typename T>
2 using value_v = ValueMetaFunction<T>::value

通常type 元函数使用以 _t结尾的变量模板

1 template<typename T>
2 using type_t = typename ValueMetaFunction<T>::type

使用便捷的调用方式

1 value_v<int>
2 type_t<int>

d. 一个有用的元函数

 1 // STRUCT TEMPLATE integral_constant
 2 template <class _Ty, _Ty _Val>
 3 struct integral_constant {
 4     static constexpr _Ty value = _Val;
 5  
 6     using value_type = _Ty;
 7     using type       = integral_constant;
 8  
 9     constexpr operator value_type() const noexcept {
10         return value;
11     }
12  
13     _NODISCARD constexpr value_type operator()() const noexcept {
14         return value;
15     }
16 };
17  
18 // ---摘自MSVC xtr1commom文件

integral_constant应用于在系统位数判断上

1 static const std::uint64_t default_buffer_size = 
2 std::conditional<sizeof(void *) == 8,  
3                  std::integral_constant<std::uint64_t, 100 * 1024 * 1024>,   
4                  std::integral_constant<std::uint64_t, 1024 * 1024 * 1024>
5                 >::type::value

这样编码的优势：

integral_constant、sizeof(void *) == 8 数值等都在编译期执行计算不占用运行时开销。
default_buffer_size 可在编译时优化成一个编译常量控件在编译时就完成分配，提升程序运行时效率。
2. 全特化&偏特化构建if-then-else
模板的全特化与偏特化特性构建出了元编程中的条件判断

模板偏特化&全特换的示例:

 1 // 标准模板
 2 template<typename T, typename U>
 3 struct Sample {};
 4  
 5 // 对于T为指针的偏特化
 6 template<typename T, typename U>
 7 struct Sample<T*, U> {};
 8  
 9 // 对于T为int的偏特化
10 template<typename U>
11 struct Sample<int, U> {};
12  
13 // 对于T&U都为int类型的全特化 
14 template<>
15 struct Sample<int, int> {};

声明if-then-else:

1 template< bool CONDITION, class THEN, class ELSE > struct IF {};
2  
3 template<class THEN, class ELSE> struct IF< false, THEN, ELSE > {typedef ELSE TEST;};
4  
5 template<class THEN, class ELSE> struct IF< true, THEN, ELSE > {typedef THEN TEST;};

if-then-else SampleCode:

 1 template< bool Condition >
 2 class IF {
 3 public:
 4     static inline void EXEC(){std::cout << "Statement is true";}
 5 };
 6  
 7 // 全特化IF模板，当模板参数为false时匹配该版本
 8 class IF< false > {
 9 public:
10     static inline void EXEC(){std::cout << "Statement is false";}
11 };
12  
13 std::cout << IF<sizeof(void*) == 8>::EXEC（）<< std::endl;

3. Type Traits 类型特征
a. type traits是什么？

它是C++泛型编程的支柱之一
检查与转换类型的属性
它通常是一个简单的模板结构
b. MSVC中的type_traits文件中定义了大量常用的类型特征模板

下图摘自<type_traits> - C++ Reference部分

具体说明及用法大家可以点击链接进行查看。上述类型特性模板在常见的模板设计程序中会经常有使用到。

c. call_traits

示例

 1 // CLASS TEMPLATE binder1st
 2 template <class _Fn>
 3 class binder1st : public unary_function<typename _Fn::second_argument_type,
 4                       typename _Fn::result_type> { // functor adapter _Func(stored, right)
 5 public:
 6     using _Base         = unary_function<typename _Fn::second_argument_type, typename _Fn::result_type>;
 7     using argument_type = typename _Base::argument_type;
 8     using result_type   = typename _Base::result_type;
 9  
10     binder1st(const _Fn& _Func, const typename _Fn::first_argument_type& _Left) : op(_Func), value(_Left) {}
11  
12     // @1
13     result_type operator()(const argument_type& _Right) const {
14         return op(value, _Right);
15     }
16  
17     result_type operator()(argument_type& _Right) const {
18         return op(value, _Right);
19     }
20  
21 protected:
22     _Fn op;
23     typename _Fn::first_argument_type value; // the left operand
24 };
25  
26  
27 // -- 摘自MSVC functional头文件

MSVC实现的binder1st 结构中存在着如果代码段@1中 argument_type如果是个引用类型，则binder1st重载()调用运算符存在引用引用的的问题。这在C++中是不被允许的

call_traits 工具 -- 摘自boost程序库

call_traits 的目的是确保像“引用引用”这样的问题永远不会发生，并且以最有效的方式传递参数。

 1 template <typename T, bool small_>
 2 struct ct_imp2 {
 3     typedef const T& param_type;
 4 };
 5  
 6 template <typename T>
 7 struct ct_imp2<T, true> {
 8     typedef const T param_type;
 9 };
10  
11 template <typename T, bool isp, bool b1, bool b2>
12 struct ct_imp {
13     typedef const T& param_type;
14 };
15  
16 template <typename T, bool isp, bool b2>
17 struct ct_imp<T, isp, true, b2> {
18     typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
19 };
20  
21 template <typename T, bool isp, bool b1>
22 struct ct_imp<T, isp, b1, true> {
23     typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
24 };
25  
26 template <typename T, bool b1, bool b2>
27 struct ct_imp<T, true, b1, b2> {
28     typedef const T param_type;
29 };
30  
31  
32 template <typename T>
33 struct call_traits
34 {
35 public:
36     typedef T value_type;
37     typedef T& reference;
38     typedef const T& const_reference;
39     typedef typename ct_imp<
40         T,
41         ::boost::is_pointer<T>::value,
42         ::boost::is_arithmetic<T>::value,
43         ::boost::is_enum<T>::value
44     >::param_type param_type;
45 };
46  
47 template <typename T>
48 struct call_traits<T&>
49 {
50     typedef T& value_type;
51     typedef T& reference;
52     typedef const T& const_reference;
53     typedef T& param_type;  // hh removed const
54 };
55 template <typename T>
56 struct call_traits<T& const>
57 {
58     typedef T& value_type;
59     typedef T& reference;
60     typedef const T& const_reference;
61     typedef T& param_type;  // hh removed const
62 };
63  
64  
65 // 摘自boost程序库 call_traits.hpp 部分

binder1st 对于调用操作符的重载最终可修改为

1 result_type operator()(typename call_traits<argument_type>::param_type _Right) const {
2     return op(value, _Right);
3 }

b. QtPromise中的型别特性的应用

QtPromise中定义了ArgsTraits元函数用于提取函数的形参列表元信息。

 1 template<typename... Args>
 2 struct ArgsTraits
 3 {
 4     using types = std::tuple<Args...>;
 5     // 返回函数参数列表第一个形参的类型
 6     using first = typename std::tuple_element<0, types>::type;
 7     // 返回函数参数列表的形参数量
 8     static const size_t count = std::tuple_size<types>::value;
 9 };
10  
11 // 全特化参数列表为空的情况
12 template<>
13 struct ArgsTraits<>
14 {
15     using types = std::tuple<>;
16     using first = void;
17     static const size_t count = 0;
18 };
19  
20  
21 // -- 摘自 qpromiseglobal.h 头文件

定义ArgsTraits的扩展类ArgsOf元函数，由ArgsTraits的声明可知，ArgsTraits元函数接收的是有个类型参数包。扩展类ArgsOf的作用则用于收集函数列表类型信息。

 1 // 标准的ArgsOf类型的声明定义
 2 template<typename T, typename Enabled = void>  struct ArgsOf : public ArgsTraits<> { };
 3  
 4 // 对nullptr_t的偏特化
 5 template<> struct ArgsOf<std::nullptr_t> : public ArgsTraits<>{ };
 6  
 7 // 对operator () 成员函数指针偏特化
 8 template<typename T> 
 9 struct ArgsOf<T, typename std::enable_if<HasCallOperator<T>::value>::type>: public ArgsOf<decltype(&T::operator())> { };
10  
11 // 对引用类型的偏特化
12 template<typename T> struct ArgsOf<T&> : public ArgsOf<T> { };
13 // 对右值类型的偏特化
14 template<typename T> struct ArgsOf<T&&> : public ArgsOf<T> { };
15  
16 // 对可调用类型的偏特化
17 template<typename R, typename... Args> struct ArgsOf<R(Args...)> : public ArgsTraits<Args...> { };
18  
19 // 对函数指针的偏特化
20 template<typename R, typename... Args> struct ArgsOf<R (*)(Args...)> : public ArgsTraits<Args...> { };
21  
22 // 对成员函数指针偏特化
23 template<typename R, typename T, typename... Args> struct ArgsOf<R (T::*)(Args...)> : public ArgsTraits<Args...> { };
24  
25 // 对const的成员函数指针偏特化 @7
26 template<typename R, typename T, typename... Args> struct ArgsOf<R (T::*)(Args...) const> : public ArgsTraits<Args...> { };
27  
28 // 对volatile的成员函数指针偏特化 @8
29 template<typename R, typename T, typename... Args> struct ArgsOf<R (T::*)(Args...) volatile> : public ArgsTraits<Args...> { };
30  
31 // 偏特化类型T为 const volatile的成员函数指针 @9
32 template<typename R, typename T, typename... Args> struct ArgsOf<R(T::*)(Args...) const volatile> : public ArgsTraits<Args...> { };
33  
34 // -- 摘自 qpromiseglobal.h 头文件

我们看到ArgsOf对于大部分函数指针类型的情况都进行了偏特化从而对特定的函数形参列表参数包进行提取，进而传递给其父类。完成对函数形参列表信息的提取。

我们其实发现ArgsOf作用紧紧是用于提取函数的形参列表类型，至于类的成员函数是否是 const、volatile、const volatile等类型是不关心的。但为了满足类的成员函数所有类型的提取则必须尽可能的偏特化出所有成员函数类型的ArgsOf版本见代码段@7& 8 & 9。细心的读者可能会发现ArgsOf对于类的成员函数形参列表类型的元信息提取其实是不全的，因为ArgsOf并没有偏特化全部的成员函数类型。例如 const&、const&&、const volatile&、const volatile&&、volatile&、volatile&&成员函数类型就没有进行偏特化，对于这一类型的成员函数类型在编译器实例化ArgsOf时会去匹配标准的ArgsOf版本所以函数形参列表会作为空处理。

如果你的项目中有上述提到的未偏特化的成员函数则在使用QPromise时就出现错误了。我们该如何去优化以下ArgsOf呢？

项目开发中我们可以提供一个基础的大而全的type_traits, 用于提取裸函数类型。无论你是否使用QtPromise模板库，至少在项目其他需求中也是可以作为一个基础类而存在的。

提供一个is_const_or_volatile_member_function 成员函数类型特征工具类，声明定义如下：

 1 template <typename T>
 2 struct is_const_or_volatile_member_function : std::false_type { };
 3  
 4 template <typename R, typename T, typename... Args>
 5 struct is_const_or_volatile_member_function<R(T::*)(Args...) const> : std::true_type{
 6     using type = R(T::*)(Args...);
 7 };
 8 template <typename R, typename T,  typename... Args>
 9 struct is_const_or_volatile_member_function<R(T::*)(Args...) const&> : std::true_type {
10     using type = R(T::*)(Args...);
11 };
12 template <typename R, typename T, typename... Args>
13 struct is_const_or_volatile_member_function<R(T::*)(Args...) const&&> : std::true_type {
14     using type = R(T::*)(Args...);
15 };
16 template <typename R, typename T, typename... Args>
17 struct is_const_or_volatile_member_function<R(T::*)(Args...) const volatile> : std::true_type {
18     using type = R(T::*)(Args...);
19 };
20 template <typename R, typename T, typename... Args>
21 struct is_const_or_volatile_member_function<R(T::*)(Args...) const volatile&> : std::true_type {
22     using type = R(T::*)(Args...);
23 };
24 template <typename R, typename T, typename... Args>
25 struct is_const_or_volatile_member_function<R(T::*)(Args...) const volatile&&> : std::true_type {
26     using type = R(T::*)(Args...);
27 };
28 template <typename R, typename T, typename... Args>
29 struct is_const_or_volatile_member_function<R(T::*)(Args...) volatile> : std::true_type {
30     using type = R(T::*)(Args...);
31 };
32 template <typename R, typename T, typename... Args>
33 struct is_const_or_volatile_member_function<R(T::*)(Args...) volatile&> : std::true_type {
34     using type = R(T::*)(Args...);
35 };
36 template <typename R, typename T, typename... Args>
37 struct is_const_or_volatile_member_function<R(T::*)(Args...) volatile&&> : std::true_type {
38     using type = R(T::*)(Args...);
39 };

is_const_or_volatile_member_function偏特化出了成员函数的所有的类型，且继承与std::false_type or std::true_type用于给出一个bool值判断传入的类型是否为成员函数类型。最终返回一个裸成员函数指针类型type(此处裸代表成员函数是非 const、 const&、const&&、const volatile、const volatile&、const volatile&&、volatile、volatile&、volatile&& 类型)

is_const_or_volatile_member_function使用：

这里对于之前ArgsOf定义的代码段@7、8、9 统一可以修改为下图的代码段@2。这样可以由is_const_or_volatile_member_function元函数去提取所有的非裸成员函数类型也节省了ArgsOf偏特化的版本数量。

 1 // @1
 2 // 对指针成员函数类型的偏特化
 3 template<typename R, typename T, typename... Args>
 4 struct ArgsOf<R(T::*)(Args...)> : public ArgsTraits<Args...>
 5 {
 6     static constexpr char* value = "R(T::*)(Args...)";
 7 };
 8  
 9 // @2
10 // 对 const、 const&、const&&、const volatile、const volatile&、
11 // const volatile&&、volatile、volatile&、volatile&& 成员函数指针偏特化
12 template<typename T>
13 struct ArgsOf <T, std::enable_if_t<is_const_or_volatile_member_function<T>::value> >: 
14     public ArgsOf<typename is_const_or_volatile_member_function<T>::type>
15 {
16     static constexpr char* value = "R(*)(Args...) const or volatile";
17 };

此处我们来验证下对于优化后ArgsOf的使用

use sample code:

1 qDebug() << ArgsOf<int(TestClass::*)(int, int)>::value;
2 qDebug() << ArgsOf<int(TestClass::*)(int, int) const>::value;
3 qDebug() << ArgsOf<int(TestClass::*)(int, int) const&>::value;
4 qDebug() << ArgsOf<int(TestClass::*)(int, int) volatile>::value;
5 qDebug() << ArgsOf<int(TestClass::*)(int, int) volatile&>::value;
6 qDebug() << ArgsOf<int(TestClass::*)(int, int) const volatile&>::value;

输出：

1 R(T::*)(Args...)
2 R(*)(Args...) const or volatile
3 R(*)(Args...) const or volatile
4 R(*)(Args...) const or volatile
5 R(*)(Args...) const or volatile
6 R(*)(Args...) const or volatile

从输出我们可以分析出非裸成员函数指针类型都匹配到上述代码段@2的ArgsOf偏特化版本，裸成员函数类型匹配到了代码段@1的ArgsOf偏特化版本。至此我们完成了对QtPromise模板库中ArgsOf的偏特化类的成员函数类型不足的优化。

4. SFINAE
a. SFINAE 是什么?

替换失败不是错误(Substitution failure is not an error)
如果你重载一个函数并调用它，只要有一个重载是有效的。其他重载可以默认失败, 在所有重载函数选择最佳匹配。
对于需要重载多个函数是非常有用的
b. SFINAE 能做什么?

检查一个类中是否含有成员XXMember
检查一个结构中是否定义函数XXFunction
一个类型能做什么
编译时的布尔值检查/条件编译
c. SFINAE在QtPromise中的应用

检查一个类中是否函数成员函数

 1 template<typename T>
 2 struct HasCallOperator 
 3 {
 4     template<typename U>
 5     static char check(decltype(&U::operator(), char(0)));
 6  
 7     template<typename U>
 8     static char (&check(...))[2];
 9     static const bool value = (sizeof(check<T>(0)) == 1);
10 };
11  
12 // -- 摘自qpromiseglobal.h文件

QPromiseBase构造函数重载

1 template<typename F, typename std::enable_if<QtPromisePrivate::ArgsOf<F>::count == 1, int>::type = 0>
2 inline QPromiseBase(F resolver);
3 template<typename F,typename std::enable_if<QtPromisePrivate::ArgsOf<F>::count != 1, int>::type = 0>
4 inline QPromiseBase(F resolver);

根据实参类型中的形参列表数量编译器来进行最佳的构造函数生成。

QtPromise源码分析和实现思想

1. QtPromise的UML 时序图

下面我结合此时序图对QtPromise 源码的主要流程进行分析

2. QtPromise源码分析

a. QPromise的构造&生命周期

先看一个基本的使用QPromise Sample Code:

1 {
2     QPromise<std::string> promise = QPromise<int>([](QPromiseResolve<int> resolve, QPromiseReject<int> reject) {
3         // @1
4         resolve(100)
5     }).then([](int) -> std::string {
6         return "100";
7     });
8 }

上述代码段构建了一个基本的Promise链式调用并返回链式最后一个QPromise实例，不知道大家在使用QPromise时有没有这样的一个疑问，就是在上述代码段执行完成后promise实例都销毁了。它是如何保证异步继续执行下有个then方法函数体的？？？随着我们对QPromise对象的构造分析慢慢来解答这个问题。

QPromise构造函数分析

 1 template<typename T>
 2 class QPromiseBase
 3 {
 4 public:
 5     using Type = T;
 6  
 7     // @1
 8     template<typename F,
 9              typename std::enable_if<QtPromisePrivate::ArgsOf<F>::count == 1, int>::type = 0>
10     inline QPromiseBase(F resolver) :  m_d{new QtPromisePrivate::PromiseData<T>{}} 
11     {
12         // @6
13         QtPromisePrivate::PromiseResolver<T> resolver{*this};
14  
15         try {
16             // @4
17             callback(QPromiseResolve<T>(resolver));
18         } catch (...) {
19             resolver.reject(std::current_exception());
20         }
21     }
22  
23     // @2
24     template<typename F,
25              typename std::enable_if<QtPromisePrivate::ArgsOf<F>::count != 1, int>::type = 0>
26     inline QPromiseBase(F resolver) : m_d{new QtPromisePrivate::PromiseData<T>{}} 
27     {
28         // @7
29         QtPromisePrivate::PromiseResolver<T> resolver{*this};
30  
31         try {
32             // @5
33             callback(QPromiseResolve<T>(resolver), QPromiseReject<T>(resolver));
34         } catch (...) {
35             resolver.reject(std::current_exception());
36         }
37     }
38 };
39  
40 template<typename T>
41 class QPromise : public QPromiseBase<T>
42 {
43 public:
44     // @3
45     template<typename F>
46     QPromise(F&& resolver) : QPromiseBase<T>(std::forward<F>(resolver)) {
47     }
48 };

QPromise构造函数接收一个任意实参(形参类型为万能引用类型)，但通常为一个可调用对象(函数指针、成员函数、Lambda表达式、重载()运算符的类、std::function). 从上图代码段@4&5中我们不难发现此规则，且该调用对象的形参数量必须为1或者2 ，为1时形参类型必须为QPromiseResolve、为2是形参类型为QPromiseResolve&QPromiseReject。
QPromise将万能引用形参resolver作为实参转发到父类QPromiseBase的构造函数上。上图代码段@3 对万能引用类型使用std::forward进行转发(参考effective modern C++)。
QPromiseBase存在代码段@1&2 两个模板函数重载版本 (参考上文的SFINA)，最终选择哪个版本则根据上文介绍的ArgsOf类型特性模板来提取类型F的参数列表数量，如果为1则匹配代码段@1否则匹配代码段@2。
QPromiseBase函数体实现：代码段@6&7 构造上下文类PromiseResolver局部对象，将自己的控制权交由PromiseResolver对象。基于PromiseResolver对象构造QPromiseResolve 或 QPromiseResolve&QPromiseReject(根据构造QPromise对象时的实参(可调用类型)的形参数量决定)。
QPromise的构造过程中会立马对构造实参进行回调，进而进入到客户代码的函数栈中。当客户代码调用形参1或者2 则相当于把操作结果交到的QPromise上下文类中。
我们此处仅对操作做成功的情况讨论其他流程基本一致，结合QPromise Sample Code(本节开头处的示例)进行流程梳理.
当客户代码将操作结果100 通知到QPromiseResolve 对象， resolve对结果进行转发，进而调用装饰对象QPromiseResolver的resolve函数，个人认为该方法没必要为模板方法，形参类型为T就行。

 1     template<typename V>
 2     void resolve(V&& value)
 3     {
 4         auto promise = m_d->promise;
 5         if (promise) {
 6             Q_ASSERT(promise->isPending());
 7             promise->m_d->resolve(std::forward<V>(value));
 8             promise->m_d->dispatch();
 9             release();
10         }
11     }

promise->m_d->resolve(std::forward<V>(value)); 将客户代码的操作结果存入到成员属性m_d
promise->m_d->dispatch(); 把当前结果已异步的方式分发到下个待处理的QPromise对象
release(); 释放当前上下文持有的QPromise堆对象，所以在QPromise构造函数中回调用户代码时，用户代码应该调用resolve或者reject 避免内存泄漏。
相信看到此处我们知道QtPromise内部是如何保证其生命周期了。

得益于PromiseResolver上下文对QPromise封装，其副本已保存在上下文类中，其生命周期的长短取决于客户代码对resolve与reject的调用。
保证后续方法得以执行则是依赖Qt event runloop机制。 Event 封装可调用对象(内部为Lambda)基于异步事件实现异步链式调用。
请保证在一定要执行resolve与reject可调用对象，不然会有内存泄漏。
QPromise then核心函数分析

then提供了接收下一步(异步)处理的函数入口(下文中称nextPromise对象)

then函数体源码

 1 template<typename T>
 2 template<typename TFulfilled, typename TRejected>
 3 inline typename QtPromisePrivate::PromiseHandler<T, TFulfilled>::Promise
 4 QPromiseBase<T>::then(const TFulfilled& fulfilled, const TRejected& rejected) const
 5 {
 6     using namespace QtPromisePrivate;
 7     // @1
 8     using PromiseType = typename PromiseHandler<T, TFulfilled>::Promise;
 9     // @2
10     PromiseType next([&](const QPromiseResolve<typename PromiseType::Type>& resolve,
11                          const QPromiseReject<typename PromiseType::Type>& reject) {
12         // @3
13         m_d->addHandler(PromiseHandler<T, TFulfilled>::create(fulfilled, resolve, reject));
14         m_d->addCatcher(PromiseCatcher<T, TRejected>::create(rejected, resolve, reject));
15     });
16  
17     if (!m_d->isPending()) {
18         m_d->dispatch();
19     }
20  
21     return next;
22 }
23  
24 template<typename T>
25 template<typename TFulfilled>
26 inline typename QtPromisePrivate::PromiseHandler<T, TFulfilled>::Promise
27 QPromiseBase<T>::then(TFulfilled&& fulfilled) const
28 {
29     return then(std::forward<TFulfilled>(fulfilled), nullptr);
30 }

then函数形参通常接收有个可调用对象
代码段@1 通过PromiseHandler型别特征提取当前待返回Promise的模板类型与返回类型，参考使用QPromise Sample Code示例，PromiseType为QPromise<std::string>。
构造局部对象QPromise 并立即执行实参Lambda表达式。
通过PromiseHandler 创建可调用对象(std::function)并将当前then的形参以及nextPromise下的上下文保存在该可调用对象中

 1 // PromiseHandler标准版
 2 template<typename T, typename THandler, typename TArg = typename ArgsOf<THandler>::first>
 3 struct PromiseHandler
 4 {
 5     using ResType = typename invoke_result<THandler, T>::type;
 6     using Promise = typename PromiseDeduce<ResType>::Type;
 7  
 8     template<typename TResolve, typename TReject>
 9     static std::function<void(const T&)>
10     create(const THandler& handler, const TResolve& resolve, const TReject& reject)
11     {
12         return [=](const T& value) {
13             PromiseDispatch<ResType>::call(resolve, reject, handler, value);
14         };
15     }
16 };

将PromiseHandler构建的可调用对象保存在当前的成员属性QPromiseData中

返回Promise对象继续以链式的方式接收下一个处理者

c. QPromiseData结构&Promise链式内存模型

QPromise 类从其父类PromiseBase继承了唯一的数据属性成员m_d。

QExplicitlySharedDataPointer<QtPromisePrivate::PromiseData<T>> m_d;

QPromiseData结构, 下图源码仅给出了Promise成员属性，

 1 template<typename T, typename F>
 2 class PromiseDataBase : public QSharedData {
 3 public:
 4     using Handler = std::pair<QPointer<QThread>, std::function<F>>;
 5     using Catcher = std::pair<QPointer<QThread>, std::function<void(const PromiseError&)>>;
 6 protected:
 7     mutable QReadWriteLock m_lock;
 8     
 9 private:
10     bool m_settled = false;
11     // 异步事件完成后下一步需要调用的可调用对象集合(及nextPromise的封装) 
12     QVector<Handler> m_handlers;
13     // 出错处理情况
14     QVector<Catcher> m_catchers;
15     PromiseError m_error;
16  
17 };
18  
19  
20 template<typename T>
21 class PromiseData : public PromiseDataBase<T, void(const T&)> {
22     using Handler = typename PromiseDataBase<T, void(const T&)>::Handler;
23 private:
24     
25     // 当前Promise处理(返回)的值交由PromiseValue自动管理其生命周期
26     PromiseValue<T> m_value;
27 };
28  
29 // 全特化QPromise返回值类型为void的case
30 template<>
31 class PromiseData<void> : public PromiseDataBase<void, void()>
32 {
33     using Handler = PromiseDataBase<void, void()>::Handler;
34 }
35  
36  
37 // 对数据T使用RAII手法来管理其生命周期
38 template<typename T>
39 class PromiseValue
40 {
41 public:
42     PromiseValue() { }
43     PromiseValue(const T& data) : m_data(QSharedPointer<T>::create(data)) { }
44     PromiseValue(T&& data) : m_data(QSharedPointer<T>::create(std::forward<T>(data))) { }
45     bool isNull() const { return m_data.isNull(); }
46     const T& data() const { return *m_data; }
47  
48 private:
49     QSharedPointer<T> m_data;
50 };

从Promise类的属性成员 QPromiseData的结构我们可以给出其内存模型

QPromiseResolve&QPromiseReject为PromiseResolver的装饰对象。

PromiseResolver是一个携带QPromise对象的上下文，即handler与catcher callable对象中成员属性resolve、reject装饰对象分别又指向了QPromiseData对象即形成了QPromise 链式内存模式。

d. QPromise 上下文类的作用

封装QtPromise链式头对象，专注于首次结果。
隔离客户代码与QPromise的关联，让客户代码调用更加简单只需要关心结果即可。
转移QPromise对象生命周期，并由客户代码来管理QPromise生命周期。
简化客户业务代码，分离成功与失败逻辑，依赖Qt显示共享技术。
e. Qt消息循环实现Promise非阻塞调用

 1 template<typename F>
 2 static void qtpromise_defer(F&& f, const QPointer<QThread>& thread)
 3 {
 4     using FType = typename std::decay<F>::type;
 5  
 6     struct Event : public QEvent
 7     {
 8         Event(FType&& f) : QEvent{QEvent::None}, m_f{std::move(f)} { }
 9         Event(const FType& f) : QEvent{QEvent::None}, m_f{f} { }
10         ~Event() override { m_f(); }
11         FType m_f;
12     };
13  
14     if (!thread || thread->isFinished()) {
15         // Make sure to not call `f` if the captured thread doesn't exist anymore,
16         // which would potentially result in dispatching to the wrong thread (ie.
17         // nullptr == current thread). Since the target thread is gone, it should
18         // be safe to simply skip that notification.
19         return;
20     }
21  
22     QObject* target = QAbstractEventDispatcher::instance(thread);
23     if (!target && QCoreApplication::closingDown()) {
24         // When the app is shutting down, the even loop is not anymore available
25         // so we don't have any way to dispatch `f`. This case can happen when a
26         // promise is resolved after the app is requested to close, in which case
27         // we should not trigger any error and skip that notification.
28         return;
29     }
30  
31     Q_ASSERT_X(target, "postMetaCall", "Target thread must have an event loop");
32     QCoreApplication::postEvent(target, new Event{std::forward<F>(f)});
33 }

Promise完成异步调用最终函数体，依赖Qt异步消息机制。下一个待处理的可调用对象(Lambda表达式)封装着nextPromise的上下文对象。

F: HandlerCallable

Event: 自定义QEvent携带Callable基于消息循环异步调用nextPromise

thread: 保证线程单一性

设计模式与元编程的混合
对于喜欢元编程的读写朋友在这里推荐去阅读Loki 库的源码，其中对于元编程的各项技巧都有深入涉及。Loki主要使用模板元编程去实现通用的设计模式。看看模板元编程与设计模式在一起组合会碰撞出什么样的火花。 (#^.^#)

1. 元编程与单例模式sampleCode
策略结构的定义

对象创建策略结构

1 template <class T> struct CreateUsingNew {
2     static T* Create() {
3         return new T;
4     }
5     static void Destroy(T* p) {
6         delete p;
7     }
8 };

对象生命周期策略结构

1 template <class T>
2 struct DefaultLifetime {
3     static void ScheduleDestruction(T*, atexit_pfn_t pFun) {
4         std::atexit(pFun);
5     }
6     static void OnDeadReference() {
7         throw std::logic_error("Dead Reference Detected");
8     }
9 };

单例构造模板类的定义

模板单例类接收两个默认的创建对象以及生命周期管理类型。实例化时用户代码可重新扩展该策略类型。

以上内容摘自Loki库，为做简单示例有简化该单例模式构造模板类。

2. 元编程与其他模式
Loki template Library库还实现了以下模板元与设计模式的混合

抽象工厂模式

工厂模式

访问者模式

至于具体的讲解大家可以阅读modern C++ programming 一书. 此书就是基于Loki库来编写的。

posted on 2023-03-23 13:53 一杯清酒邀明月阅读(664) 评论(0) 编辑收藏举报