chrome task分析

 
多线程编程完全基于消息传递会比较麻烦,因为消息的封装和解析是比较麻烦的。不仅如此,被多个线程调用的其实是同一个对象的不同方法。比如

Cpp代码 复制代码 收藏代码
  1. class Work   
  2. {   
  3.  public:   
  4.     void Start()   
  5.     {   
  6.          //CreateThread ... 创建线程或调用其它异步函数,结束时会调用OnComplete方法   
  7.            
  8.      }   
  9. private:   
  10.     void OnCompleted();    // 会从另一个线程回调该方法。   
  11. }  
class Work
{
 public:
    void Start()
    {
         //CreateThread ... 创建线程或调用其它异步函数,结束时会调用OnComplete方法
        
     }
private:
    void OnCompleted();    // 会从另一个线程回调该方法。
}
 

 


对象Work会被不同的线程所访问,如果内部没有同步的话,则不是线程安全的。OOP封装了数据和操作,但是没有封装执行线程--即可能被不同的线程同时访问! 

对以上代码,我们当然可以为Work设置一个消息接收器,然后从外部向Work对象发送ON_COMPLETE消息,再由消息接收器分发并调用OnComplete,从而保证Work对象是单线程访问的。 在带UI的程序里,我们一般就是这样做的,通过向主窗口PostMessage,然后在消息响应函数里写处理代码。 即便不带UI,我们也可以创建一个隐藏(或者Message Only)的窗口,以把从其它线程来的回调都转到主线程来执行。比如

Cpp代码 复制代码 收藏代码
  1. 另一个线程   
  2. ...   
  3. PostMessage(ON_COMPLETE)   
  4. ...   
  5.   
  6.   
  7. 主线程   
  8.   
  9.   
  10. void OnMessage(msg)   
  11. {   
  12.   switch(msg)   
  13.     {   
  14.         case ON_COMPLETE:   
  15.   
  16.             OnComplete();   
  17.         ......   
  18.     }   
  19. }  
另一个线程
...
PostMessage(ON_COMPLETE)
...


主线程


void OnMessage(msg)
{
  switch(msg)
    {
        case ON_COMPLETE:

            OnComplete();
        ......
    }
}
 

 


但是如果每个类都要创建窗口,实现消息响应函数,还有参数的传递 ... 那就太繁琐了。 这是因为,消息传递的只能是数据,需要接收方在接收到数据后进行解析并调用相关的处理函数,这就需要接收方知道什么消息对应什么处理函数,也就是说必须有大量的case ON_xxx。 但是,如果我们就是想让一段代码在指定线程上执行该怎么办? 特别的,从一个线程里,指定另一个线程执行某指定的代码,也就是说我们想传递的是可执行代码而不是数据。

其实也没有那么复杂,其实我们只要传递一个对象指针,然后接收方执行该对象的方法即可! 当然这要求必须是同一个进程内的,对象指针才有效,这在大多数情形下是不成问题的。 以下就是Chrome的实现方式,使用Task对象。要把代码转到指定线程上执行,要先把代码用Task对象进行封装! Task只有一个对外方法Run,没有参数,所有信息都在创建Task封装进了Task对象内部,接收线程只要执行Task.Run即可。

Cpp代码 复制代码 收藏代码
  1. class Task{   
  2.   // Tasks are automatically deleted after Run is called.   
  3.   virtual void Run() = 0;   
  4. };  
class Task{
  // Tasks are automatically deleted after Run is called.
  virtual void Run() = 0;
};
 

(为了突出重点,我们对代码进行删减,后面就不再一一说明)

有了Task之后,我们就可以如下让主线程(先用main_thread_loop代表)执行workObj的OnComplete方法。

Cpp代码 复制代码 收藏代码
  1. Work* workObj;    
  2. ...   
  3. main_thread_loop->PostTask(NewRunnableMethod(workObj, &Work::OnComplete));    
Work* workObj; 
...
main_thread_loop->PostTask(NewRunnableMethod(workObj, &Work::OnComplete));  

 

下面我们看看Chrome是如何具体实现的。


先看一个典型的用法

 
Cpp代码 复制代码 收藏代码
  1. class MyClass {   
  2.   private:   
  3.    ScopedRunnableMethodFactory<MyClass> some_method_factory_;   
  4.   
  5.   
  6.   public:   
  7.    MyClass() : some_method_factory_(this) { }   
  8.   
  9.   
  10.    void SomeMethod() {   
  11.      some_method_factory_.RevokeAll();   
  12.      ...   
  13.    }   
  14.   
  15.   
  16.    void ScheduleSomeMethod() {   
  17.      // The factories are not thread safe, so always invoke on   
  18.      // |MessageLoop::current()|.   
  19.      MessageLoop::current()->PostDelayedTask(FROM_HERE,   
  20.          some_method_factory_.NewRunnableMethod(&MyClass::SomeMethod),   
  21.          kSomeMethodDelayMS);   
  22.    }   
  23.  };  
class MyClass {
  private:
   ScopedRunnableMethodFactory<MyClass> some_method_factory_;


  public:
   MyClass() : some_method_factory_(this) { }


   void SomeMethod() {
     some_method_factory_.RevokeAll();
     ...
   }


   void ScheduleSomeMethod() {
     // The factories are not thread safe, so always invoke on
     // |MessageLoop::current()|.
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         some_method_factory_.NewRunnableMethod(&MyClass::SomeMethod),
         kSomeMethodDelayMS);
   }
 };
 
我们可以看到MyClass有一个ScopedRunnableMethodFactory类型的成员变量some_method_factory_对象,用于创建指向MyClass方法的Task(RunnableMethod对象)。在ScheduleSomeMethod方法里,我们创建了一个Task用于运行SomeMethod方法,该方法会在当前线程的稍后时间中执行。 一旦MyClass对象被删除,那么some_method_factory_在析构时会首先取消所有还没有执行的Task,避免在MyClass删除后还被另外的线程访问而导致崩溃。 当然也可以随时取消Task,即如上所示调用ScopedRunnableMethodFactory.RovokeAll方法。

然后再来看实现代码

Cpp代码 复制代码 收藏代码
  1. template<class T>   
  2. class ScopedRunnableMethodFactory {   
  3.  public:   
  4.   explicit ScopedRunnableMethodFactory(T* object) : weak_factory_(object) {   
  5.   }   
  6.   
  7.   
  8.   template <class Method>   
  9.   inline Task* NewRunnableMethod(Method method) {   
  10.     return new RunnableMethod<Method, Tuple0>(   
  11.         weak_factory_.GetWeakPtr(), method, MakeTuple());   
  12.   }   
  13.  protected:   
  14.   template <class Method, class Params>   
  15.   class RunnableMethod : public Task {   
  16.    public:   
  17.     RunnableMethod(const base::WeakPtr<T>& obj, Method meth, const Params& params)   
  18.         : obj_(obj),   
  19.           meth_(meth),   
  20.           params_(params) {   
  21.     }   
  22.   
  23.   
  24.     virtual void Run() {   
  25.       if (obj_)   
  26.         DispatchToMethod(obj_.get(), meth_, params_);   
  27.     }   
  28.   
  29.   
  30.    private:   
  31.     base::WeakPtr<T> obj_;   
  32.     Method meth_;   
  33.     Params params_;   
  34.   };   
  35.   
  36.   
  37.  private:   
  38.   base::WeakPtrFactory<T> weak_factory_;   
  39. };  
template<class T>
class ScopedRunnableMethodFactory {
 public:
  explicit ScopedRunnableMethodFactory(T* object) : weak_factory_(object) {
  }


  template <class Method>
  inline Task* NewRunnableMethod(Method method) {
    return new RunnableMethod<Method, Tuple0>(
        weak_factory_.GetWeakPtr(), method, MakeTuple());
  }
 protected:
  template <class Method, class Params>
  class RunnableMethod : public Task {
   public:
    RunnableMethod(const base::WeakPtr<T>& obj, Method meth, const Params& params)
        : obj_(obj),
          meth_(meth),
          params_(params) {
    }


    virtual void Run() {
      if (obj_)
        DispatchToMethod(obj_.get(), meth_, params_);
    }


   private:
    base::WeakPtr<T> obj_;
    Method meth_;
    Params params_;
  };


 private:
  base::WeakPtrFactory<T> weak_factory_;
};
 
ScopedRunnableMethodFactory构造时需要传入被调用对象的指针,并在NewRunnableMethod时传入要调用方法的指针以及参数。这里大量的使用了C++的模板技术,非此不可表示。  我们看到,一个Task就是一个RunnableMethod对象,其内部保存了被调用对象的指针,方法地址(偏移),以及参数(一般用Tuple表示),并最后调用模板方法DispatchToMethod。 暂且不管WeakPtrFactory和WeakPtr,后面再研究。

Cpp代码 复制代码 收藏代码
  1. template <class ObjT, class Method>   
  2. inline void DispatchToMethod(ObjT* obj,   
  3.                              Method method,   
  4.                              const Tuple0& arg, Tuple0*) {   
  5.   (obj->*method)();   
  6. }  
template <class ObjT, class Method>
inline void DispatchToMethod(ObjT* obj,
                             Method method,
                             const Tuple0& arg, Tuple0*) {
  (obj->*method)();
}
 
为了使用的方便,还大量的使用了模板方法和重载,比如

Cpp代码 复制代码 收藏代码
  1. template <class Method, class A>   
  2. inline Task* NewRunnableMethod(Method method, const A& a) {   
  3.   return new RunnableMethod<Method, Tuple1<A> >(   
  4.       weak_factory_.GetWeakPtr(), method, MakeTuple(a));   
  5. }  
  template <class Method, class A>
  inline Task* NewRunnableMethod(Method method, const A& a) {
    return new RunnableMethod<Method, Tuple1<A> >(
        weak_factory_.GetWeakPtr(), method, MakeTuple(a));
  }
 
用于创建指向带一个参数的方法的Task,注意使用Tuple1来封装参数。然后,调用如下的参数特例化函数进行展开。

Cpp代码 复制代码 收藏代码
  1. template <class Function, class A>   
  2. inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {   
  3.   (*function)(arg.a);   
  4. }  
template <class Function, class A>
inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
  (*function)(arg.a);
}
 
因为使用了模板方法和重载,以及实用Tuple来封装多个参数,才使得ScopedRunnableMethodFactory::Run方法只有一份即可。

Cpp代码 复制代码 收藏代码
  1. virtual void Run() {   
  2.   if (obj_)   
  3.     DispatchToMethod(obj_.get(), meth_, params_);   
  4. }  
    virtual void Run() {
      if (obj_)
        DispatchToMethod(obj_.get(), meth_, params_);
    }
 

关于Tuple,我以为就是匿名的结构体,用以把多个参数合成一个结构体,以保证函数原型的一致。

Cpp代码 复制代码 收藏代码
  1. struct Tuple0 {   
  2. };   
  3.   
  4.   
  5. template <class A>   
  6. struct Tuple1 {   
  7.   Tuple1() {}   
  8.   explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}   
  9.   
  10.   
  11.   A a;   
  12. };   
  13.   
  14.   
  15. template <class A, class B>   
  16. struct Tuple2 {   
  17.  public:   
  18.   Tuple2() {}   
  19.   Tuple2(typename TupleTraits<A>::ParamType a,   
  20.          typename TupleTraits<B>::ParamType b)   
  21.       : a(a), b(b) {   
  22.   }   
  23.   
  24.   
  25.   A a;   
  26.   B b;   
  27. };  
struct Tuple0 {
};


template <class A>
struct Tuple1 {
  Tuple1() {}
  explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}


  A a;
};


template <class A, class B>
struct Tuple2 {
 public:
  Tuple2() {}
  Tuple2(typename TupleTraits<A>::ParamType a,
         typename TupleTraits<B>::ParamType b)
      : a(a), b(b) {
  }


  A a;
  B b;
};
 

到此为止,我们看到通过一系列的C++技巧,终于成就了Task* NewRunnableMethod(Method method) 的简洁。现在来看前面搁置的问题WeakPtrFactory和WeakPtr。


在前面的讨论中,我们是通过ScopedRunnableMethodFactory::NewRunnableMethod方法来创建一个Task并传递给另外一个线程的,在这个Task里保存有被调用对象的指针,这样才能执行它的方法。现在的问题是,如果被调用对象在Task还没被执行之前就被删除了,那可怎么办?C++程序崩溃,大多就是由此产生的,这是一个古老的问题。对此,我们当然也有不同的解决办法。
第一个,等待所有Task执行完毕被调用对象才能退出,带来的问题是万一Task永远都执行不完或者要花很长的时间呢?
第二个,被调用对象使用引用计数来控制生命周期,这样只要Task还在,被调用对象就不可能删掉。这样的问题是,被调用对象万一不带引用计数呢?还有,Task不结束被调用对象就不能释放,那很多资源就不能及时释放了!
第三个,使用弱引用(Weak Reference),这样Task持有的是被调用对象的弱引用,只要被调用对象还在,弱引用就有效。如果被调用对象被删除了,那么弱引用就失效了,这可以检测到,所以不会导致程序崩溃。

Chrome里使用的就是第三种方式。我们看到RunnableMethod对象里包含了WeakPtr<T>对象obj_,并在Run时检查obj_的有效性。

Cpp代码 复制代码 收藏代码
  1. virtual void Run() {   
  2.   if (obj_)   
  3.     DispatchToMethod(obj_.get(), meth_, params_);   
  4. }  
    virtual void Run() {
      if (obj_)
        DispatchToMethod(obj_.get(), meth_, params_);
    }
 

显然,WeakPtr并不是直接指向被调用对象,是什么呢?

Cpp代码 复制代码 收藏代码
  1. template <typename T>   
  2. class WeakPtr : public internal::WeakPtrBase {   
  3.  public:   
  4.   WeakPtr() : ptr_(NULL) {   
  5.   }   
  6.   
  7.   
  8.   template <typename U>   
  9.   WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.get()) {   
  10.   }   
  11.   
  12.   
  13.   T* get() const { return ref_.is_valid() ? ptr_ : NULL; }   
  14.   operator T*() const { return get(); }   
  15.   T* operator->() const {   
  16.     return get();   
  17.   }   
  18.   
  19.   
  20.   void reset() {   
  21.     ref_ = internal::WeakReference();   
  22.     ptr_ = NULL;   
  23.   }   
  24.      
  25.   // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its   
  26.   // value is undefined (as opposed to NULL).   
  27.   T* ptr_;   
  28. };   
  29.   
  30.   
  31. class WeakPtrBase {   
  32.  public:   
  33.   WeakPtrBase() {   
  34.   }   
  35.   
  36.   
  37.  protected:   
  38.   WeakPtrBase(const WeakReference& ref) : ref_(ref) {   
  39.   }   
  40.   
  41.   
  42.   WeakReference ref_;   
  43. };  
template <typename T>
class WeakPtr : public internal::WeakPtrBase {
 public:
  WeakPtr() : ptr_(NULL) {
  }


  template <typename U>
  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.get()) {
  }


  T* get() const { return ref_.is_valid() ? ptr_ : NULL; }
  operator T*() const { return get(); }
  T* operator->() const {
    return get();
  }


  void reset() {
    ref_ = internal::WeakReference();
    ptr_ = NULL;
  }
  
  // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
  // value is undefined (as opposed to NULL).
  T* ptr_;
};


class WeakPtrBase {
 public:
  WeakPtrBase() {
  }


 protected:
  WeakPtrBase(const WeakReference& ref) : ref_(ref) {
  }


  WeakReference ref_;
};
 
由此可见,被调用对象指针保存在ptr_变量里,但是它的有效性依赖于ref_变量指向的对象WeakReference。

Cpp代码 复制代码 收藏代码
  1. class WeakReference {   
  2.  public:   
  3.   class Flag : public RefCounted<Flag>, public NonThreadSafe {   
  4.    public:   
  5.     Flag(Flag** handle) : handle_(handle) {   
  6.     }   
  7.   
  8.   
  9.     void AddRef() {   
  10.       RefCounted<Flag>::AddRef();   
  11.     }   
  12.   
  13.   
  14.     void Release() {   
  15.       RefCounted<Flag>::Release();   
  16.     }   
  17.   
  18.   
  19.     void Invalidate() { handle_ = NULL; }   
  20.     bool is_valid() const { return handle_ != NULL; }   
  21.   
  22.   
  23.    private:   
  24.     Flag** handle_;   
  25.   };   
  26.   
  27.   
  28.   WeakReference() {}   
  29.   WeakReference(Flag* flag) : flag_(flag) {}   
  30.   
  31.   
  32.   bool is_valid() const { return flag_ && flag_->is_valid(); }   
  33.   
  34.   
  35.  private:   
  36.   scoped_refptr<Flag> flag_;   
  37. };  
class WeakReference {
 public:
  class Flag : public RefCounted<Flag>, public NonThreadSafe {
   public:
    Flag(Flag** handle) : handle_(handle) {
    }


    void AddRef() {
      RefCounted<Flag>::AddRef();
    }


    void Release() {
      RefCounted<Flag>::Release();
    }


    void Invalidate() { handle_ = NULL; }
    bool is_valid() const { return handle_ != NULL; }


   private:
    Flag** handle_;
  };


  WeakReference() {}
  WeakReference(Flag* flag) : flag_(flag) {}


  bool is_valid() const { return flag_ && flag_->is_valid(); }


 private:
  scoped_refptr<Flag> flag_;
};
 
原来WeakReference内部持有一个Flag对象的引用,并且该对象是带引用计数的。而Flag对象保存了被引用对象是否有效的标志handle_(其类型其实无啥意义,只要空和非空两种状态即可。可能是为了调试方便,目前使用了Flag**),并可以设置其有效和无效。 我们现在可以猜测,Flag是由WeakPtrFactory创建的,并在退出时设置为无效的。

Cpp代码 复制代码 收藏代码
  1. template <class T>   
  2. class WeakPtrFactory {   
  3.  public:   
  4.   explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {   
  5.   }   
  6.   
  7.   
  8.   WeakPtr<T> GetWeakPtr() {   
  9.     return WeakPtr<T>(weak_reference_owner_.GetRef(), ptr_);   
  10.   }   
  11.   
  12.   
  13.   // Call this method to invalidate all existing weak pointers.   
  14.   void InvalidateWeakPtrs() {   
  15.     weak_reference_owner_.Invalidate();   
  16.   }   
  17.   
  18.   
  19.   // Call this method to determine if any weak pointers exist.   
  20.   bool HasWeakPtrs() const {   
  21.     return weak_reference_owner_.HasRefs();   
  22.   }   
  23.   
  24.   
  25.  private:   
  26.   internal::WeakReferenceOwner weak_reference_owner_;   
  27.   T* ptr_;   
  28.   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);   
  29. };  
template <class T>
class WeakPtrFactory {
 public:
  explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {
  }


  WeakPtr<T> GetWeakPtr() {
    return WeakPtr<T>(weak_reference_owner_.GetRef(), ptr_);
  }


  // Call this method to invalidate all existing weak pointers.
  void InvalidateWeakPtrs() {
    weak_reference_owner_.Invalidate();
  }


  // Call this method to determine if any weak pointers exist.
  bool HasWeakPtrs() const {
    return weak_reference_owner_.HasRefs();
  }


 private:
  internal::WeakReferenceOwner weak_reference_owner_;
  T* ptr_;
  DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
};
 
WeakPtrFactory构造时保存了被引用对象指针,并提供了GetWeakPtr()方法以获得弱引用对象WeakPtr。而WeakPtr构造时从WeakReferenceOwner.GetRef()获得了一个WeakReference对象。

Cpp代码 复制代码 收藏代码
  1. class WeakReferenceOwner {   
  2.  public:   
  3.   WeakReferenceOwner() : flag_(NULL) {   
  4.   }   
  5.   
  6.   
  7.   ~WeakReferenceOwner() {   
  8.     Invalidate();   
  9.   }   
  10.   
  11.   
  12.   WeakReference GetRef() const {   
  13.     if (!flag_)   
  14.       flag_ = new WeakReference::Flag(&flag_);   
  15.     return WeakReference(flag_);   
  16.   }   
  17.   
  18.   
  19.   bool HasRefs() const {   
  20.     return flag_ != NULL;   
  21.   }   
  22.   
  23.   
  24.   void Invalidate() {   
  25.     if (flag_) {   
  26.       flag_->Invalidate();   
  27.       flag_ = NULL;   
  28.     }   
  29.   }   
  30.   
  31.   
  32.  private:   
  33.   mutable WeakReference::Flag* flag_;   
  34. };  
class WeakReferenceOwner {
 public:
  WeakReferenceOwner() : flag_(NULL) {
  }


  ~WeakReferenceOwner() {
    Invalidate();
  }


  WeakReference GetRef() const {
    if (!flag_)
      flag_ = new WeakReference::Flag(&flag_);
    return WeakReference(flag_);
  }


  bool HasRefs() const {
    return flag_ != NULL;
  }


  void Invalidate() {
    if (flag_) {
      flag_->Invalidate();
      flag_ = NULL;
    }
  }


 private:
  mutable WeakReference::Flag* flag_;
};

 
WeakReferenceOwner 的GetRef()返回的WeakReference都指向了同一个WeakReference::Flag对象,并在析构把Flag标志至为无效。现在,被引用对象包含ScopedRunnableMethodFactory对象成员,后者又包含了WeakPtrFactory对象成员,同样后后者又包含WeakReferenceOwner,因此被引用对象析构的时候,所有Weak Reference都成无效!关系如下:

被引用对象->ScopedRunnableMethodFactory->WeakPtrFactor->WeakReferenceOwner->WeakReference::Flag

我们看到WeakReference和WeakPtr等等都是以值传递的,唯有WeakReference::Flag传递的是指针,并且WeakReference::Flag是共享的对象,所以使用了引用计数来控制生命周期。当指向WeakReference::Flag的最后一个WeakReference被删除了,WeakReference::Flag才会被删除。即便有弱引用WeakReference一直都没有被释放,也无所谓,原始的被调用对象还是可以被释放的,浪费的只是WeakReference::Flag占用的空间,这是微不足道的。


原来使用弱引用可以避免很多指针无效而导致非法访问的问题!
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值