Android开发之Thread类分析 （转载）

　　转自：http://blog.csdn.net/llping2011/article/details/9706599

       在我们Linux系统中创建线程函数为：pthread_create()，在Android中我们为线程封装了一个类Thread，实际调用的还是pthread_create()
当我们想创建线程的时候，只需要继承于这个Thread类并实现虚函数thread_loop()即可。

    frameworks/base/include/utils/threads.h  
    class Thread : virtual public RefBase  
    {  
    public:  
        // 创建一个Thread对象，但是并不立即启动线程函数  
        Thread(bool canCallJava = true);  
        virtual ~Thread();  
        // 开始启动线程函数，调用的是threadLoop  
        virtual status_t run(const char*name = 0, int32_t prority = PRIORITY_DEFAULT,  
                    size_t stack = 0);  
        // 申请退出这个线程  
        virtual void requestExit();  
        virtual status_t readyToRun();  
        // 调用requestExit()等待直到这个线程退出  
            status_t requestExitAndWait();  
        // 等待直到线程退出，如果没有启动立即返回  
            status_t join();  
    protected:  
        // 如果调用了requestExit()返回true  
        bool exitPending() const;  
    private:  
        // 这是实际的线程函数，继承类必须实现它，  
        // 返回true的话再次调用，返回false的话就会退出  
        virtual bool threadLoop() = 0;  
        // 禁止赋值  
        Thread& operator = (const Thread&);  
        // 内部类，被run函数调用，实际调用threadLoop  
        static int _threadLoop(void* user);  
        const bool mCanCallJava;  
            thread_id_t mThread;    // thread_id_t 其实是 void*类型  
        mutable Mutex mLock;  
            Condition mThreadExitedCondition;  
            status_t mStatus;  
        // 注意：所以操作这两个变量的地方都需要上锁  
        volatile bool mExitPending;  
        volatile bool mRunning;  
            sp<Thread> mHoldSelf;  
    };  

我们首先看下Thread类的构造函数：

    Thread::Thread(bool canCallJava)   
        :   mCanCallJava(canCallJava),  
            mThread(thread_id_t(-1)),  
            mLock("Thrad::mLock"),  
            mStatus(NO_ERROR),  
            mExitPending(false), mRunnig(false)  
    {}  

真正启动线程的函数：

    status_t Thread::run(const char*name, int32_t priority, size_t stack)  
    {  
        Mutex::Autolock _l(mLock);  
        if(mRunnig)  
            return INVALID_OPERATION;  
        mState = NO_ERROR;  
        mExitPending = false;  
        mThread = thread_id_t(-1);  
        mHoldSelf = this;   // 保存着当前对象的引用  
        mRunning = true;  
        if (mCanCallJava)   
            res = createThreadEtc(_threadLoop, this, name, priority, stack, &mThread);  
        else  
            res = androidCreateRawThreadEtc(_threadLoop, this, name,   
                    priority, stack, &mThread);  
        if(res == false) {  
            mStatus = UNKNOWN_ERROR;  
            mRunning = false;  
            mThread = thread_id_t(-1);  
            mHoldSelf.clear();  
            return UNKNOWN_ERROR;  
        }  
        return NO_ERROR;  
    }  
    这里有个判断mCanCallJava是个什么东西？接着往下看  
    inline bool createThreadEtc(thread_func_t entryFunction, void* userData,  
                const char* threadName = "android:unnamed_thread",  
                int32_t threadPriority = PRIORITY_DEFAULT,  
                size_t threadStackSize = 0,  
                thread_id_t *threadId = 0)  
    {  
        return androidCreateThreadEtc(entryFunction, userData, threadName, threadPriority,  
            threadStackSize, threadId) ? true : false;  
    }         
    int androidCreateThreadEtc(thread_func_t entryFunction,   
                void* userData,  
                const char* threadName,  
                int32_t threadPriority = PRIORITY_DEFAULT,  
                size_t threadStackSize = 0,  
                thread_id_t *threadId = 0)  
    {  
        return gCreateThreadFn(entryFunction, userData, threadName, threadPriority,  
            threadStackSize, threadId);  
    }  

我们看到最后调用的是gCreateThreadFn这个函数，而gCreateThreadFn是个全局的函数指针，
static android_create_thread_fn gCreateThreadFn = androidCreateRawThreadEtc;
这里默认给它赋值为 androidCreateRawThreadEtc，这跟前面调用的是一样的？？？

既然是函数指针肯定有给它赋值的地方:

    void androidSetCreateThreadFunc(android_create_thread_fn func)  
    {  
        gCreateThreadFn = func;  
    }  

那这个函数在什么地方调用的呢？又给它赋什么值了呢？
我们找到了再AndroidRuntime类里面启动虚拟机的地方：

    int androidRuntime::startReg(JNIEnv* env)  
    {  
        androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);  
        return 0;  
    }  

这样如果我们的mCanCallJava如果为true的话，调用的就是：

    int AndroidRuntime::javaCreateThreadEtc(android_thread_func_t entryFunction,  
                    void* userData,  
                    const char* threadName,  
                    int32_t threadPriority,  
                    suze_t threadStackSize,  
                    android_thread_id_t *threadId)  
    {  
        void** args = (void**)malloc(3*sizeof(void*));  
        args[0] = (void*)entryFunction;  
        args[1] = userData;  
        args[2] = (void*)strdup(threadName);  
        return androidCreateRawThreadEtc(AndroidRuntime::javaThreadShell, args.  
            threadName, threadPriority, threadStackSize, threadId);  
    }  

最后调用的还是同一个创建线程的函数只是回调函数不一样，这里变成了AndroidRuntime::javaThreadShell

    int AndroidRuntime::javaCreateThreadEtc(void* args)  
    {  
        voir* start = ((void**)args)[0];  
        voir* userData = ((void**)args)[1];  
        voir* name = ((void**)args)[2];  
        free(args);  
        JNIEnv* env;  
          
        javaAttachThread(name, &env);  
        result = (*(android_thead_func_t)start)(userData);  
        javaDetachThread();  
          
        free(name);  
        return result;  
    }  

这里线程函数javaThreadShell里面还是调用前面我们的_threadLoop函数，只不过在调用之前，调用
了javaAttachThread()将线程attach到JNI环境中去了，这样线程函数就可以调用JNI函数，最后线程
函数退出之后再调用javaDetachThread()退出JNI环境。

现在进入线程函数_threadLoop(),这是一个static函数

    int Thread::_threadLoop(void* user)  
    {  
        Thread* const self = static_cast<Thread*>(user);  
        sp<Thead> strong(self->mHoldSelf);  
        wp<Thead> weak(strong);  
        self->mHoldSelf.clear();  
          
        bool first = true;  
          
        do {    // 进入一个循环，通过判断返回值和内部退出标志位决定是否退出线程  
            bool result;  
            if (fisr) {  
                first = false;  
                self->mStatus = self->readyToRun();  
                result = (self->mStatus == NO_ERROR);  
                if (result && !self->exitPendind()) {    // 检查是否退出  
                    result = self->threadLoop(); // 调用实际线程函数  
                }  
            } else {  
                result = self->threadLoop();  
            }  
              
            {  
                Mutex::Autolock _l(self->mLock);  
                if (result == false || self->mExitPending) {  
                    self->mExitPending = true;  
                    self-mRunning = false;  
                    self->mThread = thread_ir_t(-1);  
                    self->mThreadExitedCondition.broadcast();  
                    break;  
                }  
              
            }  
            strong.clear();  
            strong = weak.promote();  
        } while(strong != 0);  
        return 0;  
    }  

在这里线程退出的条件为：
1）result = true 意味着子类在实现的threadLoop函数中返回false，这样线程就主动退出了
2）mExidPendding = true 这个变量值由Thread类的requestExit函数设置，这样线程就被动退出了。
最后如果线程退出了需要进行些去初始化操作，设置线程运行状态，广播告知其他关心这个线程的对象。

最后，如果我们想使用线程类：  
1）创建一个类如MyThread，继承与Thead类  
2）在MyThread类中实现父类的纯虚函数threadLoop，也就是我们调用pthread_create时传入的线程函数。  
3）定义一个MyThread变量 thread,调用线程的run()方法，启动函数