如何在Kotlin Multiplatform（Android/桌面端）向主线程发消息？

我在子线程运行计算任务时，需要向主线程发送消息更新UI数据。Android端我用以下代码实现：

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

val mainHandler = Handler(Looper.getMainLooper())

fun PostMessageToMainThread() {
    mainHandler.post(Runnable {
        println("Print from main thread: ${Thread.currentThread()}")
    })
}

但在搭配Compose Multiplatform的Kotlin Multiplatform Mobile（KMM）中，找不到可行方案。目前需要适配Android和桌面端代码（iOS后续处理）。尝试过协程，但无法使用Dispatcher.Main（运行时提示不可用），即使添加了依赖implementation("org.jetbrains.kotlinx:kotlinx-coroutines-swing:1.7.2")。请问有没有适用于Kotlin的跨平台方式向主线程/UI线程发送消息？

1. 正确配置协程依赖，启用Dispatchers.Main #

你遇到Dispatcher.Main不可用的问题，核心是依赖配置没有按平台区分。针对KMM项目，需在build.gradle.kts中按模块配置对应依赖：

• 通用模块（commonMain）：

sourceSets["commonMain"].dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
}

• Android模块（androidMain）：

sourceSets["androidMain"].dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
}

• 桌面模块（desktopMain）：

sourceSets["desktopMain"].dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-swing:1.7.3")
}

配置完成后，即可在通用代码中直接使用Dispatchers.Main切换主线程：

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch

fun postToMainThread() {
    // 在后台线程执行计算任务
    GlobalScope.launch(Dispatchers.Default) {
        val result = heavyCalculation()
        // 切换到主线程更新UI
        launch(Dispatchers.Main) {
            println("计算结果更新到UI: $result，线程：${Thread.currentThread()}")
            // 此处编写UI更新逻辑
        }
    }
}

fun heavyCalculation(): String {
    Thread.sleep(2000) // 模拟耗时计算
    return "计算完成"
}

2. Compose Multiplatform UI层专用：LaunchedEffect #

如果是在Compose UI代码中更新状态，推荐使用Compose自带的LaunchedEffect，它默认在主线程执行，无需手动指定调度器：

import androidx.compose.foundation.layout.Column
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.Composable
import kotlinx.coroutines.withContext
import kotlinx.coroutines.Dispatchers

@Composable
fun CalculationScreen() {
    var result by mutableStateOf("点击按钮开始计算")

    Column {
        Text(text = result)
        Button(onClick = {
            LaunchedEffect(Unit) {
                // 后台线程执行计算
                val calculationResult = withContext(Dispatchers.Default) {
                    heavyCalculation()
                }
                // 自动回到主线程更新UI状态
                result = calculationResult
            }
        }) {
            Text("开始计算")
        }
    }
}

3. 自定义跨平台调度：expect/actual机制 #

如果需要更底层的控制，可通过KMM的expect/actual为不同平台定义主线程调度逻辑：

• commonMain中定义expect函数：

expect fun runOnMainThread(block: () -> Unit)

• androidMain中实现actual函数：

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

actual fun runOnMainThread(block: () -> Unit) {
    Handler(Looper.getMainLooper()).post(block)
}

• desktopMain中实现actual函数：

import java.awt.EventQueue

actual fun runOnMainThread(block: () -> Unit) {
    EventQueue.invokeLater(block)
}

之后在通用代码中直接调用即可：

fun postMessage() {
    Thread {
        val result = heavyCalculation()
        runOnMainThread {
            println("更新UI: $result，线程：${Thread.currentThread()}")
        }
    }.start()
}

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