Kotlin挂起函数调用链中Unit返回类型的冗余分支疑问

相关Kotlin代码 #

package basic

import kotlin.concurrent.thread
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCoroutine

internal suspend fun bar() {
    suspendCoroutine {
        thread {
            Thread.sleep(1000)
            it.resume(Unit)
        }
    }
}

package basic

class SimpleCoroutine {
    private suspend fun foo() {
        bar()
    }
}

编译后的字节码 #

// ================basic/SimpleCoroutine.class =================
// class version 52.0 (52)
// access flags 0x31
public final class basic/SimpleCoroutine {


  // access flags 0x12
  // signature (Lkotlin/coroutines/Continuation<-Lkotlin/Unit;>;)Ljava/lang/Object;
  // declaration:  foo(kotlin.coroutines.Continuation<? super kotlin.Unit>)
  private final foo(Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
    // annotable parameter count: 1 (visible)
    // annotable parameter count: 1 (invisible)
   L0
    LINENUMBER 5 L0
    ALOAD 1
    INVOKESTATIC basic/BarKt.bar (Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
    DUP
    INVOKESTATIC kotlin/coroutines/intrinsics/IntrinsicsKt.getCOROUTINE_SUSPENDED ()Ljava/lang/Object;
    IF_ACMPNE L1
    ARETURN
   L1
    POP
   L2
    LINENUMBER 6 L2
    GETSTATIC kotlin/Unit.INSTANCE : Lkotlin/Unit;
    ARETURN
   L3
    LOCALVARIABLE this Lbasic/SimpleCoroutine; L0 L3 0
    LOCALVARIABLE $completion Lkotlin/coroutines/Continuation; L0 L3 1
    MAXSTACK = 3
    MAXLOCALS = 2

  // access flags 0x1
  public <init>()V
   L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this Lbasic/SimpleCoroutine; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  @Lkotlin/Metadata;(mv={1, 7, 0}, k=1, d1={"\u0000\u0014\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\u0008\u0002\n\u0002\u0010\u0002\n\u0002\u0008\u0002\u0018\u00002\u00020\u0001B\u0005\u00a2\u0006\u0002\u0010\u0002J\u0011\u0010\u0003\u001a\u00020\u0004H\u0082@\u00f8\u0001\u0000\u00a2\u0006\u0002\u0010\u0005\u0082\u0002\u0004\n\u0002\u0008\u0019\u00a8\u0006\u0006"}, d2={"Lbasic/SimpleCoroutine;", "", "()V", "foo", "", "(Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", "KotlinSuspendingFunctions"})
  // compiled from: SimpleCoroutine.kt
}


// ================META-INF/KotlinSuspendingFunctions.kotlin_module =================
"*

反编译后的Java代码 #

package basic;

import kotlin.Metadata;
import kotlin.Unit;
import kotlin.coroutines.Continuation;
import kotlin.coroutines.intrinsics.IntrinsicsKt;

public final class SimpleCoroutine {
   private final Object foo(Continuation $completion) {
      Object var10000 = BarKt.bar($completion);
      return var10000 == IntrinsicsKt.getCOROUTINE_SUSPENDED() ? var10000 : Unit.INSTANCE;
   }
}

疑问点 #

我对反编译后的这段代码逻辑感到困惑：

Object var10000 = BarKt.bar($completion);
return var10000 == IntrinsicsKt.getCOROUTINE_SUSPENDED() ? var10000 : Unit.INSTANCE;

原Kotlin的foo函数只是调用了挂起函数bar，按道理编译后直接返回BarKt.bar($completion)的结果就够了，但实际却多了一层检查：判断返回值是否为COROUTINE_SUSPENDED，再决定返回原结果还是Unit.INSTANCE。这看起来完全冗余——毕竟bar本身返回的就是Unit，不管是否挂起，最终返回的都是调用所得值。而且我发现，只要把foo的返回类型改成String，编译后就不会有这段逻辑，只有返回Unit时才会这样。

解答 #

这是Kotlin编译器针对返回Unit的挂起函数设计的特殊处理，核心原因有两点：

1. 严格保证单例返回：Unit在Kotlin中是单例对象，编译器强制非挂起路径下必须返回Unit.INSTANCE，避免出现任何意外的非标准Unit实例（虽然理论上被调用的挂起函数也会返回Unit.INSTANCE，但编译器通过这种方式做最终兜底，确保一致性）。
2. 兼容挂起与非挂起路径：挂起函数编译后的实际返回值规则是：要么返回COROUTINE_SUSPENDED标记表示函数被挂起，后续会通过Continuation恢复；要么返回实际的业务值。对于返回Unit的场景，编译器需要区分这两种情况：如果是挂起标记则直接传递，否则返回标准的Unit.INSTANCE，统一非挂起路径的返回结果。

而当返回类型为String等非Unit类型时，挂起函数的非挂起路径直接返回实际生成的字符串值即可，不需要额外统一单例的操作，因此编译器不会生成这段检查逻辑。

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