多线程编程完全基于消息传递会比较麻烦,因为消息的封装和解析是比较麻烦的。不仅如此,被多个线程调用的其实是同一个对象的不同方法。比如
- class Work
- {
- public:
- void Start()
- {
- //CreateThread ... 创建线程或调用其它异步函数,结束时会调用OnComplete方法
- }
- private:
- void OnCompleted(); // 会从另一个线程回调该方法。
- }
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();
- ......
- }
- }
另一个线程
...
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;
- };
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));
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);
- }
- };
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_;
- };
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 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));
- }
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);
- }
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_);
- }
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;
- };
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_);
- }
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_;
- };
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_;
- };
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);
- };
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_;
- };
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占用的空间,这是微不足道的。
原来使用弱引用可以避免很多指针无效而导致非法访问的问题!