概述

在Android中，UI线程是一个很重要的概念。我们对UI的更新和一些系统行为，都必须在UI线程(主线程)中进行调用。

同时，我们在进行底层跨平台开发时，我们会选择NDK，在Linux系统上进行开发。在Linux中是没有主线程这一概念的。

那么，如果我们在子线程调用了一个native方法，在C++的代码中，我们想要切换到主线程调用某个方法时，该如何切换线程呢？

需求

众所周知，Toast消息，是无法在子线程调用的。如果我们在子线程中执行C++的代码，此时想调用toast方法，该如何是好呢？

                final String s = mEditTest.getText().toString();
                for (int i = 0 ; i < 3 ; i++){
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            nativeToast(s);
                        }
                    }).start();
                }

    public native void nativeToast(String text);

    public static void toast(String text){
        Toast.makeText(MyAppImpl.getAppContext(), text, Toast.LENGTH_SHORT).show();
    }

在上面的代码中，native层的nativeToast其实就是调用了Java层的toast方法。只是在调用之前，做了线程的转换，在C++层的主线程调用了toast。

实现

初始化

MainActivity.java

    static {
        System.loadLibrary("native-lib");
    }

    Button mBtnTest;
    EditText mEditTest;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
        mBtnTest = findViewById(R.id.test_btn);
        mEditTest = findViewById(R.id.test_input);
        mBtnTest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                final String s = mEditTest.getText().toString();
                for (int i = 0 ; i < 3 ; i++){
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            nativeToast(s);
                        }
                    }).start();
                }
            }
        });

    }

    public native void init();

native-lib.cpp

#include <jni.h>
#include <string>
#include "main_looper.h"
#include "jvm_helper.h"

extern "C"
{

JNIEXPORT void JNICALL
Java_com_example_oceanlong_ndkmaintest_MainActivity_init(JNIEnv *env, jobject instance) {

    JniHelper::setJVM(env);
    MainLooper::GetInstance()->init();
    LOGD("init env : %p", env);


}

JNIEXPORT void JNICALL
Java_com_example_oceanlong_ndkmaintest_MainActivity_nativeToast(JNIEnv *env, jobject instance,jstring text_) {
    const char* ctext = JniHelper::jstr2char(env, text_);
    LOGD("nativeToast  : %s", ctext);
    MainLooper::GetInstance()->send(ctext);
    env->ReleaseStringUTFChars(text_, ctext);

}


}

初始化的代码中，其实只做了两件事情：

• 缓存一个全局的JNIEnv *
• 初始化native的looper

初始化必须在主线程中执行！

MainLooper的初始化

main_looper.h

#include <android/looper.h>
#include <string>
#include "logger.h"

class MainLooper
{
public:
    static MainLooper *GetInstance();
    ~MainLooper();
    void init();
    void send(const char* msg);

private:
    static MainLooper *g_MainLooper;
    MainLooper();
    ALooper* mainlooper;
    int readpipe;
    int writepipe;
    pthread_mutex_t looper_mutex_;
    static int handle_message(int fd, int events, void *data);
};

main_looper.cpp

#include <fcntl.h>
#include "main_looper.h"
#include <stdint.h>
#include "string.h"
#include <stdlib.h>
#include <unistd.h>
#include "toast_helper.h"

#define LOOPER_MSG_LENGTH 81

MainLooper *MainLooper::g_MainLooper = NULL;


MainLooper *MainLooper::GetInstance()
{
    if (!g_MainLooper)
    {
        g_MainLooper = new MainLooper();
    }
    return g_MainLooper;
}

MainLooper::MainLooper(){
    pthread_mutex_init(&looper_mutex_, NULL);
}

MainLooper::~MainLooper() {
    if (mainlooper && readpipe != -1)
    {
        ALooper_removeFd(mainlooper, readpipe);
    }
    if (readpipe != -1)
    {
        close(readpipe);
    }
    if (writepipe != -1)
    {
        close(writepipe);
    }
    pthread_mutex_destroy(&looper_mutex_);
}

void MainLooper::init() {

    int msgpipe[2];
    pipe(msgpipe);
    readpipe = msgpipe[0];
    writepipe = msgpipe[1];

    mainlooper = ALooper_prepare(0);
    int ret = ALooper_addFd(mainlooper, readpipe, 1, ALOOPER_EVENT_INPUT, MainLooper::handle_message, NULL);
}

int MainLooper::handle_message(int fd, int events, void *data) {

    char buffer[LOOPER_MSG_LENGTH];
    memset(buffer, 0, LOOPER_MSG_LENGTH);
    read(fd, buffer, sizeof(buffer));
    LOGD("receive msg %s" , buffer);
    Toast::GetInstance()->toast(buffer);
    return 1;
}

初始化中，最关键的两句话是:

mainlooper = ALooper_prepare(0);
    int ret = ALooper_addFd(mainlooper, readpipe, 1, ALOOPER_EVENT_INPUT, MainLooper::handle_message, NULL);

looper.h

/**
 * Prepares a looper associated with the calling thread, and returns it.
 * If the thread already has a looper, it is returned.  Otherwise, a new
 * one is created, associated with the thread, and returned.
 *
 * The opts may be ALOOPER_PREPARE_ALLOW_NON_CALLBACKS or 0.
 */
ALooper* ALooper_prepare(int opts);

通过注释，我们可以看到，ALooper_prepare会返回被调用线程的looper。由于我们是在主线程对MainLooper进行的初始化，返回的也是主线程的looper。

接下来再来看一下ALooper_addFd方法：

/**
 * Adds a new file descriptor to be polled by the looper.
 * If the same file descriptor was previously added, it is replaced.
 *
 * "fd" is the file descriptor to be added.
 * "ident" is an identifier for this event, which is returned from ALooper_pollOnce().
 * The identifier must be >= 0, or ALOOPER_POLL_CALLBACK if providing a non-NULL callback.
 * "events" are the poll events to wake up on.  Typically this is ALOOPER_EVENT_INPUT.
 * "callback" is the function to call when there is an event on the file descriptor.
 * "data" is a private data pointer to supply to the callback.
 *
 * There are two main uses of this function:
 *
 * (1) If "callback" is non-NULL, then this function will be called when there is
 * data on the file descriptor.  It should execute any events it has pending,
 * appropriately reading from the file descriptor.  The 'ident' is ignored in this case.
 *
 * (2) If "callback" is NULL, the 'ident' will be returned by ALooper_pollOnce
 * when its file descriptor has data available, requiring the caller to take
 * care of processing it.
 *
 * Returns 1 if the file descriptor was added or -1 if an error occurred.
 *
 * This method can be called on any thread.
 * This method may block briefly if it needs to wake the poll.
 */
int ALooper_addFd(ALooper* looper, int fd, int ident, int events,
        ALooper_callbackFunc callback, void* data);

我们需要的用法简而言之就是，fd监测到变化时，会在looper所在的线程中，调用callback方法。

通过初始中的这样两个方法，我们就构建了一条通往主线程的通道。

发往主线程

在初始化的方法中，我们构筑了一条消息通道。接下来，我们就需要将消息发送至主线程。

void MainLooper::init() {

    int msgpipe[2];
    pipe(msgpipe);
    readpipe = msgpipe[0];
    writepipe = msgpipe[1];

    mainlooper = ALooper_prepare(0);
    int ret = ALooper_addFd(mainlooper, readpipe, 1, ALOOPER_EVENT_INPUT, MainLooper::handle_message, NULL);
}



int MainLooper::handle_message(int fd, int events, void *data) {

    char buffer[LOOPER_MSG_LENGTH];
    memset(buffer, 0, LOOPER_MSG_LENGTH);
    read(fd, buffer, sizeof(buffer));
    LOGD("receive msg %s" , buffer);
    Toast::GetInstance()->toast(buffer);
    return 1;
}


void MainLooper::send(const char *msg) {

    pthread_mutex_lock(&looper_mutex_);
    LOGD("send msg %s" , msg);
    write(writepipe, msg, strlen(msg));
    pthread_mutex_unlock(&looper_mutex_);
}

首先我们可以看到，在init方法中，我们创建了通道msgpipe。将readpipe加入了ALooper_addFd中。

所以，我们接下来只需要对writepipe进行写入，即可将消息发送至主线程。

MainActivity.java

        mBtnTest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                final String s = mEditTest.getText().toString();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        nativeToast(s);
                    }
                }).start();

            }
        });

从日志中，我们已经可以看到，receive msg input:123表示，我们已经收到了子线程的消息，并调用了handle_message方法。

调用toast

我们在这个方法中，调用toast方法：

toast_helper.cpp

#include "toast_helper.h"
#include "jvm_helper.h"
#include "logger.h"

Toast *Toast::g_Toast = NULL;

Toast *Toast::GetInstance() {
    if (!g_Toast){
        g_Toast = new Toast();
    }
    return g_Toast;
}

void Toast::toast(std::string text) {
    JNIEnv *env = JniHelper::getJVM();
    LOGD("toast env : %p", env);

    jstring jtext = JniHelper::char2jstr(text.c_str());

    jclass javaclass = JniHelper::findClass(env,"com/example/oceanlong/ndkmaintest/MainActivity");
    jmethodID jfuncId = env->GetStaticMethodID(javaclass, "toast", "(Ljava/lang/String;)V");
    env->CallStaticVoidMethod(javaclass, jfuncId, jtext);
    env->DeleteLocalRef(jtext);
}

jvm_helper.cpp:

jstring JniHelper::char2jstr(const char* pat) {
    JNIEnv *env = getJVM();
    LOGD("char2jstr %p", env);
    // 定义java String类 strClass
    jclass strClass = (env)->FindClass("java/lang/String");
    //获取String(byte[],String)的构造器,用于将本地byte[]数组转换为一个新String
    jmethodID ctorID = (env)->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
    //建立byte数组
    jbyteArray bytes = (env)->NewByteArray(strlen(pat));
    //将char* 转换为byte数组
    (env)->SetByteArrayRegion(bytes, 0, strlen(pat), (jbyte*) pat);
    // 设置String, 保存语言类型,用于byte数组转换至String时的参数
    jstring encoding = (env)->NewStringUTF("UTF-8");
    //将byte数组转换为java String,并输出
    return (jstring) (env)->NewObject(strClass, ctorID, bytes, encoding);


}

jclass JniHelper::findClass(JNIEnv *env, const char* name) {
    jclass result = nullptr;
    if (env)
    {
        //这句会出错，所以要处理错误
        result = env->FindClass(name);
        jthrowable exception = env->ExceptionOccurred();
        if (exception)
        {
            env->ExceptionClear();
            return static_cast<jclass>(env->CallObjectMethod(gClassLoader, gFindClassMethod, env->NewStringUTF(name)));
        }
    }
    return result;
}

这里是toast的实现，最终还是调用了Java层的toast方法：

MainActivity.java:

    public static void toast(String text){
        Toast.makeText(MyAppImpl.getAppContext(), text, Toast.LENGTH_SHORT).show();
    }

值得注意的坑

findClass失败

通常，我们在native层想调用Java方法时，我们首先要获取Java中的方法所在的类。我们一般的方法是：

result = env->FindClass(name);

但如果在子线程中获取时，就会出现找不到类的情况。关于这一问题，详见StackOverFlow。

简单来讲，当我们在自己创建的子线程想要通过JVM获取Class时，Android会为我们启动系统的ClassLoader而不是我们App的ClassLoader。

Google提供了几种解决方法，在这里不一一赘述。本文中采用的方法是：通过缓存一个静态的全局ClassLoader对象，当env->findClass失败时，通过缓存的ClassLoader获取需要的类。

jvm_helper.cpp:

void JniHelper::setJVM(JNIEnv *env) {
    jvmEnv = env;
    jclass randomClass = env->FindClass("com/example/oceanlong/ndkmaintest/MainActivity");
    jclass classClass = env->GetObjectClass(randomClass);
    jclass classLoaderClass = env->FindClass("java/lang/ClassLoader");
    jmethodID getClassLoaderMethod = env->GetMethodID(classClass, "getClassLoader",
                                                      "()Ljava/lang/ClassLoader;");
    jobject localClassLoader = env->CallObjectMethod(randomClass, getClassLoaderMethod);
    gClassLoader = env->NewGlobalRef(localClassLoader);
    //我在Android中用findClass不行，改成loadClass才可以找到class
    gFindClassMethod = env->GetMethodID(classLoaderClass, "findClass",
                                        "(Ljava/lang/String;)Ljava/lang/Class;");
}

jclass JniHelper::findClass(JNIEnv *env, const char* name) {
    jclass result = nullptr;
    if (env)
    {
        result = env->FindClass(name);
        jthrowable exception = env->ExceptionOccurred();
        if (exception)
        {
            env->ExceptionClear();
            return static_cast<jclass>(env->CallObjectMethod(gClassLoader, gFindClassMethod, env->NewStringUTF(name)));
        }
    }
    return result;
}

ALooper_addFd的"粘包现象"

当我并发给main_looper发送消息时，发现ALooper_addFd没有解决并发问题。

比如当我这样调用：

MainActivity.java:

        mBtnTest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                final String s = mEditTest.getText().toString();
                for (int i = 0 ; i < 5 ; i++){
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            nativeToast(s);
                        }
                    }).start();
                }
            }
        });

5个线程几乎同时发送消息。最终的日志是：

image.png

我们总共发送了5次，但handle_message只调用了两次。

但幸运的是，内容没有丢失。

这个地方，我还没有找到好的解决方式。如果读者对此有些了解，望能赐教。

目前，我能够想到的是，根据内容，在handle_message中实现“解包”。

总结

在native层，想要切到主线程调用方法。其根本是在应用启动时，就在主线程调用初始化，构建好一个消息通道。然后，通过ALooper_AddFd方法，在接收到消息时，调用handle_message方法。这样，我们只需要在子线程中，以一定的编码格式向主线程发送消息，即可完成在native中切换主线程的能力。

如有问题，欢迎指正。