Android Native Thread分析

Android Native Thread是对pthread线程的封装，提供了封装化的接口（sp指针，抽象接口），方便应用程序使用。具体接口如下：

class Thread : virtual public RefBase    // virtual继承，多重继承时能保证只有一个RefBase
{
public:
                        Thread(bool canCallJava = true);  // 构造函数，不会开始线程的执行，直到调用run函数
    virtual             ~Thread();

    
    // 这是个模板方法，定义顶层实现逻辑，需要子类实现threadLoop()来完成整个逻辑
    virtual status_t    run(    const char* name = 0,
                                int32_t priority = PRIORITY_DEFAULT,
                                size_t stack = 0);
    
    // 请求线程推出，可以在其他的线程中调用，这是个异步调用方法，线程不一定已经真正退出了
    virtual void        requestExit();

    //线程运行前的一次性初始化工作
    virtual status_t    readyToRun();
    
    // 请求线程退出，等待直到线程真正退出，不要在当前线程上下文中调用，否则会返回WOULD_BLOCK
    status_t    requestExitAndWait();

    // 等待直到线程退出，不要在当前线程上下文中调用，否则会返回WOULD_BLOCK
    status_t    join();

    // 线程是否运行
    bool        isRunning() const;

    //返回线程ID, 与线程自身调用gettid()或者 androidGetTid()得到的值相同
    pid_t       getTid() const;

protected:
    // 是否请求退出状态
    bool        exitPending() const;
    
private:
    // 子类必须实现 threadLoop(). 如果threadLoop返回true，将会重复调用，直到requestExit请求；threadLoop返回false，线程将退出
    virtual bool        threadLoop() = 0;

private:
    static  int             _threadLoop(void* user);  //静态函数，传递给pthread_create的执行例程，这个函数调用threadLoop
    const   bool            mCanCallJava;  //java能够调用
    thread_id_t     mThread;    //thread_id_t类型的ID
    mutable Mutex           mLock;   //同步锁
    Condition       mThreadExitedCondition;  //条件变量，用于线程退出的状态同步
    status_t        mStatus; //运行状态
    volatile bool           mExitPending;  //是否请求退出
    volatile bool           mRunning;  //线程是否已经调用run开始执行
    sp<Thread>      mHoldSelf;      //自身对象的强引用
    pid_t           mTid;   //当前线程ID}

}

下面看看Thread的使用：

1）子类继承Thread，需要实现threadLoop，之后显示调用Thread::run()来执行线程上下文。也可以override onFirstRef()调用run， 利用sp第一次调用OnfirstRef自动启动线程。

2) 通过对象组合的方式复用Thread， 好处是避免类的多重继承, 对Thread对象生命周期控制比较容易。需要一个handler接口和Thread子类来对接口的包装。

/* Abstraction of MessageThread */
class IMessageHandler
{
public:
    virtual ~IMessageHandler() { };
    virtual void messageThreadLoop(void) = 0;
};

class MessageThread : public Thread {
public:
    MessageThread(IMessageHandler* runner) { }
    virtual void onFirstRef() {
        run(mName, mPriority);
    }
    virtual bool threadLoop() {
        mRunner->messageThreadLoop();
        return false;
    };
private:
    IMessageHandler* mRunner;
    String8 mName;
    int mPriority;
};

第三方的业务逻辑类，只需要实现messageThreadLoop接口，并将MessageThread对象组合到业务类，就可以完全复用Thread，并且完全控制Thread的生命周期。