android虚拟机和jni,Android虚拟机中线程的创建，VM, JNI线程的使用

一. 虚拟机的入口

void AndroidRuntime::start(const char* className, const Vector& options)

{

..........

JNIEnv* env;

if (startVm(&mJavaVM, &env) != 0) {

return;

}

onVmCreated(env);

if (startReg(env) < 0) {

ALOGE("Unable to register all android natives\n");

return;

}

}

二. 设置thread中线程创建的函数

int AndroidRuntime::startReg(JNIEnv* env)

{

/*

* This hook causes all future threads created in this process to be

* attached to the JavaVM.  (This needs to go away in favor of JNI

* Attach calls.)

*/

androidSetCreateThreadFunc((android_create_thread_fn)javaCreateThreadEtc);

}

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*));   // javaThreadShell must free

int result;

if (!threadName)

threadName = "unnamed thread";

args[0] = (void*) entryFunction;

args[1] = userData;

args[2] = (void*) strdup(threadName);   // javaThreadShell must free

result = androidCreateRawThreadEtc(AndroidRuntime::javaThreadShell, args,  这个函数是虚拟机中java线程的入口，在其中会调用用户指定的函数

threadName, threadPriority, threadStackSize, threadId);

return result;

}

int AndroidRuntime::javaThreadShell(void* args) {

void* start = ((void**)args)[0];

void* userData = ((void **)args)[1];

char* name = (char*) ((void **)args)[2];        // we own this storage

free(args);

JNIEnv* env;

int result;

/* hook us into the VM */

if (javaAttachThread(name, &env) != JNI_OK)    先把当前进程attach到java环境中

return -1;

/* start the thread running */

result = (*(android_thread_func_t)start)(userData);     执行用户指定的回调函数

/* unhook us */

javaDetachThread();   从java环境中detach当前进程

free(name);

return result;

}

static int javaAttachThread(const char* threadName, JNIEnv** pEnv)

{

JavaVMAttachArgs args;

JavaVM* vm;

jint result;

vm = AndroidRuntime::getJavaVM();  注意VM的获取方法

assert(vm != NULL);

args.version = JNI_VERSION_1_4;

args.name = (char*) threadName;

args.group = NULL;

result = vm->AttachCurrentThread(pEnv, (void*) &args);

if (result != JNI_OK)

ALOGI("NOTE: attach of thread '%s' failed\n", threadName);

return result;

}

一般JavaVM的获取方法有三种：三种方法的本质都是获取art中Runtime类中的JavaVM变量

1. vm = AndroidRuntime::getJavaVM();

2. 在JNI_OnLoad函数中，System.loadLibrary函数执行后，默认要调用这个函数；

jint JNI_OnLoad(JavaVM* vm, void* reserved) {

JNIEnv* env = NULL;

jint result = -1;

if (vm->GetEnv((void**) &env,JNI_VERSION_1_4) == JNI_OK) {

if (NULL != env && registerNativeMethods(env) == 0) {

result = JNI_VERSION_1_4;

}

}

return result;

}

3. 通过JNIEnv->GetJavaVM(JNIEnv*, JavaVM*); 函数获得，也就是在jni的环境下获得。

JNIEnv的获取方法

如果已经AttachCurrentThread了，那么可以调用AndroidRuntime::getJNIEnv方法获取当前线程的JNIEnv

JNIEnv* AndroidRuntime::getJNIEnv()

{

JNIEnv* env;

JavaVM* vm = AndroidRuntime::getJavaVM();

assert(vm != NULL);

if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)

return NULL;

return env;

}

/*

* Detach the current thread from the set visible to the VM.

*/

static int javaDetachThread(void)

{

JavaVM* vm;

jint result;

vm = AndroidRuntime::getJavaVM();

assert(vm != NULL);

result = vm->DetachCurrentThread();

if (result != JNI_OK)

ALOGE("ERROR: thread detach failed\n");

return result;

}

三. Android namespace中的thread类

在thread中，分为java线程和非java线程，如下：

status_t Thread::run(const char* name, int32_t priority, size_t stack)

{

bool res;

if (mCanCallJava) {java线程，默认为java线程，用户也可以创建非java线程要节省资源

res = createThreadEtc(_threadLoop,

this, name, priority, stack, &mThread);

} else {

res = androidCreateRawThreadEtc(_threadLoop,

this, name, priority, stack, &mThread);

}

}

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)

{

return androidCreateThreadEtc(entryFunction, userData, threadName,

threadPriority, threadStackSize, threadId) ? true : false;

}

int androidCreateThread(android_thread_func_t fn, void* arg)

{

return createThreadEtc(fn, arg);

}

int androidCreateThreadGetID(android_thread_func_t fn, void *arg, android_thread_id_t *id)

{

return createThreadEtc(fn, arg, "android:unnamed_thread",

PRIORITY_DEFAULT, 0, id);

}

static android_create_thread_fn gCreateThreadFn = androidCreateRawThreadEtc;

int androidCreateThreadEtc(android_thread_func_t entryFunction,

void *userData,

const char* threadName,

int32_t threadPriority,

size_t threadStackSize,

android_thread_id_t *threadId)

{

return gCreateThreadFn(entryFunction, userData, threadName,

threadPriority, threadStackSize, threadId);

}

默认情况下，java和非java线程没有区别，但是如果在AndroidRuntime设置了gCreateThreadFn回调函数，那就不同了。

1. 非java线程，直接调用androidCreateRawThreadEtc创建。

2. java线程的创建流程。

createThreadEtc -->androidCreateThreadEtc -->gCreateThreadFn(==AndroidRuntime::javaCreateThreadEtc)

--> androidCreateRawThreadEtc --> AndroidRuntime::javaThreadShell

在javaThreadShell函数中

int AndroidRuntime::javaThreadShell(void* args) {

/* hook us into the VM */

if (javaAttachThread(name, &env) != JNI_OK)    先把当前进程attach到java环境中

return -1;

/* start the thread running */

result = (*(android_thread_func_t)start)(userData);     执行用户指定的回调函数

javaDetachThread();   从java环境中detach当前进程

free(name);

return result;

}