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指针置空，那么它就成了一个野指针了。