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

一. 虚拟机的入口

void AndroidRuntime::start(const char* className, const Vector<String8>& 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;
}