本文使用android版本为:Android pie_9.0.0_r3
在Android的Framework层,使用线程时都是Thread
类,究其根本还是POSIX标准的pthread
类实现,只不过加入了一些android中特有的特性,比如:继承RefBase
,将其纳入只能指针体系。不过因为对pthread进行了二次包装,其具体的线程相关API已和pthread
大相径庭。在深入Framework代码时,难免会遇到Thread
对象,了解它,对相关代码的理解将会更加顺利。
但只推荐理解,不推荐使用。在开发自己程序时,依然只建议使用pthread
,因为在Thread
类定义的地方,开发者已经做了相关不推荐使用的注释(如下一段代码所示)。至于深层次的原因,暂不得而知。
// /system/core/include/utils/Thread.h
namespace android {
// DO NOT USE: please use std::thread
class Thread : virtual public RefBase {
public:
// 创建线程对象,但并不创建或启动关联线程。
explicit Thread(bool canCallJava = true);
virtual ~Thread();
// 在threadLoop函数中启动线程,threadLoop函数必须被实现
virtual status_t run(const char* name, int32_t priority = PRIORITY_DEFAULT, size_t stack = 0);
// 请求对象的线程退出。 这个函数是异步的,当该函数结束后,线程可能还在运行。
virtual void requestExit();
// 线程运行前执行,可以用于执行一些初始化函数
virtual status_t readyToRun();
// 调用requestExit函数,并且等待对象的线程退出。可能造成死锁
status_t requestExitAndWait();
// 等待直到线程退出。如果线程退出,则该函数立刻return,注意别再对象线程中调用该函数,这样容易导致死锁。
status_t join();
// 用来查看线程是否正在运行
bool isRunning() const;
#if defined(__ANDROID__)
// 和线程调用gettid()函数的调用是一致的,将会返回线程在内核中的ID。如果返回-1则表示线程并未运行。
pid_t getTid() const;
#endif
protected:
// 如果requestExit()函数被调用,则该函数将返回true
bool exitPending() const;
private:
// 子类必须实现的函数。是线程生命周期的开始,在Thread对象中,该函数有两种运行模式
// 1、loop:如果threadLoop() return true, 该函数还将继续被执行,直到requestExit函数被调用
// 2、once:如果threadLoop() return false, 线程将在该函数return时退出。
virtual bool threadLoop() = 0;
private:
Thread& operator=(const Thread&);
static int _threadLoop(void* user);
const bool mCanCallJava;
// 读或写时总是持有mLock
thread_id_t mThread; // 由创建线程时,pthread_t值的指针类型转换而来
mutable Mutex mLock;
Condition mThreadExitedCondition;
status_t mStatus;
// 请注意,所有对mExitPending和running的访问都需要持有mLock
volatile bool mExitPending;
volatile bool mRunning;
sp mHoldSelf;
#if defined(__ANDROID__)
// 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
上述是Thread类头文件中对于Thread的定义,我们重点关注构造函数和虚函数实现,即如下函数:
onFirstRef()
:从RefBase
处即成的智能指针第一次创建的函数。run
:创建线程的函数,一般在threadLoop()
函数中被调用readyToRun()
:线程准备函数_threadLoop()
:线程循环函数requestExit()
:请求退出函数接下来也会以此为序,对各个重要函数实现作详细解读。
Thread::Thread(bool canCallJava) :
mCanCallJava(canCallJava), mThread(thread_id_t(-1)), mLock("Thread::mLock"),
mStatus(NO_ERROR), mExitPending(false), mRunning(false)
#if defined(__ANDROID__)
, mTid(-1)
#endif
{
}
Thread::~Thread()
{
}
可以看到,构造函数非常简单,都只是初始化一些私有变量,简单了解一下这些变量的作用:
requestExit()
,调用过则返回true析构函数更简单,直接啥也没做。相信一些释放资源的工作都分配到其它函数中了。
当Thread对象创建,并被智能指针(如sp
该函数通常是用于使用者在线程运行之前,做一些准备工作的。所以,在默认实现中,直接返回了NO_ERROR,如果子线程有需要可以直接重写,以达到对应目的。
// /system/core/libutils/Threads.cpp
status_t Thread::readyToRun()
{
return NO_ERROR;
}
真正创建线程的函数。
status_t Thread::run(const char* name, int32_t priority, size_t stack) {
// 当线程发生异常,需要重新尝试时,需要将线程相关状态初始化到最开始的状态。
mStatus = NO_ERROR;
mExitPending = false;
mThread = thread_id_t(-1);
// 让Thread对象拥有自己的强指针,防止被销毁
mHoldSelf = this;
mRunning = true; // 标志线程已经运行,不一定正在运行。自己体会
bool res;
if (mCanCallJava) {
res = createThreadEtc(_threadLoop, this, name, priority, stack, &mThread);
} else { // 将_threadLoop作为线程函数,创建线程
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" 引用减一
return UNKNOWN_ERROR;
}
return NO_ERROR;
}
可以创建一个新线程的入口有两个:createThreadEtc()
和 androidCreateRawThreadEtc()
。决定变量在于mCanCallJava
,从变量的字面意思来说,就是如果变量为true,创建的线程可以被java代码调用。如果为false则在本地使用。
其实createThreadEtc()
函数创建线程,最终也会使用 androidCreateRawThreadEtc()
函数,只不过createThreadEtc()
会在调用 androidCreateRawThreadEtc()
函数之前,会去初始化JNI部分,使得java代码可以直接调用该线程。至于如何初始化,这主要是JNI部分的内容,就不在本文中展开了。
int androidCreateRawThreadEtc(android_thread_func_t entryFunction, // 线程函数
void *userData, // 线程函数对应的参数
const char* threadName __android_unused, // 线程名称
int32_t threadPriority,
size_t threadStackSize, // 线程栈大小
android_thread_id_t *threadId)
{
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); // 意味着子线程结束后自行释放资源,不需要主线程等待
#if defined(__ANDROID__)
if (threadPriority != PRIORITY_DEFAULT || threadName != NULL) {
thread_data_t* t = new thread_data_t;
t->priority = threadPriority;
t->threadName = threadName ? strdup(threadName) : NULL;
t->entryFunction = entryFunction;
t->userData = userData;
entryFunction = (android_thread_func_t)&thread_data_t::trampoline;
userData = t;
}
#endif
if (threadStackSize) { // 如果有指定栈大小,将其设置为线程栈大小
pthread_attr_setstacksize(&attr, threadStackSize);
}
errno = 0;
pthread_t thread;
int result = pthread_create(&thread, &attr, (android_pthread_entry)entryFunction, userData);
pthread_attr_destroy(&attr);
// ...
if (threadId != NULL) {
*threadId = (android_thread_id_t)thread; // XXX: this is not portable
}
return 1;
}
总结一下:
androidCreateRawThreadEtc()
函数的作用是:封装了创建线程的操作。
run()
函数通常调用androidCreateRawThreadEtc()
,并为其指定_threadLoop
函数指针作为线程函数,最终创建出了一个真正的线程,并通过参数将线程ID存储在mThread
变量中。此时,如果一切顺利,mRunning = true
。
该函数是真正的线程函数,通过在run()
函数中调用androidCreateRawThreadEtc()
将该函数设置给pthread线程。
int Thread::_threadLoop(void* user) { // 线程函数创建时,传递的线程参数就是Thread对象的this指针
Thread* const self = static_cast(user);
// ...
bool first = true;
do {
bool result;
if (first) { // 第一次运行
first = false; // 只执行一次
self->mStatus = self->readyToRun(); // 调用Thread对象的readyToRun()函数
result = (self->mStatus == NO_ERROR);
// 如果状态正常,并且没有调用过退出相关函数,则一直循环执行threadLoop()函数。
if (result && !self->exitPending()) {
result = self->threadLoop();
}
} else { // 后续运行,都全走这里
result = self->threadLoop();
}
{ // 建立mLock作用域
Mutex::Autolock _l(self->mLock);
if (result == false || self->mExitPending) { // 1. 条件满足线程退出
self->mExitPending = true;
self->mRunning = false;
self->mThread = thread_id_t(-1);
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处,是线程退出的两种情况:
threadLoop()
函数的返回值为false时,线程主动结束。mExitPending
为true时,由外界影响被动退出。mExitPending
可以通过requestExit()
函数设置为true。这其中,threadLoop()
函数是一个未被默认实现的函数,必须由子线程实现。通常子线程重写该函数后,会在其中实现主要的线程逻辑,当子线程想要结束线程时,只要该函数返回false即可,如果该函数返回true,并且外界没有调用requteExit()
和requestExitAndWait()
函数,那么threadLoop()
函数将会一直循环执行下去。
该函数非常简单,直接看。
void Thread::requestExit()
{
Mutex::Autolock _l(mLock);
mExitPending = true;
}
本文相对简单,强调了几个重要函数及其实现。总结一下
onFirstRef()
:继承子RefBase
,通常在这里初始化一些变量,并不限于线程。readyToRun()
:线程第一次运行时会调用的函数,通常在这里初始化一些线程相关的变量或数据。threadLoop()
:线程函数,在其中实现主要的线程逻辑,函数返回true时,还会重新运行,知道函数返回false,或者requestExit()
类型的函数被调用requestExit()
:线程被动退出函数,由其它线程调用,调用后线程可能不会立刻退出。