2. 程式人生 > >Android Framework中的執行緒Thread及它的threadLoop方法

Android Framework中的執行緒Thread及它的threadLoop方法

阿新 • • 發佈：2018-12-30

當初跟蹤Camera的程式碼中的時候一直追到了HAL層，而在Framework中的程式碼看見了許許多多的Thread。它們普遍的特點就是有一個threadLoop方法。按照字面的意思應該是這個執行緒能夠迴圈處理資料。對應我想到到了java上層中的HandlerThread，這個估計也差不多，但當時心裡總有一個疙瘩，想弄清楚它為什麼能夠迴圈，還有它到底是怎麼迴圈起來的？

Android中java世界的Thread

我們先來看看java是怎麼建立一個執行緒的。這個是最舒服的，也是我最熟悉的。


new Thread(new Runnable() {

        @Override
        public
 
 void run() {
            // TODO Auto-generated method stub
                ...
        }
}).start();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

當然，你也可以在android中建立一個訊息迴圈的HandlerThread

HandlerThread mThread = new HandlerThread("test");
mThread.start();
Handler mHandler = new Handler(mThread.getLooper()){

        @Override
        public
 
 void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            super.handleMessage(msg);
        }

};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

上面中通過mHandler傳送訊息就可以在mThread中處理了，並且這個mThread不是UIThread，不會阻塞主執行緒。
HandlerThread是一個好東西，在原始碼中處處可見，希望對此不熟悉的新手及時去學習下它的用法。

Linux下c語言的Thread

java世界的Thread很方便，那麼c呢？
Android基於linux所以，多執行緒程式設計也應該基於linux下的多執行緒。linux下的c語言用pthread。大家可以看這篇文章。

linux下C/C++,多執行緒pthread

我把裡面的例子改良了一下
test.c

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

//執行緒函式
void *test(void *ptr)
{
    int i;
    for(i=0;i<8;i++)
    {
        printf("the pthread running ,count: %d\n",i);
        sleep(1); 
    }

}


int main(void)
{
    pthread_t pId;
    int i,ret;
    //建立子執行緒，執行緒id為pId
    ret = pthread_create(&pId,NULL,test,NULL);

    if(ret != 0)
    {
        printf("create pthread error!\n");
        exit(1);
    }

    for(i=0;i < 5;i++)
    {
        printf("main thread running ,count : %d\n",i);
        sleep(1);
    }

    printf("main thread will exit when pthread is over\n");
    //等待執行緒pId的完成
    pthread_join(pId,NULL);
    printf("main thread  exit\n");

    return 0;

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

然後編譯

gcc -o test test.c -lpthread
./test
  • 1
  • 2

執行結果如下

main thread running ,count : 0
the pthread running ,count: 0
main thread running ,count : 1
the pthread running ,count: 1
main thread running ,count : 2
the pthread running ,count: 2
main thread running ,count : 3
the pthread running ,count: 3
main thread running ,count : 4
the pthread running ,count: 4
main thread will exit when pthread is over
the pthread running ,count: 5
the pthread running ,count: 6
the pthread running ,count: 7
main thread  exit
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

例子比較簡單，主要是建立一個執行緒，然後主執行緒等待子執行緒執行完畢再退出。

Android Framework中的Thread

下面焦點回到文章的主題當中，我們來看看Framework中常用的Thread是個何種形態。
先看看活生生的例子。
在原始碼中搜索threadLoop，當然也可以搜尋thread,然後隨便挑選一個Thread子類進行研究。這裡挑選
/frameworks/av/services/audioflinger/AudioWatchdog.h

#ifndef AUDIO_WATCHDOG_H
#define AUDIO_WATCHDOG_H

#include <time.h>
#include <utils/Thread.h>

namespace android {

......

class AudioWatchdog : public Thread {

public:
    AudioWatchdog(unsigned periodMs = 50) : Thread(false /*canCallJava*/), mPaused(false),
            mPeriodNs(periodMs * 1000000), mMaxCycleNs(mPeriodNs * 2),
            // mOldTs
            // mLogTs initialized below
            mOldTsValid(false), mUnderruns(0), mLogs(0), mDump(&mDummyDump)
        {
#define MIN_TIME_BETWEEN_LOGS_SEC 60
            // force an immediate log on first underrun
            mLogTs.tv_sec = MIN_TIME_BETWEEN_LOGS_SEC;
            mLogTs.tv_nsec = 0;
        }
    virtual         ~AudioWatchdog() { }

     // Do not call Thread::requestExitAndWait() without first calling requestExit().
    // Thread::requestExitAndWait() is not virtual, and the implementation doesn't do enough.
    virtual void        requestExit();

    // FIXME merge API and implementation with AudioTrackThread
    void            pause();        // suspend thread from execution at next loop boundary
    void            resume();       // allow thread to execute, if not requested to exit

    // Where to store the dump, or NULL to not update
    void            setDump(AudioWatchdogDump* dump);

private:
    virtual bool    threadLoop();

    Mutex           mMyLock;        // Thread::mLock is private
    Condition       mMyCond;        // Thread::mThreadExitedCondition is private
    bool            mPaused;        // whether thread is currently paused

    ......
};

}   // namespace android

#endif  // AUDIO_WATCHDOG_H
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

我們可以看到AudioWatchDog確實是Thread的子類，那好，下面看實現。
/frameworks/av/services/audioflinger/AudioWatchdog.cpp

#define LOG_TAG "AudioWatchdog"
//#define LOG_NDEBUG 0

#include <utils/Log.h>
#include "AudioWatchdog.h"

namespace android {


bool AudioWatchdog::threadLoop()
{
    {
        AutoMutex _l(mMyLock);
        if (mPaused) {
            mMyCond.wait(mMyLock);
            // ignore previous timestamp after resume()
            mOldTsValid = false;
            // force an immediate log on first underrun after resume()
            mLogTs.tv_sec = MIN_TIME_BETWEEN_LOGS_SEC;
            mLogTs.tv_nsec = 0;
            // caller will check for exitPending()
            return true;
        }
    }
    struct timespec newTs;
    int rc = clock_gettime(CLOCK_MONOTONIC, &newTs);
    if (rc != 0) {
        pause();
        return false;
    }
    if (!mOldTsValid) {
        mOldTs = newTs;
        mOldTsValid = true;
        return true;
    }
    time_t sec = newTs.tv_sec - mOldTs.tv_sec;
    long nsec = newTs.tv_nsec - mOldTs.tv_nsec;
    if (nsec < 0) {
        --sec;
        nsec += 1000000000;
    }
    mOldTs = newTs;
    // cycleNs is same as sec*1e9 + nsec, but limited to about 4 seconds
    uint32_t cycleNs = nsec;
    if (sec > 0) {
        if (sec < 4) {
            cycleNs += sec * 1000000000;
        } else {
            cycleNs = 4000000000u;
        }
    }
    mLogTs.tv_sec += sec;
    if ((mLogTs.tv_nsec += nsec) >= 1000000000) {
        mLogTs.tv_sec++;
        mLogTs.tv_nsec -= 1000000000;
    }
    if (cycleNs > mMaxCycleNs) {
        mDump->mUnderruns = ++mUnderruns;
        if (mLogTs.tv_sec >= MIN_TIME_BETWEEN_LOGS_SEC) {
            mDump->mLogs = ++mLogs;
            mDump->mMostRecent = time(NULL);
            ALOGW("Insufficient CPU for load: expected=%.1f actual=%.1f ms; underruns=%u logs=%u",
                mPeriodNs * 1e-6, cycleNs * 1e-6, mUnderruns, mLogs);
            mLogTs.tv_sec = 0;
            mLogTs.tv_nsec = 0;
        }
    }
    struct timespec req;
    req.tv_sec = 0;
    req.tv_nsec = mPeriodNs;
    rc = nanosleep(&req, NULL);
    if (!((rc == 0) || (rc == -1 && errno == EINTR))) {
        pause();
        return false;
    }
    return true;
}

void AudioWatchdog::requestExit()
{
    // must be in this order to avoid a race condition
    Thread::requestExit();
    resume();
}

void AudioWatchdog::pause()
{
    AutoMutex _l(mMyLock);
    mPaused = true;
}

void AudioWatchdog::resume()
{
    AutoMutex _l(mMyLock);
    if (mPaused) {
        mPaused = false;
        mMyCond.signal();
    }
}

}   // namespace android
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101

很明顯，它的核心方法就是threadLoop()，在本文中我們不關心它具體的功能，只想確定它是怎麼啟動的呢？又是怎麼迴圈執行的呢？帶著疑問我又在原始碼中搜索關鍵字AudioWatchdog
結果發現有兩個地方引用了。

/frameworks/av/services/audioflinger/AudioFlinger.h
/frameworks/av/services/audioflinger/AudioFlinger.cpp
  • 1
  • 2

在AudioFlinger.h中MixerThread中有個AudioWatchdog的sp物件


 class MixerThread : public PlaybackThread {
    public:
        MixerThread (const sp<AudioFlinger>& audioFlinger,
                     AudioStreamOut* output,
                     audio_io_handle_t id,
                     audio_devices_t device,
                     type_t type = MIXER);
        virtual             ~MixerThread();





    protected:


                    AudioMixer* mAudioMixer;    // normal mixer
    private:

                    sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread


    };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

我們再看程式碼
/frameworks/av/services/audioflinger/AudioFlinger.cpp

AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
        audio_io_handle_t id, audio_devices_t device, type_t type)
    :   PlaybackThread(audioFlinger, output, id, device, type),
        // mAudioMixer below
        // mFastMixer below
        mFastMixerFutex(0)
        // mOutputSink below
        // mPipeSink below
        // mNormalSink below
{

......
#ifdef AUDIO_WATCHDOG
        // create and start the watchdog
        mAudioWatchdog = new AudioWatchdog();
        mAudioWatchdog->setDump(&mAudioWatchdogDump);
        //AudioWatchdog的run方法在此呼叫，所以執行緒啟動
        mAudioWatchdog->run("AudioWatchdog", PRIORITY_URGENT_AUDIO);
        tid = mAudioWatchdog->getTid();
        err = requestPriority(getpid_cached, tid, kPriorityFastMixer);
        if (err != 0) {
            ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
                    kPriorityFastMixer, getpid_cached, tid, err);
        }
#endif

......
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

刪掉不相關程式碼，我們看到AudioWatchdog物件確實建立了，並且呼叫了它的run方法。在java中Thread的run方法就是啟動，這個也應該如此。但是如之前的原始碼所示AudioWatchdog.cpp中並沒有實現run方法，怎麼辦呢？別緊張，它還有父類Thread.

/frameworks/native/include/utils/Thread.h


#ifndef _LIBS_UTILS_THREAD_H
#define _LIBS_UTILS_THREAD_H

#include <stdint.h>
#include <sys/types.h>
#include <time.h>

#if defined(HAVE_PTHREADS)
# include <pthread.h>
#endif

#include <utils/Condition.h>
#include <utils/Errors.h>
#include <utils/Mutex.h>
#include <utils/RefBase.h>
#include <utils/Timers.h>
#include <utils/ThreadDefs.h>

// ---------------------------------------------------------------------------
namespace android {
// ---------------------------------------------------------------------------

class Thread : virtual public RefBase
{
public:
    // Create a Thread object, but doesn't create or start the associated
    // thread. See the run() method.
                        Thread(bool canCallJava = true);
    virtual             ~Thread();

    // Start the thread in threadLoop() which needs to be implemented.
    virtual status_t    run(    const char* name = 0,
                                int32_t priority = PRIORITY_DEFAULT,
                                size_t stack = 0);

    // Ask this object's thread to exit. This function is asynchronous, when the
    // function returns the thread might still be running. Of course, this
    // function can be called from a different thread.
    virtual void        requestExit();

    // Good place to do one-time initializations
    virtual status_t    readyToRun();

    // Call requestExit() and wait until this object's thread exits.
    // BE VERY CAREFUL of deadlocks. In particular, it would be silly to call
    // this function from this object's thread. Will return WOULD_BLOCK in
    // that case.
            status_t    requestExitAndWait();

    // Wait until this object's thread exits. Returns immediately if not yet running.
    // Do not call from this object's thread; will return WOULD_BLOCK in that case.
            status_t    join();

#ifdef HAVE_ANDROID_OS
    // Return the thread's kernel ID, same as the thread itself calling gettid() or
    // androidGetTid(), or -1 if the thread is not running.
            pid_t       getTid() const;
#endif

protected:
    // exitPending() returns true if requestExit() has been called.
            bool        exitPending() const;

private:
    // Derived class must implement threadLoop(). The thread starts its life
    // here. There are two ways of using the Thread object:
    // 1) loop: if threadLoop() returns true, it will be called again if
    //          requestExit() wasn't called.
    // 2) once: if threadLoop() returns false, the thread will exit upon return.
    virtual bool        threadLoop() = 0;

private:
    Thread& operator=(const Thread&);
    static  int             _threadLoop(void* user);
    const   bool            mCanCallJava;
    // always hold mLock when reading or writing
            thread_id_t     mThread;
    mutable Mutex           mLock;
            Condition       mThreadExitedCondition;
            status_t        mStatus;
    // note that all accesses of mExitPending and mRunning need to hold mLock
    volatile bool           mExitPending;
    volatile bool           mRunning;
            sp<Thread>      mHoldSelf;
#ifdef HAVE_ANDROID_OS
    // legacy for debugging, not used by getTid() as it is set by the child thread
    // and so is not initialized until the child reaches that point
            pid_t           mTid;
#endif
};


}; // namespace android

// ---------------------------------------------------------------------------
#endif // _LIBS_UTILS_THREAD_H
//
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98

可以看到確實有run方法。那下面看看它的實現

status_t Thread::run(const char* name, int32_t priority, size_t stack)
{
    Mutex::Autolock _l(mLock);

    if (mRunning) {
        // thread already started
        return INVALID_OPERATION;
    }

    // reset status and exitPending to their default value, so we can
    // try again after an error happened (either below, or in readyToRun())
    mStatus = NO_ERROR;
    mExitPending = false;
    mThread = thread_id_t(-1);

    // hold a strong reference on ourself
    mHoldSelf = this;

    mRunning = true;

    bool res;
    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;   // something happened!
        mRunning = false;
        mThread = thread_id_t(-1);
        mHoldSelf.clear();  // "this" may have gone away after this.

        return UNKNOWN_ERROR;
    }

    // Do not refer to mStatus here: The thread is already running (may, in fact
    // already have exited with a valid mStatus result). The NO_ERROR indication
    // here merely indicates successfully starting the thread and does not
    // imply successful termination/execution.
    return NO_ERROR;

    // Exiting scope of mLock is a memory barrier and allows new thread to run
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

run（）方法中有這麼一段

if (mCanCallJava) {
        res = createThreadEtc(_threadLoop,
                this, name, priority, stack, &mThread);
    } else {
        res = androidCreateRawThreadEtc(_threadLoop,
                this, name, priority, stack, &mThread);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

mCanCallJava的意思是能不能被JNI層呼叫，然後根據值去建立Thread，這裡有兩個分支，我們就選擇createThreadEtc()
最終程式碼會走到這裡

int androidCreateRawThreadEtc(android_thread_func_t entryFunction,
                               void *userData,
                               const char* threadName,
                               int32_t threadPriority,
                               size_t threadStackSize,
                               android_thread_id_t *threadId)
{
    ......
        entryFunction = (android_thread_func_t)&thread_data_t::trampoline;
        userData = t;
    }
#endif

    if (threadStackSize) {
        pthread_attr_setstacksize(&attr, threadStackSize);
    }

    errno = 0;
    pthread_t thread;
    //在此建立，文章開頭我有寫例子怎麼用c語言建立一個執行緒
    int result = pthread_create(&thread, &attr,
                    (android_pthread_entry)entryFunction, userData);
    pthread_attr_destroy(&attr);
    if (result != 0) {
        ALOGE("androidCreateRawThreadEtc failed (entry=%p, res=%d, errno=%d)\n"
             "(android threadPriority=%d)",
            entryFunction, result, errno, threadPriority);
        return 0;
    }

    ......
    return 1;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

刪除了不相關程式碼，大家看看是不是很熟悉啊。我在文章開始的部分就寫出了linux下c語言pthread建立執行緒的例子，大家可以回頭看看。也就是pthread_create()。這裡面傳進來的entryFunction是Thread中的_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.
                //呼叫threadLoop()
                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;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65

_threadLoop()這個方法就是Thread的最大祕密，它是一個while迴圈。

1、建立執行緒時，會sp和wp一次執行緒本身。
2、如果是第一次執行會執行執行緒的readyToRun()方法，再執行threadLoop()，否則，直接執行threadLoop()。
3、threadLoop()方法有返回值，如果threadLoop()返回false的時候，執行緒會做清理工作，然後退出while迴圈，結束執行。

所以在這裡，我開始時的疑問—為什麼執行緒Thread中的threadLoop()能夠迴圈處理資料就到此做了說明。
Thread被建立，
Thread中的run被呼叫，
__threadLoop()被呼叫，
readyToRun()被呼叫，
然後迴圈呼叫threadLoop()。
並且在threadLoop()返回false時，可以退出迴圈。

！！！
!!!
還有，最關鍵的一點是threadLoop能夠迴圈其實是因為呼叫它的_threadLoop()方法裡面有一個while迴圈。

特殊情況

有的時候Android Framework中Thread的run()方法很難發現在哪裡被呼叫。如SurfaceFlinger它也是一個Thread子類。在原始碼中搜索可以發現它的建立位置

class SurfaceFlinger : public BinderService<SurfaceFlinger>,
                       public BnSurfaceComposer,
                       private IBinder::DeathRecipient,
                       private Thread,
                       private HWComposer::EventHandler
{
public:
    static char const* getServiceName() {
        return "SurfaceFlinger";
    }

    SurfaceFlinger();


    /* ------------------------------------------------------------------------
     * Thread interface
     */
    virtual bool threadLoop();
    virtual status_t readyToRun();
    virtual void onFirstRef();


};

// ---------------------------------------------------------------------------
}; // namespace android

#endif // ANDROID_SURFACE_FLINGER_H
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

去找它建立的地方
/frameworks/base/cmds/system_server/library/system_init.cpp

extern "C" status_t system_init()
{
    ALOGI("Entered system_init()");

    sp<ProcessState> proc(ProcessState::self());

    sp<IServiceManager> sm = defaultServiceManager();
    ALOGI("ServiceManager: %p\n", sm.get());



    char propBuf[PROPERTY_VALUE_MAX];
    property_get("system_init.startsurfaceflinger", propBuf, "1");
    if (strcmp(propBuf, "1") == 0) {
        // Start the SurfaceFlinger
        SurfaceFlinger::instantiate();
    }


    // And now start the Android runtime.  We have to do this bit
    // of nastiness because the Android runtime initialization requires
    // some of the core system services to already be started.
    // All other servers should just start the Android runtime at
    // the beginning of their processes's main(), before calling
    // the init function.
    ALOGI("System server: starting Android runtime.\n");
    AndroidRuntime* runtime = AndroidRuntime::getRuntime();

    ALOGI("System server: starting Android services.\n");
    JNIEnv* env = runtime->getJNIEnv();
    if (env == NULL) {
        return UNKNOWN_ERROR;
    }
    jclass clazz = env->FindClass("com/android/server/SystemServer");
    if (clazz == NULL) {
        return UNKNOWN_ERROR;
    }
    jmethodID methodId = env->GetStaticMethodID(clazz, "init2", "()V");
    if (methodId == NULL) {
        return UNKNOWN_ERROR;
    }
    env->CallStaticVoidMethod(clazz, methodId);

    ALOGI("System server: entering thread pool.\n");
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
    ALOGI("System server: exiting thread pool.\n");

    return NO_ERROR;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

我們可以看到

 SurfaceFlinger::instantiate();
  • 1

但它本身並沒有實現instantiate()方法，那之類找它的父類了。
/frameworks/native/include/binder/BinderService.h

namespace android {

template<typename SERVICE>
class BinderService
{
public:
    static status_t publish(bool allowIsolated = false) {
        sp<IServiceManager> sm(defaultServiceManager());
        return sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated);
    }

    static void publishAndJoinThreadPool(bool allowIsolated = false) {
        sp<IServiceManager> sm(defaultServiceManager());
        sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated);
        ProcessState::self()->startThreadPool();
        IPCThreadState::self()->joinThreadPool();
    }

    static void instantiate() { publish(); }

    static status_t shutdown() {
        return NO_ERROR;
    }
};


}; // namespace android
// ---------------------------------------------------------------------------
#endif // ANDROID_BINDER_SERVICE_H
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

會呼叫publish()方法。
而SERVICE在這裡是一個模板類。在這裡SERVICE自然對應SurfaceFlinger
所以publish()會向ServiceManager新增一個Service這個Service就是Surfaceflinger。

然後我們看SurfaceFlinger的建構函式
/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

SurfaceFlinger::SurfaceFlinger()
    :   BnSurfaceComposer(), Thread(false),
        mTransactionFlags(0),
        mTransactionPending(false),
        mAnimTransactionPending(false),
        mLayersRemoved(false),
        mRepaintEverything(0),
        mBootTime(systemTime()),
        mVisibleRegionsDirty(false),
        mHwWorkListDirty(false),
        mDebugRegion(0),
        mDebugDDMS(0),
        mDebugDisableHWC(0),
        mDebugDisableTransformHint(0),
        mDebugInSwapBuffers(0),
        mLastSwapBufferTime(0),
        mDebugInTransaction(0),
        mLastTransactionTime(0),
        mBootFinished(false)
{
    ALOGI("SurfaceFlinger is starting");

    // debugging stuff...
    char value[PROPERTY_VALUE_MAX];

    property_get("debug.sf.showupdates", value, "0");
    mDebugRegion = atoi(value);

    property_get("debug.sf.ddms", value, "0");
    mDebugDDMS = atoi(value);
    if (mDebugDDMS) {
        if (!startDdmConnection()) {
            // start failed, and DDMS debugging not enabled
            mDebugDDMS = 0;
        }
    }
    ALOGI_IF(mDebugRegion, "showupdates enabled");
    ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

但是遺憾的是沒有發現run()方法的影蹤，沒有辦法只得去父類構造方法看
結果發現也沒有！！！

沒有辦法，繼續在原始碼中搜索SurfaceFlinger，結果發現與之相關的資訊大多是sp<SurfaceFlinger>
就看看sp吧。
sp是Android在c++中搞得類似java中弱引用、強引用的一套指標概念，那應該是方便回收吧。
而Android Framework中的c++世界，RefBase這個類有點像java中的Object.
而sp是一個模板類。這部分內容，請看點選下面連結

上面的連結講得還算詳細。這裡糾結sp的過多細節，長話短說，總之第一次對SurfaceFlinger引用呼叫sp<SurfaceFlinger>時會呼叫SurfaceFlinger的onFirstRef()方法。
那好，看程式碼吧

void SurfaceFlinger::onFirstRef()
{
    mEventQueue.init(this);
    //run方法在此被呼叫
    run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY);

    // Wait for the main thread to be done with its initialization
    mReadyToRunBarrier.wait();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

看見沒有？run()方法在這裡呼叫了。

所以，在Framework中如果你找不到一個Thread在何處被啟動，那麼去它的onFirstRef()方法中去看看吧

相關推薦

Android Framework中的執行緒Thread及它的threadLoop方法

當初跟蹤Camera的程式碼中的時候一直追到了HAL層，而在Framework中的程式碼看見了許許多多的Thread。它們普遍的特點就是有一個threadLoop方法。按照字面的意思應該是這個執行緒能夠迴圈處理資料。對應我想到到了java上層中的HandlerThread，這個估計也差不多，但當時心裡總有一

Android開發中執行緒的複用

專案需要在socket程式設計中傳送指令的執行緒應該實現複用，而不是每次點選一次操作就新建一次執行緒(貌似重複建立執行緒比較耗資源)，因為socket的寫操作不是阻塞方法，所以必須用一個死迴圈來保證執行緒不被結束，想到利用執行緒的等待與喚醒模擬阻塞方法的效果。即使用者傳送指

Android 執行緒 thread 兩種實現方法！

這篇文章中有三點需要提前說明一下， 一： 在android中有兩種實現執行緒thread的方法： 一種是，擴充套件java.lang.Thread類 另一種是，實現Runnable介面 二： Thread類代表執行緒類，它的兩個最主要的方法是： run()——包含執

Junit單元測試+aop+spring+執行緒池，在進行Junit測試時切面中執行緒池內呼叫的方法不執行

一、問題背景： 寫了一個切面，指向某service包下的所有類及方法，當該service包下方法被呼叫時切面執行，切面中用了執行緒池ExecutorService pool = Executors.newFixedThreadPool(5);執行緒池內呼叫了dao層的方法。 二、問題描述：單

java中執行緒同步的幾種方法

方法一： 使用synchronized關鍵字  由於java的每個物件都有一個內建鎖，當用此關鍵字修飾方法時， 內建鎖會保護整個方法。在呼叫該方法前，需要獲得內建鎖，否則就處於阻塞狀態。 注： synchronized關鍵字也可以修飾靜態方法，此時如果呼叫該靜態方法，將會

Android React Native在Android Studio中執行bundleReleaseJsAndAssets 打包失敗的解決方法

react-native bundle --platform android --dev false --entry-file index.android.js --bundle-output C:\Users\Administrator\Desktop

java 創造執行緒 Thread 的三種方法

發現 java 的不少例子中都涉及到執行緒，看來執行緒是 java 蠻重要的一部分的。 但最近看 執行緒 的一些講解時，覺得並不是很好理解，有點抽象。 邊看邊總結吧。 最近查閱到：java 程式設計一般情況下用不到多執行緒。多執行緒一般在開發 web 時 用到。 執行執行緒

如何在android framework裡建立執行緒Thread

android 執行緒Thread介紹: https://blog.csdn.net/qq_33670826/article/details/81483520 下面在安卓display裡建立執行緒為例： diff --git a/display/display/DisplayManage

Java中的執行緒Thread解析及用途

Java中的執行緒 程序和執行緒 在併發性程式中，有兩個基本的執行單元：程序和執行緒。在Java程式語言中，併發程式設計大多數情況下都是和執行緒相關。然而，程序也是很重要的。 一個計算機系統中通常都有很多活動的程序和執行緒。這一點即使是在只有一個執行核心，並且在給

Android中執行緒的建立及啟動

 Android中執行緒的型別為Thread型別，我們在構建執行緒物件時通常會參考如下構造方法？ 1）Thread（）： 構建Thread類子類物件，然後重寫run方法； 2）Thread（Runnable r）：採用此方式構建物件必須傳入一個Runnble型別的物件。

Java多執行緒原理及Thread類的使用

一、程序與執行緒的區別 1.程序是應用程式在記憶體總分配的空間。（正在執行中的程式） 2.執行緒是程序中負責程式執行的執行單元、執行路徑。 3.一個程序中至少有一個執行緒在負責程序的執行。 4.一個程序中有多個執行緒在執行的程式，為多執行緒程式。 5.多執行緒技術是為了解決多部分程式碼同時執行。

php中關於執行緒thread的使用

【原文：http://www.01happy.com/php-thread-introduction/】 php通過擴充套件pthreads也可以支援執行緒上的操作，在mac下可以通過brew安裝pthreads擴充套件。 安裝pthreads擴充套件 搜尋pthre

JVMTI 中的JNI系列函式，執行緒安全及除錯技巧

JVMTI 中的JNI系列函式，執行緒安全及除錯技巧 jni functions 在使用 JVMTI 的過程中，有一大系列的函式是在 JVMTI 的文件中 沒有提及的，但在實際使用卻是非常有用的。這就是 jni functions.

C++中 執行緒函式為靜態函式 及 類成員函式作為回撥函式

 執行緒函式為靜態函式： 　　執行緒控制函式和是不是靜態函式沒關係,靜態函式是在構造中分配的地址空間,只有在析構時才釋放也就是全域性的東西,不管執行緒是否執行,靜態函式的地址是不變的,並不在執行緒堆疊中static只是起了一個裝飾的作用,所以二者並沒有必然的關係 　　執行緒也是一種

Java中執行緒建立的方式：繼承thread類與實現Runnable介面

Java中執行緒的建立有兩種方式： 1．  通過繼承Thread類，重寫Thread的run()方法，將執行緒執行的邏輯放在其中 2．  通過實現Runnable介面，例項化Thread類     在實際應用中，我們經常用到多執行緒，如車站的售票系統，車站的

Java中的執行緒Thread方法之---suspend()和resume()

案例一：(通過打斷點除錯) package com.threadstop.demo; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.u

Android/java多執行緒(三)-HandlerThread的使用場景及原始碼解析

HandlerThread是什麼？ 點開類楸一眼，這貨是這樣介紹自己的： * Handy class for starting a new thread that has a looper. The looper can then be * used to create h

java中執行緒與執行緒池的利弊（android適用）

介紹new Thread的弊端及Java四種執行緒池的使用，對Android同樣適用。本文是基礎篇，後面會分享下執行緒池一些高階功能。 1、new Thread的弊端 執行一個非同步任務你還只是如下new Thread嗎？ new Thread(new Runnable(

Java併發程式設計中四種執行緒池及自定義執行緒使用教程

引言 通過前面的文章，我們學習了Executor框架中的核心類ThreadPoolExecutor ，對於執行緒池的核心排程機制有了一定的瞭解，並且成功使用ThreadPoolExecutor 建立了執行緒池。 而在Java中，除了ThreadPoolExecutor ，Executor框

C#中執行緒間操作無效: 從不是建立控制元件 txtBOX 的執行緒訪問它

delegate void 委託名（方法名）; void 方法名（） ｛ if(txtBox.invokeRequered) { 委託名 d=new 委託名（）; txtBox.invoke(d); } else { 具體的執行語句 } ｝ 原來是存在跨執行緒呼叫控制元件的問題