/android/libcore/libart/src/main/java/java/lang/Thread.java
/art/runtime/native/java_lang_Thread.cc
/art/runtime/native/java_lang_Object.cc
/art/runtime/thread.cc /system/core/libutils/Threads.cpp
/system/core/include/utils/AndroidThreads.h
/frameworks/base/core/jni/AndroidRuntime.cpp

一.概述

Android线程,一般地就是指Android虚拟机线程,而虚拟机线程由是通过系统调用而创建的Linux线程。纯粹的Linux线程与虚拟机线程的区别在于虚拟机线程具有运行Java代码的runtime. 除了虚拟机线程,还有Native线程,对于Native线程有分为是否具有访问Java代码的两类线程。接下来,本文分析介绍这3类线程的创建过程。

二. Java线程

2.1 Thread.start

[-> Thread.java]

public synchronized void start() {
checkNotStarted(); //保证线程只有启动一次
hasBeenStarted = true;
//[见流程2.2]
nativeCreate(this, stackSize, daemon);
}

nativeCreate()这是一个native方法,那么其所对应的JNI方法在哪呢?在java_lang_Thread.cc中通过gMethods是一个JNINativeMethod数组,其中一项为:

NATIVE_METHOD(Thread, nativeCreate, "(Ljava/lang/Thread;JZ)V"),

这里的NATIVE_METHOD定义在java_lang_Object.cc文件,如下:

#define NATIVE_METHOD(className, functionName, signature) \
{ #functionName, signature, reinterpret_cast<void*>(className ## _ ## functionName) }

将宏定义展开并代入,可得所对应的方法名为Thread_nativeCreate,那么接下来进入该方法。

2.2 Thread_nativeCreate

[-> java_lang_Thread.cc]

static void Thread_nativeCreate(JNIEnv* env, jclass, jobject java_thread,
jlong stack_size, jboolean daemon) {
//【见小节2.3】
Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE);
}

2.3 CreateNativeThread

[-> thread.cc]

void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
Thread* self = static_cast<JNIEnvExt*>(env)->self;
Runtime* runtime = Runtime::Current(); ...
Thread* child_thread = new Thread(is_daemon);
child_thread->tlsPtr_.jpeer = env->NewGlobalRef(java_peer);
stack_size = FixStackSize(stack_size); env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
reinterpret_cast<jlong>(child_thread)); std::unique_ptr<JNIEnvExt> child_jni_env_ext(
JNIEnvExt::Create(child_thread, Runtime::Current()->GetJavaVM())); int pthread_create_result = 0;
if (child_jni_env_ext.get() != nullptr) {
pthread_t new_pthread;
pthread_attr_t attr;
child_thread->tlsPtr_.tmp_jni_env = child_jni_env_ext.get();
//创建线程【见小节2.4】
pthread_create_result = pthread_create(&new_pthread,
&attr, Thread::CreateCallback, child_thread); if (pthread_create_result == 0) {
child_jni_env_ext.release();
return;
}
} ...
}

2.4 pthread_create

pthread_create是pthread库中的函数,通过syscall再调用到clone来请求内核创建线程。

  • 原型:int pthread_create((pthread_t thread, pthread_attr_t *attr, void *(start_routine)(void *), void *arg)
  • 头文件:#include
  • 输入参数:thread:线程标识符; attr:线程属性设置; start_routine:线程函数的起始地址; arg:传递给start_routine的参数;
  • 返回值:成功则返回0;出错则返回-1。
  • 功能:创建线程,并调用线程起始地址所指向的函数start_routine。

关于pthread_create的分析,在后续Linux系列文章会再进一步深入分析。

三. Native线程(C/C++)

3.1 Thread.run

[-> Threads.cpp]

status_t Thread::run(const char* name, int32_t priority, size_t stack)
{
Mutex::Autolock _l(mLock);
//保证只会启动一次
if (mRunning) {
return INVALID_OPERATION;
}
...
mRunning = true; bool res; if (mCanCallJava) {
//还能调用Java代码的Native线程【见小节4.1】
res = createThreadEtc(_threadLoop,
this, name, priority, stack, &mThread);
} else {
//只能调用C/C++代码的Native线程【见小节3.2】
res = androidCreateRawThreadEtc(_threadLoop,
this, name, priority, stack, &mThread);
} if (res == false) {
...//清理
return UNKNOWN_ERROR;
}
return NO_ERROR;
}

mCanCallJava在Thread对象创建时,在构造函数中默认设置mCanCallJava=true.

  • 当mCanCallJava=true,则代表创建的是不仅能调用C/C++代码,还能能调用Java代码的Native线程
  • 当mCanCallJava=false,则代表创建的是只能调用C/C++代码的Native线程。

3.2 androidCreateRawThreadEtc

[-> Threads.cpp]

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 (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;
} if (threadStackSize) {
pthread_attr_setstacksize(&attr, threadStackSize);
} errno = 0;
pthread_t thread;
//通过pthread_create创建线程
int result = pthread_create(&thread, &attr,
(android_pthread_entry)entryFunction, userData);
pthread_attr_destroy(&attr);
if (result != 0) {
... //创建失败,则返回
return 0;
} if (threadId != NULL) {
*threadId = (android_thread_id_t)thread;
}
return 1;
}

此处entryFunction所指向的是由[小节3.1]传递进来的,其值为_threadLoop。

3.3 _threadLoop

[-> Threads.cpp]

int Thread::_threadLoop(void* user)
{
//user是指Thread对象
Thread* const self = static_cast<Thread*>(user); sp<Thread> strong(self->mHoldSelf);
wp<Thread> weak(strong);
self->mHoldSelf.clear(); //该参数对于gdb调试很有作用
self->mTid = gettid(); bool first = true;
do {
bool result;
if (first) {
first = false;
//首次运行时会调用readyToRun()做一些初始化准备工作
self->mStatus = self->readyToRun();
result = (self->mStatus == NO_ERROR);
if (result && !self->exitPending()) {
//
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_id_t(-1);
self->mThreadExitedCondition.broadcast();
break;
}
} strong.clear(); //释放强引用
strong = weak.promote(); //重新请求强引用,用于下一次的循环
} while(strong != 0); return 0;
}

不断循环地调用成员方法threadLoop()。当满足以下任一条件,则该线程将退出循环:

  1. 当前线程状态存在错误,即mStatus != NO_ERROR;
  2. 当前线程即将退出, 即mExitPending = true; 调用Thread::requestExit()可触发该过程。
  3. 当前线程的强引用释放后,无法将弱引用提升成强引用的情况。

对于Native线程的实现方法,往往是通过继承Thread对象,通过覆写父类的readyToRun()和threadLoop()完成自定义线程的功能。

四. Native线程(Java)

4.1 createThreadEtc

[-> AndroidThreads.h]

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)
{
//【见小节4.2】
return androidCreateThreadEtc(entryFunction, userData, threadName,
threadPriority, threadStackSize, threadId) ? true : false;
}

4.2 androidCreateThreadEtc

[-> Threads.cpp]

int androidCreateThreadEtc(android_thread_func_t entryFunction,
void *userData,
const char* threadName,
int32_t threadPriority,
size_t threadStackSize,
android_thread_id_t *threadId)
{
//【见小节4.3】
return gCreateThreadFn(entryFunction, userData, threadName,
threadPriority, threadStackSize, threadId);
}

此处gCreateThreadFn默认指向androidCreateRawThreadEtc函数。 文章Android系统启动-zygote篇的小节[3.3.1]已介绍 通过androidSetCreateThreadFunc()方法,gCreateThreadFn指向javaCreateThreadEtc函数。

4.3 javaCreateThreadEtc

[-> AndroidRuntime.cpp]

int AndroidRuntime::javaCreateThreadEtc(
android_thread_func_t entryFunction,
void* userData,
const char* threadName,
int32_t threadPriority,
size_t threadStackSize,
android_thread_id_t* threadId)
{
void** args = (void**) malloc(3 * sizeof(void*));
int result; if (!threadName)
threadName = "unnamed thread"; args[0] = (void*) entryFunction;
args[1] = userData;
args[2] = (void*) strdup(threadName); //【见小节4.4】
result = androidCreateRawThreadEtc(AndroidRuntime::javaThreadShell, args,
threadName, threadPriority, threadStackSize, threadId);
return result;
}

4.4 androidCreateRawThreadEtc

[-> Threads.cpp]

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)
{
...
if (threadStackSize) {
pthread_attr_setstacksize(&attr, threadStackSize);
} ...
//通过pthread_create创建线程
int result = pthread_create(&thread, &attr,
(android_pthread_entry)entryFunction, userData);
pthread_attr_destroy(&attr); ...
return 1;
}

此处entryFunction所指向的是由[小节4.3]传递进来的AndroidRuntime::javaThreadShell,接下来,进入该方法。

4.5 javaThreadShell

[-> AndroidRuntime.cpp]

int AndroidRuntime::javaThreadShell(void* args) {
void* start = ((void**)args)[0]; //指向_threadLoop
void* userData = ((void **)args)[1]; //线程对象
char* name = (char*) ((void **)args)[2]; //线程名
free(args);
JNIEnv* env;
int result; //hook虚拟机【见小节4.5.1】
if (javaAttachThread(name, &env) != JNI_OK)
return -1; // 调用_threadLoop()方法见小节4.5.2】
result = (*(android_thread_func_t)start)(userData); //unhook虚拟机见小节4.5.3】
javaDetachThread();
free(name); return result;
}

该方法主要功能:

  1. 调用javaAttachThread():将当前线程hook到当前进程所在的虚拟机,从而既能执行C/C++代码,也能执行Java代码。
  2. 调用_threadLoop():执行当前线程的核心逻辑代码;
  3. 调用javaDetachThread():到此说明线程_threadLoop方法执行完成,则从当前进程的虚拟机中移除该线程。

4.5.1 javaAttachThread

[-> AndroidRuntime.cpp]

static int javaAttachThread(const char* threadName, JNIEnv** pEnv)
{
JavaVMAttachArgs args;
JavaVM* vm;
jint result; vm = AndroidRuntime::getJavaVM(); args.version = JNI_VERSION_1_4;
args.name = (char*) threadName;
args.group = NULL;
// 将当前线程hook到当前进程所在的虚拟机
result = vm->AttachCurrentThread(pEnv, (void*) &args); return result;
}

4.5.2 _threadLoop

[-> Threads.cpp]

int Thread::_threadLoop(void* user)
{
...
do {
if (first) {
...
self->mStatus = self->readyToRun();
result = (self->mStatus == NO_ERROR);
if (result && !self->exitPending()) {
result = self->threadLoop();
}
} else {
result = self->threadLoop();
} Mutex::Autolock _l(self->mLock);
//当result=false则退出该线程
if (result == false || self->mExitPending) {
self->mExitPending = true;
self->mRunning = false;
self->mThread = thread_id_t(-1);
self->mThreadExitedCondition.broadcast();
break;
}
} //释放强引用,让线程有机会退出
strong.clear();
//再次获取强引用,用于下一轮循环
strong = weak.promote();
} while(strong != 0);
return 0;
}

该过程与【小节3.3】完全一致,见上文。

4.5.3 javaDetachThread

[-> AndroidRuntime.cpp]

static int javaDetachThread(void)
{
JavaVM* vm;
jint result; vm = AndroidRuntime::getJavaVM();
//当前进程的虚拟机中移除该线程
result = vm->DetachCurrentThread();
return result;
}

在创建Native进程的整个过程,涉及到JavaVM的AttachCurrentThread和DetachCurrentThread方法,都已深入虚拟机内部原理,本文就先讲到这里,不再深入,后续有精力再深入研究虚拟机,准备写一系列相关文章。

五. 总结

本文介绍了3类线程的创建过程,它们都有一个共同的特点,那就是真正的线程创建过程都是通过调用pthread_create方法(见小节[2.3],[3.2],[4.4]),该方法经过层层调用,最终都会进入clone系统调用,这是linux创建线程或进程的通用接口。

Native线程中是否可以执行Java代码的区别,在于通过javaThreadShell()方法从而实现在_threadLoop()执行前后增加分别将当前线程增加hook到虚拟机和从虚拟机移除的功能。调用过程:

  1. Native线程(Java版):该过程相对比较复杂,见如上流程图:
  2. Native线程: 相对简单,只有上图中的紫色部分:thread.run -> androidCreateRawThreadEtc -> _threadLoop
  3. Java线程: Thread.start -> Thread_nativeCreate -> CreateNativeThread

转自:http://gityuan.com/2016/09/24/android-thread/

理解Android线程创建流程(转)的更多相关文章

  1. 理解Android线程创建流程

    copy from : http://gityuan.com/2016/09/24/android-thread/ 基于Android 6.0源码剖析,分析Android线程的创建过程 /androi ...

  2. 理解Android进程创建流程(转)

    /frameworks/base/core/java/com/android/internal/os/ - ZygoteInit.java - ZygoteConnection.java - Runt ...

  3. Android线程管理(二)——ActivityThread

    线程通信.ActivityThread及Thread类是理解Android线程管理的关键. 线程,作为CPU调度资源的基本单位,在Android等针对嵌入式设备的操作系统中,有着非常重要和基础的作用. ...

  4. Android线程管理(一)——线程通信

    线程通信.ActivityThread及Thread类是理解Android线程管理的关键. 线程,作为CPU调度资源的基本单位,在Android等针对嵌入式设备的操作系统中,有着非常重要和基础的作用. ...

  5. Android线程管理(三)——Thread类的内部原理、休眠及唤醒

    线程通信.ActivityThread及Thread类是理解Android线程管理的关键. 线程,作为CPU调度资源的基本单位,在Android等针对嵌入式设备的操作系统中,有着非常重要和基础的作用. ...

  6. Android线程管理(三)——Thread类的内部原理、休眠及唤醒

    线程通信.ActivityThread及Thread类是理解Android线程管理的关键. 线程,作为CPU调度资源的基本单位,在Android等针对嵌入式设备的操作系统中,有着非常重要和基础的作用. ...

  7. 深入理解 Android 之 View 的绘制流程

    概述 本篇文章会从源码(基于Android 6.0)角度分析Android中View的绘制流程,侧重于对整体流程的分析,对一些难以理解的点加以重点阐述,目的是把View绘制的整个流程把握好,而对于特定 ...

  8. Android线程管理之ThreadLocal理解及应用场景

    前言: 最近在学习总结Android的动画效果,当学到Android属性动画的时候大致看了下源代码,里面的AnimationHandler存取使用了ThreadLocal,激起了我很大的好奇心以及兴趣 ...

  9. android线程池ThreadPoolExecutor的理解

    android线程池ThreadPoolExecutor的理解 线程池 我自己理解看来.线程池顾名思义就是一个容器的意思,容纳的就是ThreadorRunable, 注意:每一个线程都是需要CPU分配 ...

随机推荐

  1. C#中byte类型运算

    首先看下面一段代码 byte x = 1; byte y = 2; byte z = x + y; Console.WriteLine(z); 可能很多人会说显示结果是3. 其实,这段代码无法运行,因 ...

  2. 数论基础之组合数&计数问题

    一.组合数:问题引入:现在有 n 个球,取其中的 k 个球,问一共有多少种方式?答案: 公式直观解释:我们考虑有顺序地取出 k 个球:第一次有 n 种选择,第二次有 n-1 种选择,...,第 k 次 ...

  3. poj3537 Crosses ans Crosses

    题目描述 题解: 一道非常简单的$SG$函数应用. 对于一个长度求它的$SG$函数,然后判断是否为$0$即可. 代码: #include<cstdio> #include<cstri ...

  4. spring踩坑

    org.springframework.web.util.NestedServletException: Request processing failed; nested exception is ...

  5. docker-ce的安装

    Docker提供了两个版本:社区版(CE)和企业版(EE). Docker社区版(CE)是开发人员和小型团队开始使用Docker并尝试使用基于容器的应用的理想之选.Docker CE有两个更新渠道,即 ...

  6. CentOS7安装Tomcat9并配置

    划重点:安装tomcat之前必须先安装jdk  安装教程 1.下载 Tomcat 9 CentOS 7 下创建目录并下载文件:// 链接已更新 cd /usr/local/ mkdir tomcat ...

  7. catalina配置参数

    CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.por ...

  8. linux 服务器 php vue项目部署流程总结

    服务器配置 购买阿里云服务器 (选择ubuntu 16系统 / 内存2G以上) 安全策略, 入规则: 添加端口 20,21,22, 80, 443, 3306, 8080, 安装宝塔 wget -O ...

  9. Linux基础(Ubuntu)

    更换apt源为清华源 1.备份 /etc/apt/sources.list 2.vim 编辑 /etc/apt/sources.list 添加 deb http://mirrors.tuna.tsin ...

  10. Java 多线程执行

    背景: 如果一个任务由多个子任务组成,子任务全部执行完成后然后由主线程对所有子任务结果进行封装,可以采用如下几种方式: 1.基于Guava ListenableFuture 进行: 2.基于Futur ...