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

    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 mHoldSelf;  
    };  

    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);  
    }  

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

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

    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);  
    }  

    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;  
    }  

    int Thread::_threadLoop(void* user)  
    {  
        Thread* const self = static_cast(user);  
        sp strong(self->mHoldSelf);  
        wp 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）创建一个类如MyThread，继承与Thead类  
2）在MyThread类中实现父类的纯虚函数threadLoop，也就是我们调用pthread_create时传入的线程函数。  
3）定义一个MyThread变量 thread,调用线程的run()方法，启动函数