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占用的空间，这是微不足道的。
原来使用弱引用可以避免很多指针无效而导致非法访问的问题！