106 lines
3.6 KiB
C++
106 lines
3.6 KiB
C++
// This file defines all kinds of tasks
|
||
|
||
#ifndef BASE_FRAMEWORK_TASK_H_
|
||
#define BASE_FRAMEWORK_TASK_H_
|
||
|
||
#include "base/base_export.h"
|
||
#include "base/callback/callback.h"
|
||
|
||
namespace nbase
|
||
{
|
||
const size_t kDeadTask = 0xDEAD7A53;
|
||
|
||
// Task用于让某个MessageLoop异步地完成某项工作。
|
||
// Task对象本身是线程安全，一个Task可以在同一个线程中生成并运行，也可以在一个线程生成在另一个线程运行，
|
||
// 后者的Run函数编写需要注意跨线程运行的问题。
|
||
// Task通过MessageLoop的Post族函数被加入到MessageLoop中运行，
|
||
// 一旦被加入到MessageLoop中，生成Task的线程不应该再负责Task的销毁而改由MessageLoop所运行的线程负责。
|
||
|
||
|
||
// RunnableMethodTraits --------------------------------------------------------
|
||
//
|
||
// This traits-class is used by RunnableMethod to manage the lifetime of the
|
||
// callee object. By default, it is assumed that the callee supports AddRef
|
||
// and Release methods. A particular class can specialize this template to
|
||
// define other lifetime management. For example, if the callee is known to
|
||
// live longer than the RunnableMethod object, then a RunnableMethodTraits
|
||
// struct could be defined with empty RetainCallee and ReleaseCallee methods.
|
||
|
||
template <class T>
|
||
struct RunnableMethodTraits
|
||
{
|
||
RunnableMethodTraits()
|
||
{
|
||
}
|
||
|
||
~RunnableMethodTraits()
|
||
{
|
||
}
|
||
|
||
void RetainCallee(T* obj)
|
||
{
|
||
obj->AddRef();
|
||
}
|
||
|
||
void ReleaseCallee(T* obj)
|
||
{
|
||
obj->Release();
|
||
}
|
||
};
|
||
|
||
// Convenience macro for declaring a RunnableMethodTraits that disables
|
||
// refcounting of a class. This is useful if you know that the callee
|
||
// will outlive the RunnableMethod object and thus do not need the ref counts.
|
||
//
|
||
// The invocation of DISABLE_RUNNABLE_METHOD_REFCOUNT should be done at the
|
||
// global namespace scope. Example:
|
||
//
|
||
// namespace foo {
|
||
// class Bar {
|
||
// ...
|
||
// };
|
||
// } // namespace foo
|
||
//
|
||
// DISABLE_RUNNABLE_METHOD_REFCOUNT(foo::Bar);
|
||
//
|
||
// This is different from DISALLOW_COPY_AND_ASSIGN which is declared inside the
|
||
// class.
|
||
#define DISABLE_RUNNABLE_METHOD_REFCOUNT(TypeName) \
|
||
template <> \
|
||
struct RunnableMethodTraits<TypeName> \
|
||
{ \
|
||
void RetainCallee(TypeName* manager) {} \
|
||
void ReleaseCallee(TypeName* manager) {} \
|
||
}
|
||
|
||
// RunnableMethod and RunnableFunction -----------------------------------------
|
||
//
|
||
// Runnable methods are a type of task that call a function on an object when
|
||
// they are run. We implement both an object and a set of NewRunnableMethod and
|
||
// NewRunnableFunction functions for convenience. These functions are
|
||
// overloaded and will infer the template types, simplifying calling code.
|
||
//
|
||
// The template definitions all use the following names:
|
||
// T - the class type of the object you're supplying
|
||
// this is not needed for the Static version of the call
|
||
// Method/Function - the signature of a pointer to the method or function you
|
||
// want to call
|
||
// Param - the parameter(s) to the method, possibly packed as a tuple
|
||
// A - the first parameter (if any) to the method
|
||
// B - the second parameter (if any) to the method
|
||
//
|
||
// Put these all together and you get an object that can call a method whose
|
||
// signature is:
|
||
// R T::MyFunction([A[, B]])
|
||
//
|
||
// Usage:
|
||
// PostTask(NewRunnableMethod(object, &Object::method[, a[, b]])
|
||
// PostTask(NewRunnableFunction(&function[, a[, b]])
|
||
|
||
// RunnableMethod and NewRunnableMethod implementation -------------------------
|
||
|
||
|
||
} // namespace nbase
|
||
|
||
#endif // BASE_FRAMEWORK_TASK_H_
|