Android NDK中的UI线程

概述

在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中切换主线程的能力。


如有问题,欢迎指正。

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏向治洪

Volley解析之表单提交篇

要实现表单的提交,就要知道表单提交的数据格式是怎么样,这里我从某知名网站抓了一条数据,先来分析别人提交表单的数据格式。  数据包: Connection: ...

23750
来自专栏desperate633

设计模式之适配器模式(Adapter Pattern)适配器模式的定义

适配器模式(Adapter Pattern)在生活中的应用随处可见。最常见的,我们使用的转接头就是利用了适配器模式的思想,我们可能用type-c接口的手机,但现...

11320
来自专栏醒者呆

算法族的集中管理——策略模式

策略模式是指对一系列的算法定义,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。 我们正好可以使用策略模式加...

302100
来自专栏双十二技术哥

Android AsyncLayoutInflater 源码解析

我们已经学习了 Layout 相关的方方面面,本文就来学习下一个相对新颖的知识点:AsyncLayoutInflater;说它相对新颖是因为它是Android ...

17520
来自专栏陈仁松博客

Android开发中应该避免的内存泄露

一、背景和目的: 目前许多开发人员在Android开发过程中,较少关注实现细节和内存使用,容易会造成内存泄露,导致程序OOM。 本文会通过代码向大家介绍在And...

36250
来自专栏AndroidTv

【Andorid源码解析】View.post() 到底干了啥

emmm,大伙都知道,子线程是不能进行 UI 操作的,或者很多场景下,一些操作需要延迟执行,这些都可以通过 Handler 来解决。但说实话,实在是太懒了,总感...

42460
来自专栏上善若水

022android初级篇之android的Context

Interface to global information about an application environment. This is an abs...

12620
来自专栏程序员互动联盟

【专业技术】Android数据保存之SharedPreferences

前言: 程序中处理的大部分问题都与数据有关,读取数据显示在UI上,读取的数据可以是本地的,也可以是网络的。保存用户数据到存储空间,可以是本地的数据库,文件等,也...

39270
来自专栏非著名程序员

Retrofit2.0通俗易懂的学习姿势,Retrofit2.0 + OkHttp3 + Gson + RxJava

Retrofit,因为其简单与出色的性能,也是受到很多人的青睐,但是他和以往的通信框架还是有点区别,不过放心,因为他本身还是挺简单的,所有我相信你看完这篇文章,...

34360
来自专栏技术点滴

适配器模式(Adapter)

适配器模式(Adapter) 适配器模式(Adapter)[Wrapper] 意图:将类的一个接口转换成用户希望的另一个接口,使得原本由于接口不兼容而不能一起工...

21390

扫码关注云+社区

领取腾讯云代金券