`
optman
  • 浏览: 44061 次
  • 性别: Icon_minigender_1
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

Chrome Task类分析

阅读更多

在上一篇《Chrome线程模型》之后,我们来实际看一看代码。
 
多线程编程完全基于消息传递会比较麻烦,因为消息的封装和解析是比较麻烦的。不仅如此,被多个线程调用的其实是同一个对象的不同方法。比如

class Work
{
 public:
    void Start()
    {
         //CreateThread ... 创建线程或调用其它异步函数,结束时会调用OnComplete方法
        
     }
private:
    void OnCompleted();    // 会从另一个线程回调该方法。
}
 

 


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

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

另一个线程
...
PostMessage(ON_COMPLETE)
...


主线程


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

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

 


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

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

class Task{
  // Tasks are automatically deleted after Run is called.
  virtual void Run() = 0;
};
 

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

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

Work* workObj; 
...
main_thread_loop->PostTask(NewRunnableMethod(workObj, &Work::OnComplete));  

 

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


先看一个典型的用法

 
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方法。

然后再来看实现代码

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,后面再研究。

template <class ObjT, class Method>
inline void DispatchToMethod(ObjT* obj,
                             Method method,
                             const Tuple0& arg, Tuple0*) {
  (obj->*method)();
}
 
为了使用的方便,还大量的使用了模板方法和重载,比如

  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来封装参数。然后,调用如下的参数特例化函数进行展开。

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

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

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

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_的有效性。

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

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

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。

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创建的,并在退出时设置为无效的。

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对象。

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占用的空间,这是微不足道的。


原来使用弱引用可以避免很多指针无效而导致非法访问的问题!

 


 

分享到:
评论
1 楼 Steven.Tan 2010-02-03  
你好,谢谢你写的这篇分析文章!我想小小补充一下,Flag类的成员handle_使用Flag**类型是必须的。handle_除了表示Flag是否有效之外,还有一个目的,就是在Flag对象析构时将引用Flag的指针置为NULL。这个指针就是WeakReferenceOwner的那个成员。

有一个情况,当所有的WeakPtr都不再引用要管理的对象时,Flag就会被释放,此时如果不将Owner的Flag指针置空,那么它就成了一个野指针了。

相关推荐

Global site tag (gtag.js) - Google Analytics