无需依赖的跨线程调用：从其他线程切换至主线程/UI线程

Great question! When building C++ mobile apps, the absence of a built-in runOnUIThread-style function is a common headache—but rolling your own is totally feasible, and it ties directly into each platform's native main-thread event loop. Let's break this down step by step, with platform-specific implementations and a cross-platform wrapper.

Core Idea #

The core concept is straightforward:

• Maintain a thread-safe task queue tied to the main thread.
• Background threads push tasks (like lambdas or function objects) into this queue.
• The main thread's event loop (iOS RunLoop, Android Looper) picks up and executes these tasks automatically.

Instead of building the queue from scratch, we leverage each platform's native mechanisms to handle queueing and execution—this is more efficient and integrates seamlessly with the OS's main thread lifecycle.

Platform-Specific Implementations #

1. Android (NDK) #

Android's main thread uses a Looper and Handler system to process messages. We'll use JNI to bridge C++ code to a Java helper class that posts tasks to the main thread's handler.

Step 1: Java Helper Class

First, create a simple Java class to handle posting to the main thread:

package com.your.app.package;

import android.os.Handler;
import android.os.Looper;

public class UIThreadDispatcher {
    private static final Handler MAIN_HANDLER = new Handler(Looper.getMainLooper());

    public static void postToUI(long taskPtr) {
        MAIN_HANDLER.post(() -> executeNativeTask(taskPtr));
    }

    private static native void executeNativeTask(long taskPtr);
}

Step 2: C++ JNI Binding

Now, implement the C++ side to pass tasks to this helper:

#include <jni.h>
#include <functional>
#include <android/log.h>

// Global references (initialize these in JNI_OnLoad)
static JavaVM* g_javaVM = nullptr;
static jclass g_uiDispatcherCls = nullptr;
static jmethodID g_postToUIMethod = nullptr;

// Initialize JNI references when the library loads
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
    g_javaVM = vm;
    JNIEnv* env = nullptr;

    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
        return JNI_ERR;
    }

    // Find the UIThreadDispatcher class and method
    jclass cls = env->FindClass("com/your/app/package/UIThreadDispatcher");
    g_uiDispatcherCls = reinterpret_cast<jclass>(env->NewGlobalRef(cls));
    g_postToUIMethod = env->GetStaticMethodID(g_uiDispatcherCls, "postToUI", "(J)V");

    return JNI_VERSION_1_6;
}

// Native callback to execute the C++ task
static void JNICALL executeNativeTask(JNIEnv* env, jclass cls, jlong taskPtr) {
    auto task = reinterpret_cast<std::function<void()>*>(taskPtr);
    try {
        (*task)();
    } catch (const std::exception& e) {
        __android_log_print(ANDROID_LOG_ERROR, "UIThread", "Task threw exception: %s", e.what());
    } catch (...) {
        __android_log_print(ANDROID_LOG_ERROR, "UIThread", "Task threw unknown exception");
    }
    delete task; // Clean up the task object
}

// Public C++ function to post tasks to UI thread
void runOnUIThread(std::function<void()> task) {
    JNIEnv* env = nullptr;
    int attachStatus = g_javaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);

    if (attachStatus == JNI_EDETACHED) {
        g_javaVM->AttachCurrentThread(&env, nullptr);
    }

    // Allocate the task on the heap (will be deleted in executeNativeTask)
    auto taskPtr = new std::function<void()>(std::move(task));
    env->CallStaticVoidMethod(g_uiDispatcherCls, g_postToUIMethod, reinterpret_cast<jlong>(taskPtr));

    if (attachStatus == JNI_EDETACHED) {
        g_javaVM->DetachCurrentThread();
    }
}

2. iOS #

iOS uses Grand Central Dispatch (GCD), and the main queue is guaranteed to execute tasks on the main thread. This implementation is far simpler:

#include <dispatch/dispatch.h>
#include <functional>
#import <Foundation/Foundation.h>

void runOnUIThread(std::function<void()> task) {
    dispatch_async(dispatch_get_main_queue(), ^{
        try {
            task();
        } catch (const std::exception& e) {
            NSLog(@"UI thread task threw exception: %s", e.what());
        } catch (...) {
            NSLog(@"UI thread task threw unknown exception");
        }
    });
}

Just link against the Foundation framework, and this will work seamlessly with iOS's main RunLoop.

Cross-Platform Wrapper #

To keep your codebase clean, wrap the platform-specific implementations in a single cross-platform function using preprocessor directives:

#include <functional>

// Forward declarations for Android
#ifdef __ANDROID__
void runOnUIThreadAndroid(std::function<void()> task);
#endif

void runOnUIThread(std::function<void()> task) {
#ifdef __ANDROID__
    runOnUIThreadAndroid(std::move(task));
#elif __APPLE__
    dispatch_async(dispatch_get_main_queue(), ^{
        try {
            task();
        } catch (const std::exception& e) {
            NSLog(@"UI thread task threw exception: %s", e.what());
        } catch (...) {
            NSLog(@"UI thread task threw unknown exception");
        }
    });
#endif
}

On Android, put the JNI-based runOnUIThreadAndroid implementation in a separate file to keep things organized.

Key Notes #

• Thread Safety: Both platform implementations are thread-safe—you can call runOnUIThread from any background thread without additional synchronization.
• Memory Management: On Android, we allocate tasks on the heap and delete them after execution to avoid leaks. On iOS, GCD handles the lifecycle of the block automatically.
• Main Thread Check: For performance, add a helper to skip posting if you're already on the main thread:
  • iOS: Use pthread_main_np() to check if current thread is main.
  • Android: Add a Java method isMainThread() that returns Looper.myLooper() == Looper.getMainLooper(), then call it via JNI in C++.
• Exception Handling: Always wrap task execution in try/catch—uncaught exceptions on the main thread will crash your app.

内容的提问来源于stack exchange，提问作者Oktaheta