【Kotlin】协程的挂起恢复源码解析

16 Oct 2023 in 博客目录

本文介绍了CPS转换，后从反编译的源码层面介绍Kotlin协程挂起和恢复的原理

首先要了解的就是CPS转换。

CPS转换

在Kotlin协程中，挂起函数的执行是通过 Continuation Passing Style (CPS)转换 来实现的。CPS转换是一种将函数式编程中的函数调用转换为可传递的 Continuation 对象的过程。这里的转换是Kotlin编译器实现的，在跨平台属性上，也保证了流程的一致性。

CPS转换调用的过程如下：

1. 当一个函数被调用时，它的参数和返回值会被封装在一个Continuation对象中。
2. 函数的执行过程中，遇到挂起操作时，会将当前的Continuation对象传递给挂起函数。
3. 挂起函数执行完毕后，会将结果封装在一个新的Continuation对象中，并将其传递给原始的Continuation对象。
4. 原始的Continuation对象会继续执行，直到所有的挂起操作都完成。

假设我们有一个简单的suspend函数，它模拟了一个异步操作:

suspend fun fetchData(): String {
    delay(1000) // 模拟耗时操作
    return "Data fetched"
}

在CPS转换后，这个函数可能会被转换为类似以下的形式：

fun fetchData(continuation: Continuation<String>) {
    delay(1000, object : Continuation<Unit> {
        override val context: CoroutineContext = continuation.context

        override fun resumeWith(result: Result<Unit>) {
            continuation.resume("Data fetched")
        }
    })
}

在这个转换后的函数中，fetchData不再直接返回结果，而是通过continuation.resume方法将结果传递给调用者。简单来说，CPS其实就是函数通过回调传递结果的一种方式。

Kotlin协程通过将异步流程拆解为一系列 挂起点 ，对含有 suspend 关键字的函数进行了 CPS转换 ，即Continuation Passing Style转换，使其能够 接收Continuation对象 作为参数，并在异步操作完成后通过调用 Continuation 的恢复方法来继续执行协程。

在编译后的字节码中，协程的状态会被转换为状态机的形式，每个挂起点对应状态机的一个状态。当协程挂起时，它的执行状态会被保存在Continuation对象中，包括局部变量上下文和执行位置。

Continuation

Continuation （续体）是一个保存协程状态的对象，它记录了协程挂起的位置以及局部变量上下文，使得协程可以在任何时候从上次挂起的地方继续执行。Continuation是一个接口，它定义了 resumeWith 方法，用于恢复协程的执行。

interface Continuation<in T> {
   val context: CoroutineContext
   fun resumeWith(result: Result<T>)//result 为返回的结果
}

1. 续体是一个较为抽象的概念，简单来说它包装了协程在挂起之后应该继续执行的代码；在编译的过程中，一个完整的协程被分割切块成一个又一个续体。
2. 在suspend函数或者 await 函数的挂起结束以后，它会调用 continuation 参数的 resumeWith 函数，来恢复执行suspend函数或者await 函数后面的代码。

CPS转换 使得协程能够在不阻塞线程的情况下执行异步操作。当协程挂起时，线程可以被释放去执行其他任务，从而提高了系统的并发性能。此外，CPS转换使得协程的挂起和恢复操作对开发者来说是透明的，开发者可以像编写同步代码一样编写异步代码。

发生 CPS 变换的函数，返回值类型变成了 Any?，这是因为这个函数在发生变换后，除了要返回它本身的返回值，还要返回一个标记CoroutineSingletons.COROUTINE_SUSPENDED,为了适配各种可能性，CPS 转换后的函数返回值类型就只能是 Any?了。

协程的启动

下面跟随启动，挂起，恢复的流程，从源码层面看看协程的核心原理。

测试代码入口：

object CoroutineExample {
    private val TAG: String = "CoroutineExample"

    fun main(){
        // 启动协程，分析入口
        GlobalScope.launch(Dispatchers.Main) {
            request()
        }
    }
    private suspend fun request(): String {
        delay(2000)
        Log.e(TAG, "request complete")
        return "result from request"
    }
}

从 CoroutineScope.launch 开始：

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy){
        LazyStandaloneCoroutine(newContext, block) 
    }else{
        StandaloneCoroutine(newContext, active = true)
    }
    coroutine.start(start, coroutine, block)
    return coroutine
}

• 参数一context：协程上下文，并不是我们平时理解的Android中的上下文，它是一种key-value数据结构。可以传入Main用于主线程调度。
• 参数二start：启动模式，此处我们没有传值则为默认值（DEFAULT），共有三种启动模式。
  • DEFAULT：默认模式，创建即启动协程，可随时取消；
  • ATOMIC：自动模式，创建即启动协程，启动前不可取消；
  • LAZY：延迟启动模式，只有当调用start方法时才能启动。
• 参数三block：协程真正执行的代码块，即上面例子中launch{}闭包内的代码块。

SuspendLambda

CoroutineScope.launch中第三个参数类型为suspend CoroutineScope.() -> Unit函数，这是怎么来的呢？我们编写代码的时候并没有这个东西，其实它由编译器生成的，我们的 block代码块 经过编译器编译后会生成一个 继承Continuation 的 类SuspendLambda 。一起看下反编译的java代码，为了关注主要逻辑方便理解，去掉了一些无关代码大概代码如下:

public final void main() {
      BuildersKt.launch$default((CoroutineScope)GlobalScope.INSTANCE, (CoroutineContext)Dispatchers.getMain(), (CoroutineStart)null, (Function2)(new Function2((Continuation)null) {
         int label;

         @Nullable
         public final Object invokeSuspend(@NotNull Object $result) {
            Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch (this.label) {
               case 0:
                  ResultKt.throwOnFailure($result);
                  CoroutineExample var10000 = CoroutineExample.this;
                  this.label = 1;
                  if (var10000.request(this) == var2) {
                     return var2;
                  }
                  break;
               case 1:
                  ResultKt.throwOnFailure($result);
                  break;
               default:
                  throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }

            return Unit.INSTANCE;
         }
        
        ···
 }

从上面反编译的java代码中好像并不能很好的看出来协程中的block代码块具体编译长什么样子，但可以确定他是编译成了 Continuation类 ，因为我们可以看到实现的 invokeSuspend 方法实际是来自BaseContinuationImpl,而BaseContinuationImpl的父类就是Continuation。这个继承关系我们后面再说。既然从反编译的java代码中看的不明显，我们直接看上面例子的字节码文件，其中可以很明显的看到这样一段代码：

final class com/imile/pda/CoroutineExample$main$1 extends kotlin/coroutines/jvm/internal/SuspendLambda implements kotlin/jvm/functions/Function2

这下恍然大悟，launch函数的第三个参数，即协程中的 block代码块 是一个编译后 继承了SuspendLambda并且实现了Function2的实例 。

SuspendLambda 本质上是一个 Continuation ，前面我们已经说过 Continuation 是一个有着恢复操作的接口，其 resume 方法可以恢复协程的执行。

SuspendLambda继承机构如下：

- Continuation: 续体，恢复协程的执行
    - BaseContinuationImpl: 实现 resumeWith(Result) 方法，控制状态机的执行，定义了 invokeSuspend 抽象方法
        - ContinuationImpl: 增加 intercepted 拦截器，实现线程调度等
            - SuspendLambda: 封装协程体代码块
                - 协程体代码块生成的子类: 实现 invokeSuspend 方法，其内实现状态机流转逻辑

每一层封装都对应添加了不同的功能，我们先忽略掉这些功能细节，着眼于我们的主线，继续跟进 launch 函数执行过程，由于第二个参数是默认值（DEFAULT），所以创建的是 StandaloneCoroutine ， 最后启动协程：

 // 启动协程
coroutine.start(start, coroutine, block)

// 启动协程
public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
    start(block, receiver, this)
}

上面 coroutine.start 的调用涉及到运算符重载，实际上会调到 CoroutineStart.invoke() 方法：

public operator fun <R, T> invoke(block: suspend R.() -> T, receiver: R, completion: Continuation<T>): Unit =
    when (this) {
        DEFAULT -> block.startCoroutineCancellable(receiver, completion)
        ATOMIC -> block.startCoroutine(receiver, completion)
        UNDISPATCHED -> block.startCoroutineUndispatched(receiver, completion)
        LAZY -> Unit // will start lazily
    }

这里启动方式为默认的 DEFAULT ，所以接着往下看：

internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(
    receiver: R, completion: Continuation<T>,
    onCancellation: ((cause: Throwable) -> Unit)? = null
) = runSafely(completion) {
    createCoroutineUnintercepted(receiver, completion)
        .intercepted()
        .resumeCancellableWith(Result.success(Unit), onCancellation)
}

整理下调用链如下：

coroutine.start(start, coroutine, block)
-> CoroutineStart.start(block, receiver, this)
-> CoroutineStart.invoke(block: suspend R.() -> T, receiver: R, completion: Continuation<T>)
->  block.startCoroutineCancellable(receiver, completion)
-> 
createCoroutineUnintercepted(receiver,completion).intercepted().resumeCancellableWith(Result.success(Unit), onCancellation)

最后走到 createCoroutineUnintercepted(receiver,completion).intercepted().resumeCancellableWith(Result.success(Unit), onCancellation) ，这里创建了一个协程，并链式调用 intercepted、resumeCancellable 方法，利用协程上下文中的 ContinuationInterceptor 对协程的执行进行拦截，intercepted 实际上调用的是 ContinuationImpl 的 intercepted 方法：

internal abstract class ContinuationImpl(
    completion: Continuation<Any?>?,
    private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {
  ...
    public fun intercepted(): Continuation<Any?> =
        intercepted
            ?:(context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
                .also { intercepted = it }
  ...
}

context[ContinuationInterceptor]?.interceptContinuation调用的是 CoroutineDispatcher 的 interceptContinuation 方法:

public final override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =
    DispatchedContinuation(this, continuation)

内部创建了一个 DispatchedContinuation 可分发的协程实例，我们继续进到看resumeCancellableWith 方法:

internal class DispatchedContinuation<in T>(
    @JvmField val dispatcher: CoroutineDispatcher,
    @JvmField val continuation: Continuation<T>
) : DispatchedTask<T>(MODE_UNINITIALIZED), CoroutineStackFrame, Continuation<T> by continuation {
  ...
  
  public fun <T> Continuation<T>.resumeCancellableWith(
    result: Result<T>,
    onCancellation: ((cause: Throwable) -> Unit)? = null
): Unit = when (this) {
  // 判断是否是DispatchedContinuation 根据我们前面的代码追踪 这里是DispatchedContinuation
    is DispatchedContinuation -> resumeCancellableWith(result, onCancellation)
    else -> resumeWith(result)
}

inline fun resumeCancellableWith(
        result: Result<T>,
        noinline onCancellation: ((cause: Throwable) -> Unit)?
    ) {
        val state = result.toState(onCancellation)
    // 判断是否需要线程调度 
   // 由于我们之前使用的是 `GlobalScope.launch(Main)` Android主线程调度器所以这里为true     
        if (dispatcher.isDispatchNeeded(context)) {
            _state = state
            resumeMode = MODE_CANCELLABLE
            dispatcher.dispatch(context, this)
        } else {
            executeUnconfined(state, MODE_CANCELLABLE) {
                if (!resumeCancelled(state)) {
                    resumeUndispatchedWith(result)
                }
            }
        }
}
  
  ...
}

最终走到 dispatcher.dispatch(context, this) 而这里的 dispatcher 就是通过工厂方法创建的 HandlerDispatcher ，dispatch() 函数第二个参数this是一个runnable这里为 DispatchedTask

HandlerDispatcher

internal class HandlerContext private constructor(
    private val handler: Handler,
    private val name: String?,
    private val invokeImmediately: Boolean
) : HandlerDispatcher(), Delay {
  ...
  
   //  最终执行这里的 dispatch方法 而handler则是android中的 MainHandler
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        if (!handler.post(block)) {
            cancelOnRejection(context, block)
        }
    }
  
  ...
}

这里借用 Android 的主线程消息队列来在主线程中执行 block Runnable而这个 Runnable 即为 DispatchedTask：

internal abstract class DispatchedTask<in T>(
    @JvmField public var resumeMode: Int
) : SchedulerTask() {
  ...
 public final override fun run() {
            ...
            withContinuationContext(continuation, delegate.countOrElement) {
                 ...
                if (job != null && !job.isActive) {
                    val cause = job.getCancellationException()
                    cancelCompletedResult(state, cause)
                    // 异常情况下
                    continuation.resumeWithStackTrace(cause)
                } else {
                    if (exception != null) {
                       // 异常情况下
                       continuation.resumeWithException(exception)
                    } else {
                      // step1：正常情况下走到这一步
                       continuation.resume(getSuccessfulResult(state))
                    }
                }
            }
           ...
   }
}

//step2：这是Continuation的扩展函数，内部调用了resumeWith()
@InlineOnly public inline fun <T> Continuation<T>.resume(value: T): Unit =
    resumeWith(Result.success(value))


//step3：最终会调用到BaseContinuationImpl的resumeWith()方法中
internal abstract class BaseContinuationImpl(...) {
    // 实现 Continuation 的 resumeWith，并且是 final 的，不可被重写
    public final override fun resumeWith(result: Result<Any?>) {
        ...
        val outcome = invokeSuspend(param)
        ...
    }
    // 由编译生成的协程相关类来实现，例如 CoroutineExample$main$1
    protected abstract fun invokeSuspend(result: Result<Any?>): Any?
}

最终调用到 continuation.resumeWith() 而 resumeWith() 中会调用 invokeSuspend，即之前编译器生成的 SuspendLambda 中的 invokeSuspend 方法：

 @Nullable
     public final Object invokeSuspend(@NotNull Object $result) {
            Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch (this.label) {
               case 0:
                  ResultKt.throwOnFailure($result);
                  CoroutineExample var10000 = CoroutineExample.this;
                  this.label = 1;
                  if (var10000.request(this) == var2) {
                     return var2;
                  }
                  break;
               case 1:
                  ResultKt.throwOnFailure($result);
                  break;
      }
 }

这段代码是一个状态机机制，每一个挂起点都是一种状态，协程恢复只是跳转到下一个状态，挂起点将执行过程分割成多个片段，利用状态机的机制保证各个片段按顺序执行。

可以看到 协程非阻塞的异步底层实现其实就是一种Callback回调 （这一点我们在介绍Continuation时有提到过），只不过有多个挂起点时就会有多个Callback回调，这里协程把多个Callback回调封装成了一个状态机。

以上就是协程的启动过程，下面我们再来看下协程中的重点挂起和恢复。

协程的挂起与恢复

协程的挂起和恢复有两个关键方法 : invokeSuspend() 和 resumeWith(Result)。我们以上一节中的例子，反编译后逆向剖析协程的挂起和恢复，先整体看下是怎样的一个过程。

suspend fun reqeust(): String {
    delay(2000)
    return "result from request"
}

反编译后的代码如下（为了方便理解，代码有删减和修改）:

//1.函数返回值由String变成Object，入参也增加了Continuation参数
public final Object reqeust(@NotNull Continuation completion) {
   //2.通过completion创建一个ContinuationImpl，并且复写了invokeSuspend()
   Object continuation;
   if (completion instanceof <undefinedtype>){
     continuation =  <undefinedtype>completion
   }else{
     continuation = new ContinuationImpl(completion) {
       Object result;
       int label; //初始值为0
        
       @Nullable
       public final Object invokeSuspend(@NotNull Object $result) {
          this.result = $result;
          this.label |= Integer.MIN_VALUE;
          return request(this);//又调用了request()方法
       }
    };
  }

   Object $result = (continuation).result;
   Object var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
   //状态机  
   //3.方法被恢复的时候又会走到这里，第一次进入case 0分支，label的值从0变为1，第二次进入就会走case 1分支
   switch(continuation.label) {
       case 0:
          ResultKt.throwOnFailure($result);
          continuation.label = 1;
          //4.delay()方法被suspend修饰，传入一个continuation回调，返回一个object结果。这个结果要么是`COROUTINE_SUSPENDED`，否则就是真实结果。
          Object delay = DelayKt.delay(2000L, continuation)
          if (delay == var4) {
            //如果是 COROUTINE_SUSPENDED 则直接return，就不会往下执行了，request()被暂停了。
            // 如果不是COROUTINE_SUSPENDED，则说明不需要挂起，就会break跳出switch语句。正常返回继续往下执行后续外部代码。
             return var4;
          }
          break;
       case 1:
          ResultKt.throwOnFailure($result);
          break;
       default:
          throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
       }
   return "result from request";
}

ResultKt.throwOnFailure($result) 是 Kotlin 协程中的一个重要方法，主要用于处理协程的异常情况。它的主要作用是： (1)检查异常：它会检查传入的 $result 对象，如果这个对象是一个异常（即协程执行过程中抛出的异常），它会立即抛出这个异常。 (2)确保正常执行：如果 $result 不是异常，则继续正常执行后续代码。

挂起过程

函数返回值由 String 变成 Object，编译器自动增加了Continuation参数，相当于帮我们添加Callback。

根据 completion 创建了一个 ContinuationImpl（如果已经创建就直接用，避免重复创建），复写了 invokeSuspend() 方法，在这个方法里面它又调用了 request() 方法，这里又调用了一次自己（是不是很神奇），并且把 continuation 传递进去。

在 switch 语句中，label 的默认初始值为 0，第一次会进入 case 0 分支，delay() 是一个挂起函数，传入上面的 continuation 参数，会有一个 Object 类型的返回值。这个结果要么是COROUTINE_SUSPENDED，否则就是真实结果。

DelayKt.delay(2000, continuation)的返回结果如果是 COROUTINE_SUSPENDED ， 则直接 return ，那么方法执行就被结束了，方法就被挂起了。

函数即便被 suspend 修饰了，但是也未必会挂起。需要里面的代码编译后有返回值为 COROUTINE_SUSPENDED 这样的标记位才可以。

协程的挂起实际是方法的挂起，本质是return。

恢复过程

因为 delay() 是 IO操作，在2000ms后就会通过传递给它的 continuation 回调回来。

回调到 ContinuationImpl 类的 resumeWith() 方法，会再次调用 invokeSuspend() 方法，进而再次调用 request() 方法。

即反编译代码中的这一段：

Object continuation;
   if (completion instanceof <undefinedtype>){
     continuation =  <undefinedtype>completion
   }else{
     continuation = new ContinuationImpl(completion) {
       Object result;
       int label; //初始值为0
        
       @Nullable
       public final Object invokeSuspend(@NotNull Object $result) {
          this.result = $result;
          this.label |= Integer.MIN_VALUE;
          return request(this);//又调用了request()方法
       }
    };
  }

程序会再次进入switch语句，由于第一次在 case 0 时把 label = 1 赋值为1，所以这次会进入 case 1 分支，检查无异常之后，再次 break ，并且返回了结果result from request。

并且 request() 的返回值作为 invokeSuspend() 的返回值返回。重新被执行的时候就代表着方法被恢复了。

看到大家一定会疑问， 步骤2中 invokeSuspend() 是如何被再次调用呢？ 我们都知道 ContinuationImpl 的父类是 BaseContinuationImpl，实际上ContinuationImpl中调用的resumeWith()是来自父类。

BaseContinuationImpl

internal abstract class BaseContinuationImpl(
    public val completion: Continuation<Any?>?
) : Continuation<Any?>, CoroutineStackFrame, Serializable {
    //这个实现是最终的，用于展开 resumeWith 递归。
    public final override fun resumeWith(result: Result<Any?>) {
        var current = this
        var param = result
        while (true) {
            with(current) {
                val completion = completion!!
                val outcome: Result<Any?> =
                    try {
                        // 1.调用 invokeSuspend()方法执行，执行协程的真正运算逻辑，拿到返回值
                        val outcome = invokeSuspend(param)
                        // 2.如果返回的还是COROUTINE_SUSPENDED则提前结束
                        if (outcome == COROUTINE_SUSPENDED) return 
                        Result.success(outcome)
                    } catch (exception: Throwable) {
                        Result.failure(exception)
                    }
                if (completion is BaseContinuationImpl) {
                    //3.如果 completion 是 BaseContinuationImpl，内部还有suspend方法，则会进入循环递归，继续执行和恢复
                    current = completion
                    param = outcome
                } else {
                    //4.否则是最顶层的completion，则会调用resumeWith恢复上一层并且return
                    // 这里实际调用的是其父类 AbstractCoroutine 的 resumeWith 方法
                    completion.resumeWith(outcome)
                    return
                }
            }
        }
    }
}

实际上任何一个挂起函数它在恢复的时候都会调到 BaseContinuationImpl 的 resumeWith() 方法里面。

一但 invokeSuspend() 方法被执行，那么 request() 又会再次被调用, invokeSuspend() 就会拿到 request() 的返回值，在 ContinuationImpl 里面根据 val outcome = invokeSuspend() 的返回值来判断我们的 request() 方法恢复了之后的操作。

如果 outcome 是 COROUTINE_SUSPENDED 常量（可能挂起函数中又返回了一个挂起函数），说明你即使被恢复了，执行了一下， if (outcome == COROUTINE_SUSPENDED) return但是立马又被挂起了，所以又 return 了。

如果本次恢复 outcome 是一个正常的结果，就会走到 completion.resumeWith(outcome)，当前被挂起的方法已经被执行完了，实际调用的是其父类 AbstractCoroutine 的 resumeWith 方法，那么协程就恢复了。

我们知道 request() 肯定是会被协程调用的(从上面反编译代码知道会传递一个Continuation completion参数)，request() 方法恢复完了就会让协程completion.resumeWith()去恢复，所以说协程的恢复是方法的恢复，本质其实是 callback（resumeWith） 回调。

一张图总结一下：

协程的核心是挂起——恢复，挂起——恢复的本质是return & callback回调

协程挂起

我们说过协程启动后会调用到上面这个 resumeWith() 方法，接着调用其 invokeSuspend() 方法：

当 invokeSuspend() 返回 COROUTINE_SUSPENDED 后，就直接 return 终止执行了，此时协程被挂起。 当 invokeSuspend() 返回非 COROUTINE_SUSPENDED 后，说明协程体执行完毕了，对于 launch 启动的协程体，传入的 completion 是 AbstractCoroutine 子类对象，最终会调用其 AbstractCoroutine.resumeWith() 方法做一些状态改变之类的收尾逻辑。至此协程便执行完毕了。

协程恢复

这里我们接着看上面第一条：协程执行到挂起函数被挂起后，当这个挂起函数执行完毕后是怎么恢复协程的，以下面挂起函数为例：

private suspend fun login() = withContext(Dispatchers.IO) {
    Thread.sleep(2000)
    return@withContext true
}

通过反编译可以看到上面挂起函数中的函数体也被编译成了 SuspendLambda 的子类，创建其实例时也需要传入 Continuation 续体参数(调用该挂起函数的协程所在续体)。贴下 withContext 的源码：

public suspend fun <T> withContext(
    context: CoroutineContext,
    block: suspend CoroutineScope.() -> T
): T {
    return suspendCoroutineUninterceptedOrReturn sc@ { uCont ->
        // 创建 new context
        val oldContext = uCont.context
        val newContext = oldContext + context
        // 检查新上下文是否作废
        newContext.ensureActive()
        // 新上下文与旧上下文相同
        if (newContext === oldContext) {
            val coroutine = ScopeCoroutine(newContext, uCont)
            return@sc coroutine.startUndispatchedOrReturn(coroutine, block)
        }
        // 新调度程序与旧调度程序相同
        if (newContext[ContinuationInterceptor] == oldContext[ContinuationInterceptor]) {
            val coroutine = UndispatchedCoroutine(newContext, uCont)
            // 上下文有变化，所以这个线程需要更新
            withCoroutineContext(newContext, null) {
                return@sc coroutine.startUndispatchedOrReturn(coroutine, block)
            }
        }
        // 使用新的调度程序
        val coroutine = DispatchedCoroutine(newContext, uCont)
        block.startCoroutineCancellable(coroutine, coroutine)
        coroutine.getResult()
    }
}

首先调用了 suspendCoroutineUninterceptedOrReturn 方法，看注释知道可以通过它来获取到当前的续体对象 uCont, 接着有几条分支调用，但最终都是会通过续体对象来创建挂起函数体对应的 SuspendLambda 对象，并执行其 invokeSuspend() 方法，在其执行完毕后调用 uCont.resume() 来恢复协程，具体逻辑大家感兴趣可以自己跟代码，与前面大同小异。

至于其他的顶层挂起函数如 await(), suspendCoroutine(), suspendCancellableCoroutine() 等，其内部也是通过 suspendCoroutineUninterceptedOrReturn() 来获取到当前的续体对象，以便在挂起函数体执行完毕后，能通过这个续体对象恢复协程执行。

Desktop平台举例分析挂起恢复（Kotlin 2.1.0）

Kotlin测试代码如下：

class MySimpleTest {

    suspend fun stephenTest(): String {
        delay(500L)
        return "result From stephenTest"
    }
}

fun callFromOutside() {
    CoroutineScope(Dispatchers.IO).launch {
        val result = MySimpleTest().stephenTest()
        println(result)
    }
}

在callFromOutside函数中，我们创建了一个协程作用域，并在其中启动了一个协程。该协程将调用stephenTest函数。而stephenTest函数是一个挂起函数，它会暂停该协程的执行，直到delay函数返回。

将这个片段反编译成java代码，删掉导包和元数据注解信息等，分析过程见注释流程号：

public final class MySimpleTest {
   public static final int $stable;

   @Nullable
   // （8）stephenTest函数本来是无参的，现在有一个Continuation类型的参数
   // 这个就是外部调用代码块封装成的实例，stephenTest方法执行完毕，需要继续往下执行的代码都在这个对象里面
   public final Object stephenTest(@NotNull Continuation $completion) {
      Continuation $continuation;
      // （9）label20: 是一个Java中的标签（label），主要用于控制流程跳转。在这里它被用来实现协程的挂起和恢复机制
      label20: {
         if ($completion instanceof <undefinedtype>) {
            $continuation = (<undefinedtype>)$completion;
            // （10）用于检查当前协程是否处于挂起状态。Integer.MIN_VALUE 是一个特殊的标志位，用于标记协程是否被挂起。
            // 它的值是10000000 00000000 00000000 00000000
            // label首次传进来是1，即00000000 00000000 00000000 00000001，和Integer.MIN_VALUE按位与的结果为0，表示需要挂起，会走到11步，基于外部传入的 completion 对象创建一个新的ContinuationImpl对象
            //=======================分割线====================
            // （16）这里的label在15步被赋值成了10000000 00000000 00000000 00000001，按位与的结果是Integer.MIN_VALUE，即条件检查结果为真（即 != 0）
            // 10000000 00000000 00000000 00000001减去Integer.MIN_VALUE，结果是1，即00000000 00000000 00000000 00000001
            // 并将label20标签跳出循环，继续往下执行stephenTest的switch状态判断
            if (($continuation.label & Integer.MIN_VALUE) != 0) {
               $continuation.label -= Integer.MIN_VALUE;
               break label20;
            }
         }

         // （11）开始创建关于stephenTest代码块的ContinuationImpl对象，用于传递给下一个suspend函数
         $continuation = new ContinuationImpl($completion) {
            // $FF: synthetic field
            Object result;
            // 初始值为0
            int label;

            @Nullable
            // （13）delay执行完，调用resumeWith，触发这个invokeSuspend方法
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               //（14）将label = 1和Integer.MIN_VALUE按位或，
               // 运算的结果是 10000000 00000000 00000000 00000001（即 -2147483647）
               this.label |= Integer.MIN_VALUE;
               //（15）重入调用stephenTest函数，这次是传入 $continuation 自己作为参数。
               return MySimpleTest.this.stephenTest((Continuation)this);
            }
         };
      }


      Object $result = $continuation.result;
      Object var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
      // (17) 本轮调用中，label值为1，检查无异常后，就会返回这个字符串
      // "result From stephenTest"
      switch ($continuation.label) {
         case 0:
            ResultKt.throwOnFailure($result);
            $continuation.label = 1;
            // （12）调用delay函数，之后就和外部调用的（3）-（7）步流程一样.
            // 传入ContinuationImpl对象，delay函数内部会判断是否需要挂起，如果需要挂起，就return掉本轮stephenTest方法的调用
            // 进入了delay内部执行，等500ms过后，调用外部传进来的ContinuationImpl对象的 resumeWith 函数回调
            // 而resumeWith方法，必然会调用到这个ContinuationImpl 对象自己的invokeSuspend方法，就跳转到第13步了
            if (DelayKt.delay(500L, $continuation) == var4) {
               return var4;
            }
            break;
         case 1:
            ResultKt.throwOnFailure($result);
            break;
         default:
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }

      return "result From stephenTest";
   }
}

// CoroutineTestKt.java
public final class CoroutineTestKt {

  
   public static final void callFromOutside() {
      // （1）分析入口，从最外部的调用开始
      BuildersKt.launch$default(CoroutineScopeKt.CoroutineScope((CoroutineContext)Dispatchers.getIO()), (CoroutineContext)null, (CoroutineStart)null, new Function2((Continuation)null) {

        // （2）函数代码块里的任务，被封装在了继承自Continuation的一个匿名内部类对象中
        // launch开始后，进入就会调用其invoke方法，并首次执行invokeSuspend方法，这时候label为0
         int label;
        // （18） 17步返回后，标志着 stephenTest 方法中 $continuation实例的invokeSuspend方法调用完毕
        // 将调用completion的invokeSuspend方法
         // （19）这时候外部的这个label值也已经为1了，就是继续往下执行了
         public final Object invokeSuspend(Object $result) {
            Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            Object var10000;
            // （3）通过label来判断当前是到了哪一个状态
            switch (this.label) {
               case 0:
                  // （4）首先检查异常
                  ResultKt.throwOnFailure($result);
                  // （5）创建一个MySimpleTest对象，并调用其stephenTest方法
                  var10000 = new MySimpleTest();
                  // （6）将这个匿名内部类自己传进去，作为参数
                  Continuation var10001 = (Continuation)this;
                  // 将label状态设置为1，等下次再次调用invokeSuspend就会走switch的1的分支
                  this.label = 1;
                  var10000 = (MySimpleTest)var10000.stephenTest(var10001);
                   // (7) 如果 stephenTest 这个方法的返回值是COROUTINE_SUSPENDED，则表示该函数已暂停，我们也返回COROUTINE_SUSPENDED给调用者
                  // 通知这个函数是挂起函数，暂时不往下执行了
                  if (var10000 == var3) {
                     return var3;
                  }
                  // 转到MySimpleTest这个类分析 ->（8）
                  break;
               case 1:
                  ResultKt.throwOnFailure($result);
                  var10000 = (MySimpleTest)$result;
                  break;
               default:
                  throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }

            // （20）挂起和恢复流程执行完毕，打印结果
            String result = (String)var10000;
            System.out.println(result);
            return Unit.INSTANCE;
         }

         public final Continuation create(Object value, Continuation $completion) {
            return (Continuation)(new <anonymous constructor>($completion));
         }

         public final Object invoke(CoroutineScope p1, Continuation p2) {
            return ((<undefinedtype>)this.create(p1, p2)).invokeSuspend(Unit.INSTANCE);
         }

         // $FF: synthetic method
         // $FF: bridge method
         public Object invoke(Object p1, Object p2) {
            return this.invoke((CoroutineScope)p1, (Continuation)p2);
         }
      }, 3, (Object)null);
   }
}

以上的分析流程就是协程的挂起恢复过程。

自动的线程切换

引例

在Android上使用协程，从本地读取一个字符串，或其他耗时逻辑，可能会写下这样的代码：

// MainViewModel.kt
suspend fun getLocalString() = withContext(Dispatchers.IO) {
        // 模拟IO操作
        Thread.sleep(2000) 
        "result from local"
    } 

// MainActivity.kt
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 开启协程
        lifecycleScope.launch {
            val result = getLocalString()
            tv_result.text = result
        }
    }
}

getLocalString() 方法，我们设置了上下文为IO，很明显直觉上会在 IO 线程中执行。

在 MainActivity 中，我们通过 lifecycleScope.launch 开启了一个协程，协程中调用 getLocalString() 方法，最初为主线程环境，是怎么从主线程切换到IO线程来运行这个方法的呢？

ContinuationInterceptor

Kotlin协程实现自动线程切换的核心在于其调度器（Dispatcher）机制，而调度器 Dispatcher 就是 ContinuationInterceptor 的实现。

ContinuationInterceptor 接口（简化）：

public interface ContinuationInterceptor : CoroutineContext.Element {
    // 拦截 Continuation 的恢复
    fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T>
}

AbstractCoroutine (例如 StandaloneCoroutine) 的 resumeWith 方法：

当协程需要恢复时，通常会调用 Continuation 的 resumeWith 方法。在协程的底层实现中，例如 AbstractCoroutine (所有 Job 的子类，如 StandaloneCoroutine 继承的基类)，其 resumeWith 方法会检查 CoroutineContext 中是否存在 ContinuationInterceptor。

// AbstractCoroutine.kt (简化)
override fun resumeWith(result: Result<T>) {
    val context = this.context
    val dispatcher = context[ContinuationInterceptor] as? ContinuationInterceptor

    if (dispatcher == null) {
        // 没有调度器，直接在当前线程执行
        dispatchResume(result)
    } else {
        // 有调度器，通过调度器来分发恢复操作
        dispatcher.dispatch(this, result) // 最终会调用 dispatchResume
    }
}

Dispatcher 的 dispatch 方法

Dispatcher 的 dispatch 方法是实际执行线程切换的地方。不同的调度器有不同的实现。

Dispatchers.Default (例如 DefaultScheduler.kt)：

Dispatchers.Default 通常使用一个共享的线程池来执行协程。

// DefaultScheduler.kt (简化)
internal object DefaultScheduler : CoroutineDispatcher(), Executor {
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        // 将 block (即恢复协程的Runnable) 提交到默认的线程池
        DefaultExecutor.enqueue(block) // DefaultExecutor 是一个线程池
    }
    // ... 其他方法
}

当 dispatch 被调用时，它会将协程的恢复逻辑封装在一个 Runnable 中，然后提交给调度器底层的 线程池 。这个 Runnable 最终会在线程池中的某个线程上执行，从而实现了线程的切换。

• Dispatchers.IO 通常会使用一个独立的、容量更大的线程池，用于处理 IO 密集型任务。其 dispatch 逻辑与 Default 类似，只是提交给不同的线程池。
• Dispatchers.Main 在 Android 上通常会与主线程的 Looper 绑定。

// AndroidMainDispatcherFactory.kt (简化)
internal class AndroidMainDispatcherFactory : MainDispatcherFactory {
    override fun createDispatcher(allFactories: List<MainDispatcherFactory>): MainCoroutineDispatcher {
        // ...
        return HandlerContext(Looper.getMainLooper(), "Main") // 包装了 Looper
    }
}

// HandlerDispatcher.kt (简化)
class HandlerContext(...) : MainCoroutineDispatcher() {
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        // 将 block 提交到 Looper 关联的 Handler
        handler.post(block)
    }
    // ...
}

上面的代码可以看出， Dispatchers.Main 会将协程的恢复操作通过 Android Handler 的 post 方法发送到主线程的消息队列，从而确保协程在主线程上恢复执行。

suspendCoroutine / suspendCancellableCoroutine

除了编译器自动生成的挂起点，我们也可以手动创建挂起点，这通常通过 suspendCoroutine 或 suspendCancellableCoroutine 函数实现。

suspend fun manualSuspendExample(): String = suspendCancellableCoroutine { continuation ->
    // 可以在这里执行一些异步操作
    Thread {
        Thread.sleep(1000)
        continuation.resume("Resumed from another thread") // 在另一个线程调用 resume
    }.start()
}

这里 continuation.resume(...) 的调用是关键。当这个 resume 被调用时，它会触发之前提到的 ContinuationInterceptor 机制，如果 CoroutineContext 中有调度器，就会通过调度器进行线程切换。

总结挂起和线程切换流程

1. 协程挂起： 当协程遇到 suspend 函数（如 delay，或自定义的挂起函数），如果该函数需要等待某个异步操作完成，它会返回 COROUTINE_SUSPENDED，并将当前的执行上下文（Continuation）保存起来。
2. 异步操作完成： 当异步操作完成时（例如网络请求返回数据，或 delay 时间到），会调用之前保存的 Continuation 对象的 resumeWith 方法。
3. 调度器介入： resumeWith 方法会检查协程的 CoroutineContext 中是否存在 ContinuationInterceptor (即 Dispatcher)。
4. 分发恢复： 如果存在调度器，resumeWith 会调用调度器的 dispatch 方法。
5. 线程切换： 调度器的 dispatch 方法会将协程的恢复逻辑（一个 Runnable）提交到其管理的线程（如线程池中的线程，或 Android 主线程）。
6. 协程恢复： Runnable 在目标线程上执行，调用实际的恢复逻辑，协程从挂起的地方继续执行。

通过这种 CPS转换 + 回调resume + 调度器拦截 的机制，Kotlin 协程得以在不阻塞线程的情况下，根据需要自动在不同的线程之间切换执行，从而实现高效的并发编程。

【Kotlin】Kotlin中的集合

08 Oct 2023 in 博客目录

本文介绍了Kotlin中集合的相关，并列举一下其使用方式

在 Kotlin 中，集合类（Collections）是非常重要的一部分，它提供了丰富且功能强大的 API 来操作数据集合。Kotlin 的集合类在很大程度上与 Java 的集合框架兼容，但 Kotlin 在其基础上进行了扩展和增强，提供了更简洁、更安全、更富表达力的 API。

一个重要的概念是，Kotlin 明确区分了只读 (read-only) 集合和可变 (mutable) 集合。

• 只读集合接口： 它们只提供读取数据的方法，不能添加、删除或修改元素。例如：List<T>、Set<T>、Map<K, V>。
• 可变集合接口： 它们在只读接口的基础上，提供了修改集合的方法。例如：MutableList<T>、MutableSet<T>、MutableMap<K, V>。

Kotlin 的集合类主要分为三大类：列表 (List)、集合 (Set) 和 映射 (Map)。这些集合类都继承自 kotlin.collections 包中的接口。

List<T>

有序集合，保持元素的插入顺序，其内部的元素可以重复。

• 只读列表：通常通过 listOf() 或 mutableListOf().toList() 创建。
• 可变列表：通常通过 mutableListOf() 创建。除了 List 的功能外，还支持添加、删除、更新元素。

除了上面两种创建方式，还可以使用 arrayListOf() 返回一个 ArrayList ，其实就是Java 的 ArrayList。

Set<T>

Set是一种无序的集合，不包含重复的元素。

• 只读集合 通常通过 setOf() 或 mutableSetOf().toSet() 创建。不保证元素的顺序，不允许有重复元素。
• 可变集合 通常通过 mutableSetOf() 创建。支持添加、删除元素。

其他的创建方式还有 hashSetOf()，返回一个 HashSet (Java 的 HashSet)。

linkedSetOf(): 返回一个 LinkedHashSet (Java 的 LinkedHashSet)。

Map<K, V>

映射 (也称为字典或关联数组) 存储键值对，其中每个键都是唯一的，并且映射到一个值。

• Map<K, V> (只读): 通常通过 mapOf() 或 mutableMapOf().toMap() 创建。用来存储键值对，键是唯一的，不保证元素的顺序 (除非使用特定实现如 LinkedHashMap)。
• MutableMap<K, V> (可变): 通常通过 mutableMapOf() 创建。支持添加、删除、更新键值对。

还可以使用 hashMapOf() 创建一个 HashMap (Java 的 HashMap)。

linkedMapOf(): 返回一个 LinkedHashMap (Java 的 LinkedHashMap)。

Kotlin 集合与 Java 集合对比

Kotlin 的集合在很大程度上是基于 Java 集合框架的，但进行了优化和扩展，提供了更安全、更简洁的 API。

1. 只读与可变分离 (最主要区别)

Kotlin: 明确区分了只读接口 (List, Set, Map) 和可变接口 (MutableList, MutableSet, MutableMap)。

这在编译时强制执行了不变性，有助于避免运行时错误和并发问题。当你只需要读取集合时，声明为只读类型可以更好地表达意图，并防止意外修改。

val readOnlyList: List<String> = listOf("A", "B", "C")
// readOnlyList.add("D") // 编译错误！

val mutableList: MutableList<String> = mutableListOf("X", "Y", "Z")
mutableList.add("W") // 可以修改

而使用 Java的集合接口 (如 List, Set, Map) 本身就包含了修改方法。虽然可以通过 Collections.unmodifiableList() 等方法创建不可修改的视图，但这只是一个运行时检查，如果你仍然持有原始的可变集合引用，它仍然可以被修改。

List<String> javaList = new ArrayList<>(Arrays.asList("A", "B", "C"));
// javaList.add("D"); // 可以直接修改

List<String> unmodifiableJavaList = Collections.unmodifiableList(javaList);
// unmodifiableJavaList.add("E"); // 运行时抛出 UnsupportedOperationException
// 但是，如果修改 javaList，unmodifiableJavaList 也会随之改变
javaList.add("F"); // unmodifiableJavaList 现在也包含 "F"

在Java中也可以直接创建不可变集合，使用 Java 9 以后引入的 List.of(), Set.of(), Map.of() 方法。

List<Integer> numbers = Arrays.asList(1, 2, 3); // 返回一个固定大小的List
// 或者
List<Integer> numbersJava9 = List.of(1, 2, 3); // 不可变List
Map<String, Integer> users = new HashMap<>();
users.put("Alice", 30);

2. 可空性支持

Kotlin 的类型系统原生支持可空性。这意味着你可以明确指定集合是否可以包含 null 元素，以及集合本身是否可以为 null。

val nullableStrings: List<String?> = listOf("A", null, "B") // 列表中可以有 null
val nonNullableList: List<String> = listOf("C", "D") // 列表中不能有 null

// 如果一个List本身可能为null
var maybeList: List<Int>? = null
maybeList = listOf(1, 2)

而 Java 在语言层面没有原生支持可空性，null 是一种常见的运行时错误源 (NullPointerException)。通常通过 @Nullable 和 @NonNull 注解来提示，但这些只是编译器或工具的提示，不能像 Kotlin 那样在编译时强制执行。

3. 集合扩展函数

Kotlin提供了大量的 扩展函数 (Extension Functions) 来操作集合，这使得集合操作变得非常简洁和富有表现力。例如：filter, map, forEach, firstOrNull, count, groupBy 等。这些函数通常链式调用，形成了非常强大的函数式编程风格。

val nums = listOf(1, 2, 3, 4, 5)
val evenSquared = nums.filter { it % 2 == 0 }.map { it * it } // 过滤偶数并平方
println(evenSquared) // 输出: [4, 16]

以下是一些常用的扩展函数：

• map：对集合中的每个元素进行转换，返回新的集合。
• filter：过滤出符合条件的元素，返回新的集合。
• flatMap：先对每个元素进行转换，然后将结果扁平化为一个新的集合。
• reduce 和 fold：对集合中的元素进行累积操作。
• forEach：遍历集合中的每个元素。
• any 和 all：判断集合中是否存在或所有元素满足某个条件。
• find 和 first：查找符合条件的元素。

示例：

val numbers = listOf(1, 2, 3, 4, 5)

val doubled = numbers.map { it * 2 } // [2, 4, 6, 8, 10]
val even = numbers.filter { it % 2 == 0 } // [2, 4]
val sum = numbers.reduce { acc, i -> acc + i } // 15

这些扩展函数让 Kotlin 的集合操作更加直观和简洁，提高了开发效率。

4. 与 Java 集合的互操作性

Kotlin 集合与 Java 集合是完全兼容的，并且可以无缝互操作。

• 在 Kotlin 代码中，你可以直接使用 Java 的 ArrayList, HashSet, HashMap 等。当你在 Kotlin 中使用这些 Java 集合时，它们会自动被视为可变集合。
• 当 Kotlin 的只读集合传递给 Java 方法时，它们会被转换为相应的 Java 接口，但仍然是“只读视图”。修改这些视图会导致运行时异常，而修改原始 Kotlin 可变集合则会反映在 Java 视图中。
• 当你从 Java 方法接收集合时，Kotlin 会将其视为可变集合，但在 Kotlin 中你可以轻松地将其转换为只读视图（例如 someJavaList.toList()）。

Kotlin 的 Sequence（序列）

Sequence 是 Kotlin 提供的一种惰性集合操作机制，类似于 Java 的 Stream API。它的主要特点是：

• 惰性计算：Sequence 中的操作不会立即执行，而是按需计算，只有在终端操作（如 toList()、forEach()）被调用时才会执行。
• 适合大数据集：由于是惰性计算，Sequence 在处理大量数据时更高效，因为它避免了创建中间集合。
• 链式操作：支持链式调用多个操作，代码更简洁。

示例：

val numbers = sequenceOf(1, 2, 3, 4, 5)

val result = numbers
    .map { it * 2 }       // 不会立即执行
    .filter { it % 3 == 0 } // 不会立即执行
    .toList()             // 触发实际计算，返回 [6]

println(result) // 输出 [6]

与 Java 的 Stream 相比，Kotlin 的 Sequence 在语法上更简洁，且与 Kotlin 的集合体系无缝集成。

【Kotlin】Kotlin协变和逆变

07 Oct 2023 in 博客目录

本文介绍了Kotlin中泛型相关的协变和逆变，和reified关键字

协变（Covariance）、逆变（Contravariance）和 reified 关键字是 Kotlin 泛型系统中比较高级和强大的特性。它们能帮助你编写更健壮、更灵活、更类型安全的泛型代码，尤其是在处理集合、高阶函数以及需要运行时类型检查的场景。

类型擦除

在深入协变和逆变之前，先简单回顾一下 Java/Kotlin 泛型的类型擦除（Type Erasure）。

在 JVM 上，泛型信息只在编译时存在，运行时会被擦除。这意味着 List<String> 和 List<Int> 在运行时都会变成 List<Object>（或 List<Any?>）。

这就导致了两个主要限制：

1. 你不能在运行时直接获取泛型参数的具体类型（比如 T::class.java）。
2. 你不能直接创建泛型数组（比如 Array<T>()）。

Kotlin 中通过 reified 关键字解决了第一个限制，在内联函数中使用，可以在编译期就确定泛型参数的实际类型。

而 协变和逆变 则解决了在使用泛型时如何安全地处理子类型关系的问题。

Java中的协变和逆变

首先回顾下Java中是怎么做的， Java 泛型中的 super 和 extends 通配符，与 Kotlin 的协变 (out) 和逆变 (in) 概念密切相关。

Java 泛型通配符：extends 和 super

在 Java 中，泛型默认是 不变的 (invariant) ，这意味着 List<String> 并不是 List<Object> 的子类型，也就是说，子类的泛型（List<String>）不属于泛型（List<Object>）的子类，反之亦然。

为了在需要时放宽这种限制，Java 引入了泛型通配符：? extends T 和 ? super T。

它们允许你在泛型类型参数上定义上限或下限，从而实现 协变（Covariance） 和 逆变（Contravariance） 的效果。

1. ? extends T (上界通配符)

简介：

• 含义: ? extends T 表示“类型是 T 或 T 的某个子类型”。
• 用途: 主要用于从泛型结构中读取数据。你可以从一个 List<? extends T> 中获取 T 类型的对象，但不能安全地向其中添加任何 T 类型的对象（除了 null）。
• 角色: 充当生产者 (Producer)。如果你要从集合中取东西，那么这个集合应该使用 extends。
• 与 Kotlin 的 out 对应: ? extends T 在 Java 中实现了协变。

如果 Sub 是 Super 的子类型，那么 Generic<Sub> 也是 Generic<Super> 的子类型，就称为协变。即 子类型关系在泛型中得以保留。

List<Button> buttons = new ArrayList<Button>();
List<? extends TextView> textViews = buttons; // 合法
TextView textView = textViews.get(0); // 合法

// 下面的描述都是成立的
List<? extends TextView> textViews = new ArrayList<TextView>(); // 👈 本身
List<? extends TextView> textViews = new ArrayList<Button>(); // 👈 直接子类
List<? extends TextView> textViews = new ArrayList<RadioButton>(); // 👈 间接子类

前面说到 List<? extends TextView> 的泛型类型是个未知类型 ?，编译器也不确定它是啥类型，只是有个限制条件。

由于它满足 ? extends TextView 的限制条件，所以 get 出来的对象，肯定是 TextView 的子类型，根据多态的特性，能够赋值给 TextView，啰嗦一句，赋值给 View 也是没问题的。

List<? extends TextView> textViews = new ArrayList<Button>();
TextView textView = textViews.get(0); // 合法
View view = textViews.get(0); // 合法

// 下面的添加元素的代码是不合法的
textViews.add(new Button()); // 不合法
textViews.add(new TextView()); // 不合法

到了 add 操作的时候，我们可以这么理解：

• List<? extends TextView> 由于类型未知，它可能是 List<Button>，也可能是 List<TextView> 。
• 对于前者，显然我们要添加 TextView 是不可以的。
• 实际情况是编译器无法确定到底属于哪一种，无法继续执行下去，就报错了。

2. ? super T (下界通配符)

简介：

• 含义: ? super T 表示“类型是 T 或 T 的某个父类型”。
• 用途: 主要用于向泛型结构中写入数据。你可以向一个 List<? super T> 中添加 T 类型的对象或其任何子类型，但从其中获取元素时，你只能确定它们是 Object 类型。
• 角色: 充当消费者 (Consumer)。如果你要向集合中放东西，那么这个集合应该使用 super。
• 与 Kotlin 的 in 对应: ? super T 在 Java 中实现了逆变。

如果 Sub 是 Super 的子类型，那么 Generic<Super> 是 Generic<Sub> 的子类型，就称为逆变。即 子类型关系在泛型中被反转。

先看一下它的写法：

List<? super Button> buttons = new ArrayList<TextView>();

这个 ? super 叫做「下界通配符」，可以使 Java 泛型具有「逆变性 Contravariance」。

与上界通配符对应，这里 super 限制了通配符 ? 的子类型，所以称之为下界。

它也有两层意思：

• 通配符 ? 表示 List 的泛型类型是一个未知类型。
• super 限制了这个未知类型的下界，也就是泛型类型必须满足这个 super 的限制条件。
  • super 我们在类的方法里面经常用到，这里的范围不仅包括 Button 的直接和间接父类，也包括下界 Button 本身。
  • super 同样支持 interface 。

上面的例子中， TextView 是 Button 的父类型 ，也就能够满足 super 的限制条件，就可以成功赋值了。

其他示例：

List<? super Button> buttons = new ArrayList<Button>(); // 👈 本身
List<? super Button> buttons = new ArrayList<TextView>(); // 👈 直接父类
List<? super Button> buttons = new ArrayList<Object>(); // 👈 间接父类

在涉及到拿取和添加元素的情景时，编译器可以确定你 添加进去的元素是 Button 的父类 ，Button 对象一定是这个未知类型的子类型，根据多态的特性，这里通过 add 添加 Button 对象是合法的。

但你不能通过 get 方法拿到这个元素，因为编译器只知道它是个未知类型，是 Button 的父类，但是你拿什么类型的对象来接收呢（除非Object）。

使用下界通配符 ? super 的泛型 List，只能读取到 Object 对象，一般没有什么实际的使用场景，通常也只拿它来添加数据，也就是消费已有的 List<? super Button>，往里面添加 Button，因此这种泛型类型声明称之为「消费者 Consumer」。

Kotlin中的 协变：out 关键字

以上为java中实现逆变和协变的方法，在Kotlin中的写法如何呢？在 Kotlin 中，当泛型类型参数被标记为 out 时，它表示该类型参数只能被生产（作为返回值输出），而不能被消费（作为参数输入）。（这个很形象，一个out，一个in）

• 如果一个类 Producer<T> 的类型参数 T 被声明为 out：
  • Producer<T> 的成员函数只能返回 T 类型的值。
  • Producer<T> 的成员函数不能接受 T 类型的值作为参数（因为你无法保证传入的 T 是特定子类型）。
• 这意味着，如果 A 是 B 的子类型，那么 Producer<A> 就是 Producer<B> 的子类型。

// 声明一个协变接口：只能生产 T 类型
interface Producer<out T> {
    fun produce(): T // T 只能作为返回类型（生产）
    // fun consume(item: T) // 编译错误！T 不能作为参数类型（消费）
}

open class Animal
class Cat : Animal()
class Dog : Animal()

// 实现生产 Animal 的生产者
class AnimalProducer : Producer<Animal> {
    override fun produce(): Animal = Cat() // 可以生产 Cat (是 Animal 的子类)
}

// 实现生产 Cat 的生产者
class CatProducer : Producer<Cat> {
    override fun produce(): Cat = Cat()
}

fun main() {
    val animalProducer: Producer<Animal> = CatProducer() // 协变：CatProducer 可以被赋值给 Producer<Animal>
    val animal: Animal = animalProducer.produce() // produce() 返回 Animal
    println("Produced: $animal")
    // AnimalProducer producerCat = CatProducer() // 这样也是可以的
}

何时使用 out？ 当你的泛型类型只作为输出（例如，函数返回值、只读属性）时，使用 out。这通常用于表示“提供者”或“源头”。Kotlin 的 List<out E> 就是一个很好的例子：你只能从 List 中获取元素，不能添加特定类型的元素（尽管 MutableList<E> 不会使用 out，因为它可以添加）。

Kotlin中的逆变：in 关键字

在 Kotlin 中，当泛型类型参数被标记为 in 时，它表示该类型参数只能被消费（作为参数输入），而不能被生产（作为返回值输出）。

• 如果一个类 Consumer<T> 的类型参数 T 被声明为 in：
  • Consumer<T> 的成员函数只能接受 T 类型的值作为参数。
  • Consumer<T> 的成员函数不能返回 T 类型的值（因为你无法保证返回的 T 是特定父类型）。
• 这意味着，如果 A 是 B 的子类型，那么 Consumer<B> 就是 Consumer<A> 的子类型。

// 声明一个逆变接口：只能消费 T 类型
interface Consumer<in T> {
    fun consume(item: T) // T 只能作为参数类型（消费）
    // fun produce(): T // 编译错误！T 不能作为返回类型（生产）
}

open class Animal
class Cat : Animal()
class Dog : Animal()

// 实现消费 Animal 的消费者
class AnimalConsumer : Consumer<Animal> {
    override fun consume(item: Animal) {
        println("Consuming an animal: $item")
    }
}

// 实现消费 Cat 的消费者
class CatConsumer : Consumer<Cat> {
    override fun consume(item: Cat) {
        println("Consuming a cat: $item")
    }
}

fun main() {
    val catConsumer: Consumer<Cat> = AnimalConsumer() // 逆变：AnimalConsumer 可以被赋值给 Consumer<Cat>
    catConsumer.consume(Cat()) // 可以消费 Cat
    // catConsumer.consume(Animal()) // 编译错误！因为 catConsumer 期望的是 Cat 或其子类型
}

何时使用 in？ 当你的泛型类型只作为输入（例如，函数参数、只写属性）时，使用 in。这通常用于表示“消费者”或“汇集点”。Kotlin 的 Comparator<in T> 就是一个很好的例子：它可以通过比较任何 T 或其超类型来比较 T。

reified 关键字

最后介绍一下Kotlin中的reifeid关键字，reified 关键字用于 内联函数 (inline functions) 的泛型类型参数。它解决了 Java/Kotlin 泛型类型擦除的问题，允许你 在运行时访问泛型类型信息 。

由于类型擦除，你不能像下面的示例一样写，直接在运行时检查一个泛型类型：

// 这是不允许的，因为 T 在运行时是 Any/Object
fun <T> checkIfString(value: Any) {
    // if (value is T) { // 编译错误！Cannot check for instance of erased type: T
    //    println("It's a T")
    // }
}

// 也不允许获取 T 的 Class 对象
// fun <T> createInstance(): T {
//    return T::class.java.newInstance() // 编译错误！Cannot use T as reified type parameter
// }

reified 的作用

当一个泛型类型参数被标记为 reified 时，Kotlin 编译器会在编译时将该类型参数的具体类型信息内联到调用点。这意味着在运行时，该泛型类型不再被擦除，你可以像访问普通类型一样访问它。

• reified 只能用于 inline 函数的类型参数。因为内联函数会将其代码复制到调用点，所以编译器有机会“知道”实际的类型参数。
• 有了 reified，你就可以在函数体内使用 is 运算符、as 运算符以及 T::class.java。

// 使用 reified 关键字检查类型
inline fun <reified T> T.checkClassType() {
    // 类型 T 内联解析
    when (this) {
        is Int -> {
            // 检查 this 是否为 Int 类型
            println("this is a Int: $this")
        }

        is String -> {
            // 检查 this 是否为 String 类型
            println("this is a String: $this")
        }

        else -> {
            // 检查 this 是否为其他类型
            println("this is a other type: $this")
        }
    }
}

/**
this is a Int: 2
this is a String: Kotlin
this is a other type: 2.0
*/

// 使用reified创建类实例
class Fish {
    fun swim() {
        println("Fish is swimming")
    }
}

inline fun <reified T> createInstance(){
    try {
        // 1. 获取 ClassLoader
        val classLoader = Thread.currentThread().contextClassLoader
        // 2. 加载类
        val className = T::class.java.name
        val loadedClass = classLoader?.loadClass(className)
        // 3. 创建实例
        val instance = loadedClass?.getDeclaredConstructor()?.newInstance()

        instance?.let {
            // 4. 调用方法
            val method = loadedClass.getDeclaredMethod("swim")
            method.invoke(instance)
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

/**
Fish is swimming
*/

reified 在Android中的应用场景

1. JSON 解析库: 许多 JSON 解析库（如 Gson, Moshi, kotlinx.serialization）的扩展函数使用 reified 来简化类型指定，无需传递 Class<T> 参数。

   // 假设你有这样一个扩展函数
   inline fun <reified T> String.fromJson(): T {
       // 内部使用 T::class.java 进行类型反序列化
       // ...
       throw NotImplementedError()
   }
   
   // val user = jsonString.fromJson<User>() // 比 jsonString.fromJson(User::class.java) 更简洁
   

2. 启动 Activity: 简化 Activity 的启动，无需在 Intent 中指定 Class。

   inline fun <reified T : Activity> Context.startActivity() {
       startActivity(Intent(this, T::class.java))
   }
   
   // 使用：context.startActivity<DetailActivity>()
   

3. 获取 Service: 简化获取系统服务。安卓热门网络请求库Retrofit也是使用了这个方法来示例化定义好的api服务的。

   inline fun <reified T> Context.getSystemService(): T? {
       return getSystemService(T::class.java) as? T
   }
   
   // val locationManager = context.getSystemService<LocationManager>()
   

4. 查找视图: 在一些旧的视图查找框架中，可以使用 reified 简化类型转换。

注意事项:

• reified 只能用于 inline 函数。
• 由于内联的特性，过度使用 reified 可能会导致生成的字节码文件变大。应合理使用。

【Kotlin】Kotlin专项总结

07 Oct 2023 in 博客目录

本文介绍了Kotlin语言对比java的优点，以及使用中的一些重难点

本文基于公司内部我写的一篇关于Kotlin的推广文，呼吁在日常开发中更多地使用Kotlin，而不是Java。

Kotlin在Android平台上，最吸引人的一点，就是它在简洁优雅的同时，完全兼容Java，可以与Java的方法，类等无缝地进行互调用。第一章节，先介绍一下对比Java的写法优化。

第二节是Kotlin的一些高级特性，像协程，密封类，内联，noinline等。

对比Java有哪些写法优化

lambda

Java 中也有lambda，在Kotlin中的lambda表达式，是一种更简洁的函数表示方式，它可以代替匿名内部类的使用。lambda表达式的语法如下：

// 无参lambda表达式
val printName = { println("Kotlin") }

// 带参lambda表达式
val sum = { a: Int, b: Int -> a + b }

在这个例子中，printName 是一个无参的lambda表达式，它的函数体只有一行代码。sum 是一个带参的lambda表达式，它接收两个 Int 类型的参数，并返回它们的和。

与匿名内部类相比，lambda表达式的代码更简洁，可读性更好。

其他的用法，例如声明Runnable和线程的时候，可以直接使用lambda写成下面这样：

val runnable = Runnable {
    println("Kotlin")
}

val thread = Thread(runnable)
thread.start()

fun startThread() {
  Thread {
    println("Thread name is ${Thread.currentThread().name}")
  }.start()
}

实现原理

Kotlin和Java的Lambda语法实现均是基于函数式接口（内部只有一个方法的接口）。

函数式接口​​ 是指​​只包含一个抽象方法​​（Single Abstract Method，简称 SAM）​，但是可以有多个默认方法或静态方法的接口。这样的接口可以被 Lambda 表达式 或 方法引用 所实现（或替代）。

Java中没有原生的接口类，而Kotlin则原生定义了很多接口类，归类叫做FunctionN，其中N代表参数的数量，最多支持带22个参数。

public interface Function0<out R> : Function<R> {
    /** Invokes the function. */
    public operator fun invoke(): R
}
/** A function that takes 1 argument. */
public interface Function1<in P1, out R> : Function<R> {
    /** Invokes the function with the specified argument. */
    public operator fun invoke(p1: P1): R
}

...

同时Kotlin还支持带接收者的lambda，可以说是和函数式编程和扩展函数的结合，可以在lambda的域中访问该对象的变量和方法。

在定义使用Lambda时，会默认将lambda参数继承实现 FunctionN 接口，传递到方法中，在方法中调用 invoke方法。

// HighOrderFunction.kt 文件的顶层函数
fun printSomething(print: () -> Unit) {
    print()
}

反编译之后：

public final class HighOrderFunctionKt {
   public static final void printSomething(@NotNull Function0 print) {
      Intrinsics.checkNotNullParameter(print, "print");
      print.invoke();
   }
}

循环中使用lambda的坑

上面的分析可以得知，每一个lambda的调用，不像一般的方法使用指针来调用，而是都会创建出一个匿名内部类，如果在循环中使用的话，会导致性能问题。

这时候一般会在循环中使用inline关键字修饰的内联函数，或者使用crossinline关键字修饰的内联函数，这样在循环中使用lambda时，就不会创建出多个匿名内部类了。

class LambdaTest {
    inline fun testInline(lambdaParams:()->Unit) {
        lambdaParams()
    }
}

fun main() {
    val lambdaTest = LambdaTest()
    for (i in 0..100000) {
        lambdaTest.testInline {
            println("hello world")
        }
    }
}

反编译之后：

public final class LambdaTest {
   public final void testInline(@NotNull Function0 lambdaParams) {
      Intrinsics.checkNotNullParameter(lambdaParams, "lambdaParams");
      lambdaParams.invoke();
   }
}

public final class MainKt {
   public static final void main() {
      LambdaTest lambdaTest = new LambdaTest();
      int $i$iv = 0;
      int var3;
      for(var3 = 100000; $i$iv <= var3; ++$i$iv) {
         System.out.println("hello world");
      }
   }
}

默认函数参数

Kotlin中函数的参数可以有默认值，这样在调用函数时如果没有为该参数传入值，就会使用默认值。

fun printName(name: String = "Unknown") {
    println("My name is $name")
}

printName() // 输出: My name is Unknown
printName("Kotlin") // 输出: My name is Kotlin

自动类型推断

Kotlin 编译器会根据上下文推断变量的类型，这意味着你通常不需要显式地声明变量的类型。

val name = "Kotlin" // 编译器推断 name 为 String 类型

除了变量，函数也可以自动推断参数类型和返回值类型。

fun sum(a: Int, b: Int): Int {
    return a + b
}

在这个例子中，sum 函数的参数 a 和 b 类型都是 Int，返回值类型也是 Int。Kotlin 编译器可以根据函数体推断出这一点，所以你可以省略函数声明中的类型。

fun sum(a: Int, b: Int) = a + b

if else直接返回结果

Java中，对一个变量进行分支判断赋值，往往写成下面这样：

String name;
if (isMale) {
  name = "Mike";
} else {
  name = "Marry";
}

而Kotlin中，使用if else表达式，在一行代码里完成对变量的赋值：

val name = if (isMale) "Mike" else "Marry"

实际上反编译成Java之后，可以看出这段代码仍然使用的是上面Java的那种写法，或者一个三元判断运算符来实现，不过在面向程序员时的写法更优雅了。

when 关键字

Kotlin 中的 when 关键字，它是一个非常强大和灵活的控制流结构，是 Java 中 switch 语句的增强版。 when 在处理多种条件分支时，比传统的 if-else if-else 链更加简洁和表达性强。

when 可以作为一个表达式（有返回值）或一个语句（没有返回值）使用，这使得它比 Java 的 switch 更具通用性。它的基本作用是根据某个值或条件，执行对应的代码块。

1. when 作为表达式

当 when 作为表达式使用时，它会评估每个分支的条件，然后返回第一个满足条件的分支的结果。所有可能的分支都必须被覆盖（或者有一个 else 分支），以确保 when 总是能返回一个值。

fun getColorName(colorCode: Int): String {
    return when (colorCode) {
        0xFF0000 -> "Red"
        0x00FF00 -> "Green"
        0x0000FF -> "Blue"
        else -> "Unknown Color" // else 分支是必需的，因为 when 是表达式
    }
}

val color1 = getColorName(0xFF0000) // color1 = "Red"
val color2 = getColorName(0x00FFFF) // color2 = "Unknown Color"
println(color1)
println(color2)

2. when 作为语句

当 when 作为语句使用时，它会执行第一个满足条件的分支的代码，但不会返回任何值。在这种情况下，else 分支是可选的，除非编译器无法确定所有可能的情况都已覆盖（例如处理 sealed 类时）。

fun printColorInfo(colorCode: Int) {
    when (colorCode) {
        0xFF0000 -> println("This is the color Red.")
        0x00FF00 -> println("This is the color Green.")
        0x0000FF -> println("This is the color Blue.")
        // else 分支在这里是可选的
    }
}

printColorInfo(0x00FF00) // 输出: This is the color Green.

匹配多个值 (逗号分隔)

如果多个分支需要执行相同的操作，可以将它们用逗号 , 分隔开。

val character = 'a'
when (character) {
    'a', 'e', 'i', 'o', 'u' -> println("It's a vowel.")
    in 'b'..'z' -> println("It's a consonant.") // 后面会介绍范围匹配
    else -> println("Not a letter.")
}

范围 (Ranges) 匹配 (in 或 !in)

可以使用 in 运算符检查值是否在一个范围内，或使用 !in 检查是否不在一个范围内。

val age = 25
val category = when (age) {
    in 0..12 -> "Child"
    in 13..19 -> "Teenager"
    in 20..64 -> "Adult"
    else -> "Senior"
}
println("Age $age is a $category.") // 输出: Age 25 is a Adult.

类型检查 (is 或 !is)

可以使用 is 运算符检查一个值是否是某种类型，或使用 !is 检查是否不是某种类型。这在处理多态性或检查未知对象类型时非常有用。

fun describe(obj: Any) {
    when (obj) {
        1 -> println("One")
        "Hello" -> println("Greeting")
        is Long -> println("Long type value: $obj") // obj 会被智能转换为 Long
        !is String -> println("Not a String")
        else -> println("Unknown type or value")
    }
}

describe(1)      // 输出: One
describe("Hello") // 输出: Greeting
describe(1000L)  // 输出: Long type value: 1000
describe(2.5)    // 输出: Not a String
describe("Kotlin") // 输出: Unknown type or value

when 无参数

when 也可以在没有参数的情况下使用。在这种情况下，它会评估每个分支的布尔表达式，然后执行第一个为 true 的分支。这类似于一个更可读的 if-else if-else 链。

val temperature = 28
val isRaining = true

when {
    temperature > 30 -> println("It's very hot!")
    temperature > 20 && !isRaining -> println("It's warm and sunny.")
    isRaining -> println("It's raining.")
    else -> println("Normal weather.")
}
// 输出: It's warm and sunny.

处理密封类 (Sealed Classes) 或枚举 (Enums)

when 在处理密封类 (Sealed Classes) 和枚举 (Enums) 时特别有用。如果 when 表达式覆盖了密封类或枚举的所有可能子类/值，那么不需要 else 分支，因为编译器可以验证所有情况都已处理。

// 定义一个密封类
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result() // 单例对象
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        is Result.Error -> println("Error: ${result.message}")
        Result.Loading -> println("Loading data...") // 注意这里直接引用单例对象
    }
}

handleResult(Result.Success("Data fetched!")) // 输出: Success: Data fetched!
handleResult(Result.Error("Network failed.")) // 输出: Error: Network failed.
handleResult(Result.Loading)                 // 输出: Loading data...

这种用法在 Android 中处理网络请求状态、UI 事件或不同的视图状态时非常常见和强大，因为它提供了编译时安全，确保你不会遗漏任何一种情况。

范围限制coerceIn

coerceIn 是一个扩展函数，作用是将接收者对象的值“强制”限定在一个指定的范围内。如果原始值在这个范围内，就返回原始值；如果原始值小于范围的最小值，就返回最小值；如果原始值大于范围的最大值，就返回最大值。

这个函数通常用于任何实现了 Comparable 接口的类型，比如数字（Int, Double, Float, Long 等）、字符串，甚至自定义的可比较对象。

fun main() {
    // 1. 限定整数范围
    val num1 = 5.coerceIn(1, 10)  // 5 在 [1, 10] 之间，返回 5
    val num2 = 0.coerceIn(1, 10)  // 0 小于 1，返回 1
    val num3 = 12.coerceIn(1, 10) // 12 大于 10，返回 10
    println("Int coercing: $num1, $num2, $num3") // 输出: Int coercing: 5, 1, 10

    // 2. 限定浮点数范围
    val float1 = 3.5f.coerceIn(1.0f, 5.0f) // 3.5f 在 [1.0f, 5.0f] 之间，返回 3.5f
    val float2 = 0.5f.coerceIn(1.0f, 5.0f) // 0.5f 小于 1.0f，返回 1.0f
    println("Float coercing: $float1, $float2") // 输出: Float coercing: 3.5, 1.0

    // 3. 限定字符串范围 (按字典顺序)
    val str1 = "banana".coerceIn("apple", "orange") // banana 在 apple 和 orange 之间，返回 banana
    val str2 = "cat".coerceIn("apple", "banana")    // cat 大于 banana，返回 banana
    val str3 = "zoo".coerceIn("apple", "orange")    // zoo 大于 orange，返回 orange
    println("String coercing: $str1, $str2, $str3") // 输出: String coercing: banana, banana, orange

    // 4. 处理负数或范围倒置（注意：如果 min > max，会抛出 IllegalArgumentException）
    // val invalidRange = 5.coerceIn(10, 1) // 这会抛出 IllegalArgumentException
}

Android 应用 coerceIn

在 Android 开发中，coerceIn 在很多场景下都能派上用场：

1. UI 元素的滑动或拖拽限制: 当用户拖拽一个视图时，你可能需要限制其位置在屏幕的某个特定区域内。

   val newX = event.rawX.coerceIn(0f, screenWidth - viewWidth)
   view.x = newX
   

2. 进度条或评分: 确保进度值或评分值始终在有效的 0 到 100（或 1 到 5）范围内。

   val progress = (rawProgressValue * 100).toInt().coerceIn(0, 100)
   progressBar.progress = progress
   

3. 动画插值: 限制动画的起始或结束值，防止超出预期。
4. 游戏开发: 限制玩家角色的移动范围，或限制敌人 AI 的行为范围。
5. 数据验证: 在处理用户输入或从外部来源获取数据时，确保数值符合预期的业务规则。

   val quantity = inputString.toIntOrNull()?.coerceIn(1, 99) ?: 1 // 如果解析失败或超出范围，默认为1
   

6. 数值计算: 避免计算结果超出合理的物理或逻辑限制。

coerceAtLeast 和 coerceAtMost

Kotlin 还提供了两个更细粒度的“强制”函数：

• value.coerceAtLeast(minimumValue): 返回 value 和 minimumValue 中较大的那个。它只设定下限。

  val score = 80.coerceAtLeast(90) // 返回 90 (因为它不能低于 90)
  val score2 = 95.coerceAtLeast(90) // 返回 95
  

• value.coerceAtMost(maximumValue): 返回 value 和 maximumValue 中较小的那个。它只设定上限。

  val speed = 120.coerceAtMost(100) // 返回 100 (因为它不能高于 100)
  val speed2 = 90.coerceAtMost(100) // 返回 90
  

这两个函数在你只需要限制单边范围（只有上限或只有下限）时非常方便。

空安全

这一点是Kotlin的核心设计，也是它的一大卖点。Kotlin的空安全设计对于开发者来说是一种福利，它可以在编译阶段就发现很多空指针异常，而不是在运行时才发现。

作为一名 Android 开发者，你肯定深知 NullPointerException (NPE) 是 Java 开发中常见且令人头疼的问题。Kotlin 的设计目标之一就是消除这种运行时错误，通过在编译时强制进行空安全检查来解决这个问题。

1. 可空类型与非空类型

• 非空类型 (Non-nullable Types): 默认情况下，Kotlin 中的所有类型都是非空的。这意味着你声明的变量如果没有明确标记为可空，就不能被赋值为 null。如果你尝试将 null 赋值给非空类型的变量，编译器会报错。

  var name: String = "Kotlin"
  // name = null // 编译错误：Null can not be a value of a non-null type String
  

• 可空类型 (Nullable Types): 如果你确实需要一个变量可以持有 null 值，你必须在其类型后面加上问号 ? 来明确声明它为可空类型。

  var name: String? = "Kotlin"
  name = null // 编译通过
  

  这样，编译器就知道 name 这个变量可能为 null，并在你访问它的成员时强制你进行空检查。

Java里的空指针（NPE）报错，Kotlin 中也有类似的，就是使用 lateinit var 的不可空变量时，需要注意初始化和使用时机不对的情况下，有可能会报 UnInitializedPropertyAccessException 异常。所以在一些不确定是否在初始化完毕之后调用的方法里，使用变量时，最好加一层初始化判断。

// 延迟初始化变量
lateinit var str: String

// 使用时进行初始化判断
if(::str.isInitialized) {
    print(str.length)
}

2. 安全调用操作符 (?.)

当处理可空类型的变量时，你不能直接访问它的成员（例如调用方法或访问属性）。你需要使用安全调用操作符 ?.。

• 如果 ?. 左边的表达式不为 null，则会正常执行右边的操作。
• 如果 ?. 左边的表达式为 null，则整个表达式的结果为 null，并且不会执行右边的操作，从而避免了 NPE。

  val name: String? = null
  val length: Int? = name?.length // 如果 name 为 null，则 length 也为 null
  println(length) // 输出: null
  
  val name2: String? = "Hello"
  val length2: Int? = name2?.length
  println(length2) // 输出: 5
  

3. Elvis 操作符 (?:)

Elvis 操作符 ?: 提供了一种简洁的方式来处理可空值，当左边的表达式为 null 时，提供一个默认值。

• 如果 ?: 左边的表达式不为 null，则返回左边的值。
• 如果 ?: 左边的表达式为 null，则返回 ?: 右边的默认值。

  val name: String? = null
  val length: Int = name?.length ?: 0 // 如果 name?.length 为 null，则 length 为 0
  println(length) // 输出: 0
  
  val name2: String? = "World"
  val length2: Int = name2?.length ?: 0
  println(length2) // 输出: 5
  

4. 非空断言操作符 (!!)

非空断言操作符 !! 允许你将任何可空类型的值转换为非空类型。然而，如果 !! 左边的表达式为 null，它会抛出一个 NullPointerException。

val name: String? = null
// val length: Int = name!!.length // 运行时会抛出 NullPointerException

这个操作符应该慎用，只有当你非常确定某个值在特定时刻不可能为 null 时才使用。它的作用是告诉编译器“我保证这里不会是 null，如果错了，就让它崩溃吧”。

5. let 函数

let 是一个作用域函数，常用于对非空对象执行操作。如果接收者对象不为 null，let 函数会执行给定的 lambda 表达式，并将接收者作为 it 参数传入。

val name: String? = "Kotlin"
name?.let {
    // 只有当 name 不为 null 时才执行这里的代码
    println("The name is ${it.toUpperCase()}")
}

val name2: String? = null
name2?.let {
    // 这段代码不会执行
    println("This will not be printed if name2 is null")
}

6. 安全类型转换 (as?)

安全类型转换 as? 尝试将一个值转换为指定的类型，如果转换失败，则返回 null，而不是抛出 ClassCastException。

val obj: Any = "Hello"
val str: String? = obj as? String // str 为 "Hello"

val num: Any = 123
val str2: String? = num as? String // str2 为 null

平台类型 (Platform Types)

Kotlin 的空安全设计非常严格，但当它需要与 Java 代码交互时，就面临一个挑战。Java 不像 Kotlin 那样在类型系统中强制空安全，Java 的引用可以是 null，也可以是非 null，这在编译时是无法确定的。

为了解决这个问题，Kotlin 引入了平台类型 (Platform Types)。

平台类型是指 Kotlin 编译器 无法确定其空性 的类型，通常是来自 Java 代码的类型。当你从 Java 代码中调用方法或访问字段时，Kotlin 编译器无法知道这些值是否可能为 null。

平台类型在 Kotlin 中用 T! 的形式表示（例如 String!），但你不能在代码中显式地声明一个平台类型。它只会在编译器推断出类型时出现。

例如，如果你有一个 Java 类：

// JavaClass.java
public class JavaClass {
    public String getName() {
        return null; // Java 中可以返回 null
    }

    public void printValue(String value) {
        System.out.println(value.length()); // 如果 value 为 null，这里会抛出 NPE
    }
}

在 Kotlin 中使用 JavaClass：

// Kotlin code
val javaClass = JavaClass()
val name = javaClass.name // name 的类型会被推断为 String! (平台类型)

平台类型的特点和处理

当你操作一个平台类型的值时，Kotlin 编译器不会强制进行空安全检查。这意味着你可以像在 Java 中那样使用它，但这也意味着你可能会遇到 NullPointerException，因为它可能在运行时为 null。

对于平台类型，Kotlin 将空性的责任交给了开发者。你可以选择将其视为可空类型 (String?) 或非空类型 (String)。

• 如果你确定它不会是 null，可以将其赋值给非空类型。如果运行时是 null，就会抛出 NPE。
• 如果你不确定它是否为 null，最好将其赋值给可空类型，并使用安全调用操作符或其他空处理机制。

在Java代码中，为了帮助 Kotlin 编译器更好地理解 Java 代码的空性，Java 库可以使用空性注解（如 @Nullable, @NotNull，来自 JetBrains、AndroidX、JSR-305 等）。如果 Java 代码使用了这些注解，Kotlin 编译器可以根据注解信息 将 Java 类型映射为 Kotlin 的可空或非空类型 ，从而避免平台类型带来的不确定性。

总结来说，平台类型是 Kotlin 和 Java 互操作性中的一个“妥协点”，它允许你在 Kotlin 中使用 Java 代码，但同时也提醒你，在这些特定情况下，Kotlin 的编译时空安全保护可能会失效，你需要更加小心地处理潜在的 null 值。

单例类

Java中比较通用的单例类写法一般为static关键字声明的懒加载同步方法。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造函数，防止外部实例化
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在Kotlin中，想要定义一类为全局单例模式，只需要使用 object 关键字来声明类就可以了。

object Singleton {
    fun doSomething() {
        // 单例对象的方法
    }
}

// 使用
Singleton.doSomething()

这个写法等同于Java中的饿汉单例模式，对于开发者写起来更简洁，反编译之后的java代码如下：

public final class Singleton {
   @NotNull
   public static final Singleton INSTANCE = new Singleton();

   private Singleton() {
   }
}

伴生对象

在Kotlin中，每个类都可以有一个伴生对象。伴生对象的成员可以直接通过类名调用，而不需要实例化类。

class MyClass {
    companion object {
        fun doSomething() {
            // 伴生对象的方法
        }
    }
}

// 使用
MyClass.doSomething()

与Java中的静态方法类似，Kotlin中的伴生对象方法在反编译后的Java代码中也会被转换为静态方法。

在Android中，可以把类的TAG，和这个类强相关的一些常量，都定义在这个类的伴生对象中。

字符串模板

Java中，字符串和变量的结合需要使用加号+，而Kotlin中可以使用字符串模板来简化这个过程。在Kotlin中，可以使用字符串模板来动态构建字符串。字符串模板以$开头，在其中可以嵌入变量或表达式。

val name = "Kotlin"
val message = "Hello, $name!" // 字符串模板，结果为 "Hello, Kotlin!"

如果是和常量拼接，在编译器就会直接内联优化为字符串。如果是变量拼接，最后运行时实际上还是使用StringBuilder来拼接字符串。

扩展函数

在Kotlin中，可以为现有的类添加新的函数，而不需要修改类的源代码。这些新的函数被称为扩展函数。扩展函数允许你在不继承类的情况下，向类添加新的行为。

例如，String 类并没有一个内置的 isPalindrome() 方法来检查一个字符串是否是回文，但你可以通过扩展函数为它添加这个功能：

fun String.isPalindrome(): Boolean {
    val cleanedString = this.lowercase().replace(Regex("[^a-z0-9]"), "")
    return cleanedString == cleanedString.reversed()
}

fun main() {
    val word = "madam"
    println(word.isPalindrome()) // 输出: true
}

在这个例子中：

• fun String.isPalindrome(): Boolean 定义了一个扩展函数。
• String. 表示这个函数是 String 类的扩展。
• 在函数内部，this 关键字引用了调用该函数的 String 实例。

扩展函数让代码看起来更自然。比如 string.isPalindrome() 比 StringUtils.isPalindrome(string) 更直观。扩展函数可以把这些“工具”方法直接挂载到它们所操作的类上，减少了Utils工具类的数量，使得代码结构更清晰。

实现原理

Kotlin 的扩展函数实际上是一个静态函数。当 Kotlin 编译器处理扩展函数时，它会将其转换为一个普通的静态方法，这个静态方法会将接收者对象作为第一个参数。

例如，上面的 String.isPalindrome() 扩展函数在编译后，大致等价于一个 Java 中的静态方法：

// 编译后的伪 Java 代码
public final class StringExtensionsKt { // 自动生成的文件名，通常是文件名 + Kt
    public static final boolean isPalindrome(@NotNull String $receiver) {
        // 函数体内部的 this 对应于这里的 $receiver 参数
        String cleanedString = $receiver.toLowerCase().replaceAll("[^a-z0-9]", "");
        return cleanedString.equals(new StringBuilder(cleanedString).reverse().toString());
    }
}

然后，当你调用 word.isPalindrome() 时，编译器会将其转换为对这个静态方法的调用：

// 编译后的伪 Java 代码
StringExtensionsKt.isPalindrome(word);

这就是为什么扩展函数不能访问其接收者的 private 或 protected 成员——因为它并不是真正意义上的成员函数，它只是一个方便的语法糖。

Android 开发中的常见应用

在 Android 开发中，扩展函数无处不在，极大地简化了代码：

• View 扩展: 为 View 添加方便的函数，比如 View.show()、View.hide()、View.gone()。

  fun View.show() {
      this.visibility = View.VISIBLE
  }
  
  fun View.hide() {
      this.visibility = View.INVISIBLE
  }
  
  fun View.gone() {
      this.visibility = View.GONE
  }
  

• Context 扩展: 简化 Toast 显示、资源获取等操作。

  fun Context.toast(message: String, duration: Int = Toast.LENGTH_SHORT) {
      Toast.makeText(this, message, duration).show()
  }
  // 使用: context.toast("Hello!")
  

• Fragment/Activity 扩展: 简化 FragmentTransaction 或 Intent 的使用。
• 数据类型转换: 比如为 Int 或 Long 添加 toPx() 或 toDp() 转换函数。

高阶函数 let、with、apply、run、also

也叫操作域函数，它们是 Kotlin 标准库中非常强大且常用的高阶函数。作为 Android 开发者，你肯定会在日常工作中频繁遇到和使用它们，因为它们能让你的代码更简洁、更易读，尤其是处理对象的配置、转换或安全调用时。

作用域函数是一种特殊的函数，它们的主要目的是在你提供的 lambda 表达式内部创建一个 临时作用域 。在这个作用域内，你可以直接访问（或引用）你所操作的对象，从而避免重复写对象名，让代码更紧凑。

Kotlin 提供了五种主要的作用域函数：let、run、with、apply 和 also。它们之间的主要区别在于：

• 引用上下文对象的方式：使用 this 还是 it。
• 返回值：返回上下文对象本身还是 lambda 表达式的结果。

apply

apply 函数，它的 lambda 表达式的 最后一行代码会自动作为返回值 返回。不同之处在于 apply 函数始终返回 上下文对象本身。

val result = "Kotlin".apply {
    println("Length: $length") // 可以直接访问 String 的属性
}
// 输出: Length: 6
// 因为 apply 始终返回上下文对象本身，所以可以直接链式调用
"Kotlin".apply {
    println("Length: $length")
}.also {
    println("Also: $it") // 输出: Also: Kotlin
}

在Android中，apply通常用于对一个对象进行初始化或设置属性。例如，在RecyclerView的初始化过程中。

recyclerView.apply {
    layoutManager = LinearLayoutManager(context)
    addItemDecoration(MyDecoration(context)) // 添加分隔线装饰器
    setHasFixedSize(true) // 固定大小，提高性能
    adapter = myAdapter // 设置适配器
}

let

上面的空安全有提到一次，最常用于判空场景，非空后执行let中的代码。返回值 lambda 表达式的最后一行结果。还可以很方便地在链式调用中对结果进行操作或转换。

val name: String? = "Alice"

// 传统空检查
if (name != null) {
    println(name.length)
}

// 使用 let 进行空安全操作
name?.let {
    // 这里的 it 就是非空的 name
    println(it.length)
}

// 链式调用和转换
val result = "Hello Kotlin"
    .length
    .let { it * 2 } // 将长度乘以2
    .let { "Double length: $it" } // 转换为字符串
println(result) // 输出: Double length: 24

run

内部引用方式为 this ，返回值为 lambda 表达式的最后一行结果。

run 主要有两种应用形式：

作为扩展函数调用 (在对象上调用)

val user = User("Bob", 30)

val userDescription = user.run {
    // 这里的 this 就是 user 对象
    "Name: ${this.name}, Age: ${this.age}" // 返回这个字符串
}
println(userDescription) // 输出: Name: Bob, Age: 30

// 结合空安全 (类似 let)
val greeting: String? = "Hello"
val finalMessage = greeting?.run {
    // 这里的 this 就是非空的 "Hello"
    toUpperCase() + "!" // 返回 "HELLO!"
} ?: "No greeting" // 如果 greeting 为 null，则返回 "No greeting"
println(finalMessage) // 输出: HELLO!

独立调用

val message = run {
    val x = 10
    val y = 20
    "Sum: ${x + y}" // 返回这个字符串
}
println(message) // 输出: Sum: 30

with

引用方式为 this ，返回值 lambda 表达式的最后一行结果。 已知非空的对象执行一系列操作，而不需要链式调用。与 run 作为扩展函数类似，但 with 不是扩展函数写法，它将对象作为第一个参数传入。

val configuration = Configuration("Debug", 1024)

val configDetails = with(configuration) {
    // 这里的 this 就是 configuration 对象
    println("Configuring system...")
    "Mode: ${mode}, Size: ${maxSize}MB" // 返回这个字符串
}
println(configDetails) // 输出: Mode: Debug, Size: 1024MB

also

内部引用方式为 it 。返回 上下文对象本身 。主要用于 执行对象的附加操作，不影响对象本身，通常用于副作用 (side-effects)。例如，日志记录、调试输出或在对象准备好后执行一些不影响其状态的操作。

val numbers = mutableListOf(1, 2, 3)

val processedNumbers = numbers.also {
    // 这里的 it 就是 numbers 列表
    println("Before adding: $it") // 打印当前列表状态
    it.add(4)
}.also {
    println("After adding: $it") // 再次打印列表状态
}
// also 返回 numbers 列表本身，所以 processedNumbers 仍然是 numbers
println(processedNumbers) // 输出: [1, 2, 3, 4]

即also 适用于你想在不改变原始对象的情况下，对其执行一些额外操作的场景。

操作域函数小结

• let: 如果你想在代码块中对一个可空对象执行操作，或者想对结果进行转换，并返回转换后的值。
• run:
  • 作为扩展函数: 如果你想配置一个对象并计算一个结果，或者结合空安全和 this 引用。
  • 作为非扩展函数: 如果你想封装一段语句，并返回其结果。
• with: 如果你有一个非空对象，并且想在其作用域内执行一系列操作并返回一个结果。
• apply: 如果你想配置一个对象并返回该对象本身。非常适合链式设置多个属性。
• also: 如果你想在不改变对象的情况下，对它执行一些额外操作或副作用（例如日志记录、调试打印），并返回该对象本身。

val originSting = "Kotlin"
val letString = originSting.let {
    it.uppercase()
}
val applyString = originSting.apply {
    uppercase()
}
val withString = with(originSting) {
    uppercase()
}
val runString = originSting.run {
    uppercase()
}
val alsoString = originSting.also {
    it.uppercase()
}
/**
letString: KOTLIN
applyString: Kotlin
withString: KOTLIN
runString: KOTLIN
alsoString: Kotlin
*/

根据运行结果可以看出，apply和also都是返回操作的对象本身的，另外的三个，都是返回最后一行表达式的结果。在使用操作域函数时，需要注意这一点以免拿到不符合预期的数据。

map扩展函数

map 可以对List，Map，Set等集合对象中的元素进行转换，生成一个新的集合。

例如：

val numbers = listOf(1, 2, 3, 4)
val doubled = numbers.map { it * 2 } 
// 结果: [2, 4, 6, 8]

// 或显式命名参数
val squared = numbers.map { number -> number * number }
// 结果: [1, 4, 9, 16]

在Android中，也可以用在初始化要显示的数据集上，语法更简洁：

private val functionList = listOf(
    "壁纸取色测试" to {
        startActivity(Intent(this, WallpaperTestActivity::class.java))
    },
    "弹一个Toast" to {
        Toast.makeText(this, "一个普通的Toast", Toast.LENGTH_SHORT).show()
    },
    "设备Root状态" to {
        startActivity(Intent(this, RootInfoActivity::class.java))
    },
    "CPU信息" to {
        startActivity(Intent(this, CpuInfoActivity::class.java))
    },
).map { (name, task) -> FunctionItem(name, task) }

还可以和 Flow 数据流一起作用，在数据发送之前使用 map 预处理一遍：

fun mapTest() {
    CoroutineScope(Dispatchers.IO).launch {
        flowOf(1, 2, 3, 4, 5).map {
            it + 1
        }.collectLatest {
            Log.i(TAG, "mapTest collect $it")
        }
    }
}

use扩展函数

use 函数是 Kotlin 标准库为实现了 Closeable 或 AutoCloseable 接口的类（如 FileInputStream、BufferedReader 等）提供的扩展函数。

它主要用于​资源管理​​（如文件、网络连接、数据库连接等），它可以确保资源在使用完毕后被正确关闭，即使发生异常也能保证资源释放，防止内存泄露。其底层实现实际上也是对try-catch-finally的封装。

用法举例，独取一个文件的内容：

fun readFile() {
    val file = File("example.txt")
    FileInputStream(file).use { inputStream ->
        val bytes = inputStream.readBytes()
        println(String(bytes))
    } // inputStream 自动关闭
}

数据库连接：

fun queryDatabase() {
    val connection: Connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db")
    connection.use { conn ->
        // 执行 SQL 查询
        conn.createStatement().use { statement ->
            statement.executeQuery("SELECT * FROM users").use { resultSet ->
                while (resultSet.next()) {
                    println(resultSet.getString("name"))
                }
            }
        }
    } // conn 自动关闭
}

Kotlin集合

对于Kotlin和Java中的集合简要对比，专门提取来一篇来记录：

Kotlin中的集合

data class数据类

data class 是 Kotlin 中的一个重要概念，通常用于表示数据对象。

数据类是专门为存储数据而设计的类。 Kotlin 编译器会自动为数据类生成许多有用的成员函数，从而省去了你手动编写这些函数的麻烦。这使得你的代码更简洁、更安全、更易读。

在 Java 中，为了实现一个简单的数据持有类，你需要写大量的模板代码（构造函数、getter/setter、equals()、hashCode()、toString() 等），而 Kotlin 的数据类用一个关键字就搞定了这一切。

data class User(val name: String, val age: Int)

1. 所有属性的 Getters (以及 var 属性的 Setters): 尽管在 Kotlin 中我们通常直接访问属性，但底层它们依然是存在的。

   val user = User("Alice", 30)
   println(user.name) // 访问 name 属性
   

2. equals(other: Any?): 用于比较两个数据类对象是否相等。当且仅当两个对象的类型相同，并且主构造函数中声明的所有属性的值都相等时，它们才被认为是相等的。

   val user1 = User("Alice", 30)
   val user2 = User("Alice", 30)
   val user3 = User("Bob", 25)
   
   println(user1 == user2) // 输出: true (因为属性值相同)
   println(user1 == user3) // 输出: false
   

   注意： 传统的类比较的是内存地址（引用相等），而数据类比较的是内容（结构相等）。

3. hashCode(): 返回一个基于主构造函数中所有属性的哈希码。这在将数据类对象存储在哈希集合（如 HashSet 或 HashMap）中时至关重要。equals() 和 hashCode() 必须保持一致性（如果两个对象 equals 返回 true，它们的 hashCode 也必须相同）。

   val userSet = hashSetOf(user1)
   println(userSet.contains(user2)) // 输出: true (因为 user2 的 equals 和 hashCode 与 user1 相同)
   

4. toString(): 返回一个包含类名和所有属性及其值的字符串表示。这对于日志记录和调试非常有用。

   val user = User("Alice", 30)
   println(user) // 输出: User(name=Alice, age=30)
   

5. componentN() 函数: 为每个在主构造函数中声明的属性生成一个 componentN() 函数，其中 N 是属性在声明时的顺序（component1() 对应第一个属性，component2() 对应第二个，以此类推）。这些函数使得数据类可以支持解构声明 (Destructuring Declarations)。

   val (name, age) = User("Alice", 30) // 解构声明
   println("Name: $name, Age: $age") // 输出: Name: Alice, Age: 30
   

6. copy(): 创建一个新对象，复制现有对象的所有属性，同时允许你选择性地修改某些属性的值。这对于创建对象的一个副本但需要轻微修改时非常有用，因为数据类通常是不可变的（尽管也可以有 var 属性）。

   val originalUser = User("Alice", 30)
   val copiedUser = originalUser.copy(age = 31) // 复制 originalUser，只改变 age 属性
   val anotherCopiedUser = originalUser.copy(name = "Bob") // 改变 name 属性
   
   println(originalUser)    // 输出: User(name=Alice, age=30)
   println(copiedUser)      // 输出: User(name=Alice, age=31)
   println(anotherCopiedUser) // 输出: User(name=Bob, age=30)
   

数据类使用注意事项

1. 主构造函数必须至少有一个参数：所有自动生成的函数都是基于主构造函数中声明的属性。
2. 主构造函数的所有参数都必须标记为 val 或 var：这是为了确保它们是类中的属性，而不是仅仅是构造函数参数。
3. 不能是 abstract、open、sealed 或 inner 类：数据类通常是最终的，不适合继承层次结构。

4. 可以有其他成员: 除了自动生成的函数，你也可以在数据类中定义自己的函数、属性或伴生对象。

   data class Product(val id: String, val name: String, var price: Double) {
       // 自定义函数
       fun displayInfo() {
           println("Product ID: $id, Name: $name, Price: $price")
       }
   
       // 伴生对象
       companion object {
           const val DEFAULT_CURRENCY = "USD"
       }
   }
   

5. 属性的默认值: 你可以为数据类的主构造函数属性提供默认值。

   data class Settings(val theme: String = "dark", val notificationsEnabled: Boolean = true)
   val defaultSettings = Settings() // 使用默认值
   val customSettings = Settings(theme = "light") // 覆盖默认值
   

Android中常用场景

在 Android 开发中，数据类无处不在：

• API 响应模型: 当你从 RESTful API 获取数据时，通常会定义数据类来映射 JSON 或 XML 结构。

  data class Post(val userId: Int, val id: Int, val title: String, val body: String)
  

• 数据库实体: 当使用 Room Persistence Library 或其他 ORM 框架时，数据类可以很好地表示数据库表中的一行数据。

  @Entity(tableName = "users")
  data class UserEntity(@PrimaryKey val id: Long, val name: String, val email: String)
  

• UI 状态: 在 MVVM 或 MVI 架构中，数据类常用于表示 UI 的当前状态，方便进行状态的更新和比较。

  data class UserProfileState(
      val isLoading: Boolean = false,
      val user: User? = null,
      val errorMessage: String? = null
  )
  

• 事件 (Events): 在事件驱动的架构中，数据类可以很好地表示各种事件。

  sealed class LoginEvent {
      data class Success(val userId: String) : LoginEvent()
      data class Error(val message: String) : LoginEvent()
      object Loading : LoginEvent()
  }
  

Kotlin高级特性

sealed class和sealed interface

Kotlin 的密封类 (Sealed Class) 是一个非常棒的特性，尤其是在处理有限的、受限的类继承结构时。它能让你的代码更安全、更具表达力，并且在与 when 表达式结合使用时，能提供强大的编译时检查。

密封类是一种限制类继承层次结构的特殊抽象类。 它的主要目的是声明一个受限的类层次结构，其中所有可能的子类都必须在同一文件内声明（Kotlin 1.5 之后可以在同一个模块内的任何文件中声明，但通常仍推荐在同一文件内以保持紧凑性）。

这就意味着，编译器在编译时就知道了这个密封类的所有可能直接子类。这种“已知子类”的特性是密封类最有价值的地方。

// 定义一个密封类来表示网络请求的结果
sealed class NetworkResult {
    data class Success(val data: String) : NetworkResult() // 子类可以是数据类
    data class Error(val message: String) : NetworkResult()   // 子类可以是数据类
    object Loading : NetworkResult()                          // 子类可以是单例对象
    class Idle : NetworkResult()                              // 子类也可以是普通类
}

在这个例子中：

• NetworkResult 是一个密封类。
• Success、Error、Loading 和 Idle 是 NetworkResult 的直接子类。
• 重要: 所有的这些子类都必须在定义 NetworkResult 的同一文件内（或者在 Kotlin 1.5+ 中，在同一模块内），这样编译器才能“知道”它们。

1. 确保穷举性检查 (Exhaustiveness Checking) 与 when 表达式

这是密封类最强大的特性。当你在 when 表达式中使用密封类的实例时，如果 when 覆盖了所有可能的子类型，Kotlin 编译器会强制你处理所有可能的子类，并且不需要 else 分支。如果遗漏了某个子类，编译器会报错，从而防止运行时错误。

fun handleNetworkResult(result: NetworkResult) {
    when (result) {
        is NetworkResult.Success -> {
            println("数据加载成功: ${result.data}")
        }
        is NetworkResult.Error -> {
            println("加载失败: ${result.message}")
        }
        NetworkResult.Loading -> { // 注意：对于 object，直接引用即可
            println("正在加载中...")
        }
        is NetworkResult.Idle -> {
            println("网络请求处于空闲状态。")
        }
        // 不需要 else 分支，因为编译器知道所有可能的子类型都被处理了
    }
}

这对于构建健壮的应用程序至关重要，特别是在处理 UI 状态、事件或网络响应时。

2. 更好的类型安全和代码可读性

密封类提供了一种清晰的方式来建模有限的状态。例如，一个 UI 组件的状态可能只有“加载中”、“显示数据”或“显示错误”几种。使用密封类可以明确地表示这些状态，使得代码的意图一目了然，并减少了引入无效状态的可能性。

3. 作为枚举的替代（更强大）

虽然枚举 (enum class) 也能表示一组有限的值，但枚举的每个成员都是一个简单的实例，不能携带额外的状态。而密封类的每个子类可以是独立的类，可以拥有自己的属性和行为，这使得它比枚举更加灵活和强大。

// 枚举无法携带额外数据
enum class Color { RED, GREEN, BLUE }

// 密封类可以携带额外数据
sealed class Shape {
    data class Circle(val radius: Double) : Shape()
    class Square(val side: Double) : Shape()
    object Triangle : Shape() // 也可以是无状态的单例
}

密封类与枚举 (Enum Class) 的场景选择

• 使用枚举: 如果你只需要表示一组固定且不携带额外数据的常量集（例如方向：上、下、左、右；或简单的状态：开启、关闭）。
• 使用密封类: 如果你需要表示一组有限的、可携带不同数据或具有不同行为的子类型（例如网络请求结果、UI 状态、事件）。

密封类在 Android 开发中的常见应用

在 Android 开发中，密封类几乎无处不在，是管理复杂状态和事件的利器：

1. 网络请求结果: 如上面示例所示，表示 API 调用的不同状态（成功、失败、加载中）。

   sealed class Resource<out T> { // 可以是泛型
       data class Success<out T>(val data: T) : Resource<T>()
       data class Error(val message: String, val errorCode: Int) : Resource<Nothing>()
       object Loading : Resource<Nothing>()
   }
   

2. UI 状态: 定义一个屏幕可能拥有的所有状态。

   sealed class UserViewState {
       object Loading : UserViewState()
       data class Loaded(val user: User) : UserViewState()
       data class Error(val errorMessage: String) : UserViewState()
       object Empty : UserViewState()
   }
   

3. 用户交互事件: 表示用户在界面上的各种操作。

   sealed class ProfileEvent {
       object LoadProfile : ProfileEvent()
       data class UpdateName(val newName: String) : ProfileEvent()
       object Logout : ProfileEvent()
   }
   

4. RecyclerView 列表项: 如果一个 RecyclerView 可以显示不同类型的列表项（Header, Item, Footer），可以用密封类来建模。

协程

Kotlin的协程也是广为开发者讨论的一个异步框架，在Android应用开发过程中，几乎可以完全替代线程的使用，并且以同步方式写异步代码看起来也比较优雅。

详细的有多篇文章介绍过：

Kotlin协程的基础使用

Kotlin协程浅谈

Kotlin协程的取消与异常处理

Kotlin协程挂起恢复源码解析

内联函数 (Inline Functions) 与交叉内联 (Crossinline)/无内联 (Noinline)

关于这几个内联相关的关键字，由另一篇文章也记录过：

Kotlin的inline&crossinline&noinline关键字

泛型的 in out 和 Reified 关键字

Kotlin协变和逆变

委托

在 Kotlin 中，委托（Delegation） 是一种强大的设计模式，它允许对象将部分功能委托给另一个辅助对象来实现。Kotlin 原生支持多种委托方式，主要分为以下几种：

类委托（Class Delegation）

通过 by 关键字，将类的接口实现委托给另一个对象，常用于 “装饰器模式” 或 “代理模式”。

示例：委托接口实现

interface Printer {
    fun print(message: String)
}

class DefaultPrinter : Printer {
    override fun print(message: String) {
        println("Default Printer: $message")
    }
}

// 委托给 printer 对象
class CustomPrinter(private val printer: Printer) : Printer by printer {
    // 可以覆盖部分方法
    override fun print(message: String) {
        println("Before Printing...")
        printer.print(message) // 调用委托对象的方法
        println("After Printing...")
    }
}

fun main() {
    val defaultPrinter = DefaultPrinter()
    val customPrinter = CustomPrinter(defaultPrinter)
    customPrinter.print("Hello, Kotlin!")
}