android thread使用测试

本文主要是想测试 threadLoop 线程是不是循环执行。

1. ThreadTest.cpp

#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>

#include <utils/threads.h>


namespace android {

    class ThreadTest : public Thread {
        virtual bool threadLoop();
    };

    bool ThreadTest::threadLoop() {
        printf("threadLoop\n");
        sleep(1);
        return true;
    }
}

using namespace android;

int main() {
    
    sp<ThreadTest> thr = new ThreadTest();
    thr->run();

    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();

    return 0;
}

2. Android.mk

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE_TAGS:= optional

LOCAL_SRC_FILES := \
    ThreadTest.cpp

LOCAL_SHARED_LIBRARIES := \
    libutils \
    libbinder

LOCAL_MODULE := ThreadTest

include $(BUILD_EXECUTABLE)

3. 执行

可以看到每隔1秒，打印一次threadLoop，所以threadLoop是循环执行。

若用指针代替android的sp，即StrongPointer，则只打印一次threadLoop。如下所示：

//sp<ThreadTest> thr = new ThreadTest();
ThreadTest *thr = new ThreadTest();

或者在threadLoop函数中return false，也只打印一次threadLoop。

原因是Thread类的实现中，

先由pthreads或win32_threads实现创建thread，并将线程入口设为_threadLoop。

_threadLoop再调用thread类实现者(ThreadTest)的threadLoop，并将这个threadLoop

放在do-while循环中，只有当threadLoop返回false或线程对象指针不是sp实现时，会退出循环。

_threadLoop示意代码：

int Thread::_threadLoop(void* user)
{
    Thread* const self = static_cast<Thread*>(user);

    sp<Thread> strong(self->mHoldSelf);
    wp<Thread> weak(strong);
    self->mHoldSelf.clear();

#ifdef HAVE_ANDROID_OS
    // this is very useful for debugging with gdb
    self->mTid = gettid();
#endif

    bool first = true;

    do {
        bool result;
        if (first) {
            first = false;
            self->mStatus = self->readyToRun();
            result = (self->mStatus == NO_ERROR);

            if (result && !self->exitPending()) {
                // Binder threads (and maybe others) rely on threadLoop
                // running at least once after a successful ::readyToRun()
                // (unless, of course, the thread has already been asked to exit
                // at that point).
                // This is because threads are essentially used like this:
                //   (new ThreadSubclass())->run();
                // The caller therefore does not retain a strong reference to
                // the thread and the thread would simply disappear after the
                // successful ::readyToRun() call instead of entering the
                // threadLoop at least once.
                result = self->threadLoop();
            }
        } else {
            result = self->threadLoop();
        }

        // establish a scope for mLock
        {
        Mutex::Autolock _l(self->mLock);
        if (result == false || self->mExitPending) {
            self->mExitPending = true;
            self->mRunning = false;
            // clear thread ID so that requestExitAndWait() does not exit if
            // called by a new thread using the same thread ID as this one.
            self->mThread = thread_id_t(-1);
            // note that interested observers blocked in requestExitAndWait are
            // awoken by broadcast, but blocked on mLock until break exits scope
            self->mThreadExitedCondition.broadcast();
            break;
        }
        }
        
        // Release our strong reference, to let a chance to the thread
        // to die a peaceful death.
        strong.clear();
        // And immediately, re-acquire a strong reference for the next loop
        strong = weak.promote();
    } while(strong != 0);
    
    return 0;
}

关于sp,wp，可参考：

深入理解android常用类