在Android中，由于性能等多方面因素，多线程使用的场景较多，基于多线程的消息机制Handler、异步处理AsyncTask、回调方法等也经常会遇到，这里简要分析下Java多线程的使用和原理(针对Thread和Runnable，Callable等不在讨论范围内)

创建多线程

java端多线程的使用比较简单，JDK提供了接口Runnable和类Thread以供多线程使用，实现run方法，执行start函数启动即可，网上例子很多，这边给出最简单的使用：

//1.继承Thread类

public class MyThread extends Thread{

@Overridepublic void run(){

...

}

}

MyThread mThread= newMyThread();

mThread.start();//2.实现Runnable接口

public class MyRunnable implements Runnable {

@Override

public void run(){

...

}

}

Thread thread = new Thread(new MyRunnable());

thread.start();

众所周知，重写run方法，就是确定线程的执行方法；而调用start函数，就是启动多线程执行。如果只调用run方法，和调用正常函数并无区别，还是在当前线程执行。

之所以在实现Runnable接口之后还需要定义Thread对象来调用start函数，就是因为Runnable接口没有start函数 (接口的方法是抽象方法，不能有具体实现，必须在子类覆盖实现，而自己实现start函数又不怎么现实)，所以只能调用其子类Thread提供的start完成多线程的创建执行。

这里给出Thread和Runnable的部分源码：

//Runnable接口非常简单，只有一个虚方法run

public interfaceRunnable {public abstract voidrun();

}//Thread类实现了Runnable，并提供了start方法(下面具体分析)

public class Thread implementsRunnable {public synchronized voidstart() {

...

}privateRunnable target;

@Overridepublic voidrun() {//如果Thread的run未被重写，且Runnable对象不为空，则调用Runnable的run//然而Runnable是接口，不能实例化，run方法也不能实现//这种情况其实就是定义了类A实现了Runnable接口，并用类A的对象作为参数创建了Thread对象

if (target != null) {

target.run();

}

}

}

除了通过定义子类的方式实现多线程，当然也可以通过使用匿名内部类，同样是依据类Thread或接口Runnable

public static voidmain(String[] args) {//3.匿名内部类继承thread

newThread() {public voidrun() {

...

}

}.start();//4.匿名内部类实现runnable，同样依赖于Thread的start创建执行线程

new Thread(newRunnable() {

@Overridepublic voidrun() {

...

}

}).start();

}

从上面的使用实例可以看出，多线程的启动执行工作就在这个start函数中，下面来具体看看

start函数简介

首先看下start函数在Thread.java中的定义

public class Thread implementsRunnable {public synchronized voidstart() {//防止一些由VM启动的线程被人为调用启动(主线程或系统组线程)

if (threadStatus != 0)throw newIllegalThreadStateException();//group主要是对线程队列的操作(记录线程状态，启动、阻塞等的计数等)，对线程自身的运行无关

group.add(this);boolean started = false;try{//线程启动函数，native函数，具体实现在C++端

start0();

started= true;

}finally{try{if (!started) {

group.threadStartFailed(this);

}

}catch(Throwable ignore) {

}

}

}private native voidstart0();

}

经过一些异常处理和状态记录后，启动操作交给底层的C++去实现，启动函数就是这个start0。

按照openjdk的设计，java与c++相对应的类一般选择相同名称。查找后发现在/jdk/src/java.base/share/native/libjava文件夹下有一个同名文件Thread.c。

扫视一眼，Thread.c中确实有start0，但却没有遵循传统的JNI调用函数命名规则(Java_包层级目录_函数名)，而是使用了对函数进行注册的机制——RegisterNatives

RegisterNatives的作用就是向VM注册 java方法C++函数 的映射关系，以便在java端调用native函数时可以快速地定位其对应的C++方法，而且便于修改：改变映射关系数组，再次调用RegisterNatives可覆盖之前的映射关系，而传统的JNI命名规则则需要修改C++方法

下面来看下Thread类是如何使用这个注册机制的：

在java端调用native函数之前，需要主动调用RegisterNatives进行native函数的注册，在Thread.java中，申明并调用了如下native函数

public classThread implements Runnable {//系统注释：确保这个函数是该接口初始化时第一个调用的//这个函数是用于JNI关联C++方法和native函数的，Thread中的线程操作函数并没有使用JNI中传统的名称对应规则，所以需要用这个函数保证native函数有定义可用

private static native voidregisterNatives();//放在static块中，在初始化Thread类时执行一次注册即可，与对象无关

static{

registerNatives();

}

}//对应的C++方法，使用了传统的JNI调用函数命名规则，就在之前提到的Thread.c文件中

JNIEXPORT voidJNICALL

Java_java_lang_Thread_registerNatives(JNIEnv*env, jclass cls)

{//向VM注册native函数的对应关系，此函数具体源码没有找到，这个methods就是native函数的映射表，下面会讲到，cls为类型，对应Java中的Thread，这样就能精确定位Java中的函数

(*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));

}

native函数与C++方法的对应关系结构体及Thread所用到的函数映射表

//描述一个native函数对象和其对应的C++方法

typedef struct{char *name; //native函数名

char *signature; //native函数签名(参数与返回值类型)

void *fnPtr; //对应的函数指针引用(C++中的具体实现函数)

} JNINativeMethod;//函数映射表methods

static JNINativeMethod methods[] ={

{"start0", "()V", (void *)&JVM_StartThread},

{"stop0", "(" OBJ ")V", (void *)&JVM_StopThread},

{"isAlive", "()Z", (void *)&JVM_IsThreadAlive},

{"suspend0", "()V", (void *)&JVM_SuspendThread},

{"resume0", "()V", (void *)&JVM_ResumeThread},

{"setPriority0", "(I)V", (void *)&JVM_SetThreadPriority},

{"yield", "()V", (void *)&JVM_Yield},

{"sleep", "(J)V", (void *)&JVM_Sleep},

{"currentThread", "()" THD, (void *)&JVM_CurrentThread},

{"countStackFrames", "()I", (void *)&JVM_CountStackFrames},

{"interrupt0", "()V", (void *)&JVM_Interrupt},

{"isInterrupted", "(Z)Z", (void *)&JVM_IsInterrupted},

{"holdsLock", "(" OBJ ")Z", (void *)&JVM_HoldsLock},

{"getThreads", "()[" THD, (void *)&JVM_GetAllThreads},

{"dumpThreads", "([" THD ")[[" STE, (void *)&JVM_DumpThreads},

{"setNativeName", "(" STR ")V", (void *)&JVM_SetNativeThreadName},

};

经过RegisterNatives的注册，Java端的native函数start0与C++端的JVM_StartThread形成对应关系，线程启动工作也就落在了JVM_StartThread函数中

//宏JVM_ENTRY--JVM_END，用来对函数进行定义，这里就是定义函数JVM_StartThread

JVM_ENTRY(void, JVM_StartThread(JNIEnv*env, jobject jthread))

JVMWrapper("JVM_StartThread");

JavaThread*native_thread =NULL;bool throw_illegal_thread_state = false;

{//在java线程创建成功(加入到线程队列)之前防止C++本地线程和相关平台数据被释放(平台数据用于创建线程时选择对应平台方法，c++本地线程就是之后的操作线程)

MutexLocker mu(Threads_lock);//防止对一个已存在的线程进行再次创建

if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) !=NULL) {

throw_illegal_thread_state= true;

}else{

jlong size=java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));

size_t sz= size > 0 ? (size_t) size : 0;//创建本地线程(C++线程，根据不同平台选择不同的处理)，设置线程处理函数为thread_entry(下面会讲到)，这里的JavaThread就是主要的线程处理类//其属性包括java层线程对象、jni指针、java层引用计数等以及一系列编译优化内存控制项，控制本地线程的生命周期内活动、与Java端关联等一系列操作(属性、功能很多)

native_thread = new JavaThread(&thread_entry, sz);//经过上面的创建JavaThread对象之后，对象native_thread中应该包含有平台相关信息

if (native_thread->osthread() !=NULL) {//将本地线程加入线程链表、设置优先级，并与java线程对象相关联//作为参数的jthread其实就是java层调用start0的Thread类对象//这里通过句柄将jthread和C++线程关联，通过JNI可直接操作C++线程

native_thread->prepare(jthread);

}

}

}if(throw_illegal_thread_state) {

THROW(vmSymbols::java_lang_IllegalThreadStateException());

}

assert(native_thread!= NULL, "Starting null thread?");if (native_thread->osthread() ==NULL) {deletenative_thread;if(JvmtiExport::should_post_resource_exhausted()) {

JvmtiExport::post_resource_exhausted(

JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR|JVMTI_RESOURCE_EXHAUSTED_THREADS,

os::native_thread_creation_failed_msg());

}

THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),

os::native_thread_creation_failed_msg());

}//本地线程在创建JavaThread对象时已经创建并初始化，在prepare时已与Java对象关联//线程在初始化状态默认被阻塞，在这里主要功能就是唤醒本地线程使其开始运行

Thread::start(native_thread);

JVM_END

从上面的代码中可以看到，除了一些异常处理外，使用到的重要函数有三个，分别是JavaThread、prepare和start。他们的基本功能已经作了相关注释，下面来具体看下

创建线程之JavaThread

JavaThread这个类相当的大，功能相当的多，呵呵！在这里只简述下主要流程

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) : Thread()

{//初始化

initialize();//JNI附加状态，刚开始为未附加(此时线程尚未创建，当然未关联)

_jni_attach_state =_not_attaching_via_jni;//设置属性(线程函数)_entry_point为&thread_entry (参数entry_point对应的值为&thread_entry),后面会用到

set_entry_point(entry_point);//设置线程类型(便宜线程或处理线程)

os::ThreadType thr_type =os::java_thread;

thr_type= entry_point == &compiler_thread_entry ?os::compiler_thread : os::java_thread;//属性值设置完了，那毫无疑问最后这个函数就是最重要的线程创建函数了//注意到函数前的作用域os没，他就是操作系统接口类，提供基于平台的代码，也就是说，create_thread会根据平台不同而不同，这里主要介绍下Linux平台下的相关代码

os::create_thread(this, thr_type, stack_sz);

}

//Linux平台下对应的create_thread实现

bool os::create_thread(Thread*thread, ThreadType thr_type,

size_t req_stack_size) {

assert(thread->osthread() == NULL, "caller responsible");

OSThread* osthread = newOSThread(NULL, NULL);if (osthread ==NULL) {return false;

}//设置线程类型

osthread->set_thread_type(thr_type);//设置状态(内存分配、初始化等状态)

osthread->set_state(ALLOCATED);//设置平台相关数据

thread->set_osthread(osthread);

pthread_attr_t attr;

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);//堆栈大小设置什么的就略过了

size_t stack_size =os::Posix::get_initial_stack_size(thr_type, req_stack_size);

stack_size= align_size_up(stack_size +os::Linux::default_guard_size(thr_type), vm_page_size());

pthread_attr_setstacksize(&attr, stack_size);

pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));

ThreadState state;

{

pthread_t tid;//看到这句是不是很熟悉了，创建线程，处理函数为thread_native_entry//相应的Windows下为_beginthreadex；Solaris下为thr_create

int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);char buf[64];if (ret == 0) {

log_info(os, thread)("Thread started (pthread id:" UINTX_FORMAT ", attributes: %s).",

(uintx) tid, os::Posix::describe_pthread_attr(buf,sizeof(buf), &attr));

}else{

log_warning(os, thread)("Failed to start thread - pthread_create failed (%s) for attributes: %s.",

os::errno_name(ret), os::Posix::describe_pthread_attr(buf,sizeof(buf), &attr));

}//删除临时数据、报错退出

pthread_attr_destroy(&attr);if (ret != 0) {//Need to clean up stuff we've allocated so far

thread->set_osthread(NULL);deleteosthread;return false;

}//向平台数据记录线程号

osthread->set_pthread_id(tid);//初始化成功或者中止

{

Monitor* sync_with_child = osthread->startThread_lock();

MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);while ((state = osthread->get_state()) ==ALLOCATED) {

sync_with_child->wait(Mutex::_no_safepoint_check_flag);

}

}

}//达到上限，退出

if (state ==ZOMBIE) {

thread->set_osthread(NULL);deleteosthread;return false;

}//线程初始化成功，返回

//这里有句系统注释: The thread is returned suspended (in state INITIALIZED),也就是说，创建并初始化成功后，线程默认被阻塞，需要唤醒才能运行 assert(state == INITIALIZED, "race condition");return true;

}

经过函数create_thread处理之后，本地线程就已经创建成功并初始化，处理函数为thread_native_entry。如果正确返回，那此时线程就处于已初始化状态(此时线程尚未加入到进程的线程链表中，且被阻塞)，如果返回错误，那说明创建失败。关于线程的状态，可以参考这篇文章。接下来的就是要看看thread_native_entry在哪定义，是否和我们想的一样，最终执行的是Java端所定义的函数run？

源码中安全检测类代码太多，这边就只列出主要函数

static unsigned __stdcall thread_native_entry(Thread*thread) {

__try {

thread->run();

} __except(topLevelExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) {

}return(unsigned)os::win32::exit_process_or_thread(os::win32::EPT_THREAD, res);

}voidJavaThread::run() {

thread_main_inner();

}voidJavaThread::thread_main_inner() {if (!this->has_pending_exception() &&

!java_lang_Thread::is_stillborn(this->threadObj())) {

{

ResourceMark rm(this);this->set_native_thread_name(this->get_thread_name());

}

HandleMark hm(this);this->entry_point()(this, this);

}

}

ThreadFunction entry_point()const { return _entry_point; }

进过上面的流程过滤，最后定位到了函数 _entry_point，那这个是什么呢？往回看一点点，对，就是在创建JavaThread的函数中，有一个set_entry_point(entry_point)，功能是将_entry_point的值设置为&thread_entry，也就是这边所用的这个_entry_point，而其值就是&thread_entry，这个又是什么呢？来看看定义

static void thread_entry(JavaThread*thread, TRAPS) {

HandleMark hm(THREAD);

Handle obj(THREAD, thread->threadObj());

JavaValue result(T_VOID);//JavaCalls: openjdk中用于C++端调用Java端方法的功能类，在这里不再深入//显然这边就是调用最终的具体执行函数了，来看看是不是run方法//类vmSymbols是用于VM对所用的标识进行快速定位的，在他的命名空间中，定义有一系列(函数名，符号名)的对应关系//类SystemDictionary用作类加载器的辅助类，记录本地函数与Java类名的对应关系

JavaCalls::call_virtual(&result,

obj,

KlassHandle(THREAD, SystemDictionary::Thread_klass()),//类型java_lang_Thread的一个句柄

vmSymbols::run_method_name(), //函数名

vmSymbols::void_method_signature(), //函数签名

THREAD);

}//由此可以看出，上面的call_virtual调用的Java端函数为 void run();而函数的定位用到obj和KlassHandle//这个obj就是传入的Java层线程对象，KlassHandle对应于类型java_lang_Thread的一个句柄//call_virtual从名字就可以看出是虚函数调用约定，后面会涉及链接时函数定位、运行时函数定位等等，有兴趣的可以查看源码

template(run_method_name, "run")

template(void_method_signature,"()V")//Pre表示该类为预加载类，本地函数Thread_klass对应Java中的类java_lang_Thread

do_klass(Thread_klass,java_lang_Thread,Pre)

到这里，之前的new JavaThread(&thread_entry, sz)函数的功能大致已经清楚了，简单的概括就是：创建了一个本地线程，并使其处于已初始化状态，线程处理函数为Java层线程对象的run方法

prepare与start

prepare与start的篇幅比较少，放在一起简述下

voidJavaThread::prepare(jobject jni_thread, ThreadPriority prio) {//保证当前线程占有锁定资源

assert(Threads_lock->owner() == Thread::current(), "must have threads lock");//下面几个操作将Java层线程对象和C++层本地线程相互关联起来//系统注释中将jni_thread说成是C++线程对象，不甚理解，如果有大大懂得可以说下~~下面按自己的理解来叙述//将jni_thread(Java层线程对象)作为本地线程的一个句柄，thread_oop则指向jni_thread，之后通过thread_oop就可调用Java层Thread类对象

Handle thread_oop(Thread::current(),

JNIHandles::resolve_non_null(jni_thread));

assert(InstanceKlass::cast(thread_oop->klass())->is_linked(),"must be initialized");//设置_threadObj(JavaThread中用于表示Java层线程对象的属性)，值为上面定义的句柄，这样就实现了C++调用Java的条件

set_threadObj(thread_oop());//向java.lang.Thread对象的接口类注册本地线程，这样就实现了Java调用C++的条件

java_lang_Thread::set_thread(thread_oop(), this);if (prio ==NoPriority) {

prio=java_lang_Thread::priority(thread_oop());

assert(prio!= NoPriority, "A valid priority should be present");

}//设置优先级

Thread::set_priority(this, prio);

prepare_ext();//将本地线程加入到线程队列

Threads::add(this);

}

用一句话来概括prepare的工作：关联Java层线程对象与C++本地线程，并将本地线程加入线程队列

到现在为止，就差一步线程就能开始工作了(还记得上面说的线程创建后默认被阻塞么)，最后的工作就是将它唤醒，当然就是start的功能了

void Thread::start(Thread*thread) {//启动线程与恢复线程情况不同，这边要排除这种情况

if (!DisableStartThread) {if (thread->is_Java_thread()) {//设置线程状态为运行

java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),

java_lang_Thread::RUNNABLE);

}

os::start_thread(thread);

}

}void os::start_thread(Thread*thread) {

MutexLockerEx ml(thread->SR_lock(), Mutex::_no_safepoint_check_flag);

OSThread* osthread = thread->osthread();//设置平台相关数据的状态为运行

osthread->set_state(RUNNABLE);//调用各平台的唤醒函数启动线程

pd_start_thread(thread);

}//Windows的比较直观，分析Windows的

void os::pd_start_thread(Thread*thread) {//唤醒本地线程使之运行，对应Linxu的notify，Solaris的thr_continue

DWORD ret = ResumeThread(thread->osthread()->thread_handle());

assert(ret!= SYS_THREAD_ERROR, "StartThread failed");

}