{"id":28490304,"url":"https://github.com/jeanboydev/android-kotlintest","last_synced_at":"2025-07-13T20:06:50.331Z","repository":{"id":106410514,"uuid":"214744198","full_name":"jeanboydev/Android-KotlinTest","owner":"jeanboydev","description":null,"archived":false,"fork":false,"pushed_at":"2020-01-20T11:48:33.000Z","size":214,"stargazers_count":0,"open_issues_count":0,"forks_count":1,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-06-22T02:43:31.679Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Kotlin","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/jeanboydev.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2019-10-13T01:48:18.000Z","updated_at":"2020-01-20T11:48:35.000Z","dependencies_parsed_at":null,"dependency_job_id":"83752b62-ce0d-4a47-a80b-ea069cc718e1","html_url":"https://github.com/jeanboydev/Android-KotlinTest","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/jeanboydev/Android-KotlinTest","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jeanboydev%2FAndroid-KotlinTest","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jeanboydev%2FAndroid-KotlinTest/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jeanboydev%2FAndroid-KotlinTest/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jeanboydev%2FAndroid-KotlinTest/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/jeanboydev","download_url":"https://codeload.github.com/jeanboydev/Android-KotlinTest/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jeanboydev%2FAndroid-KotlinTest/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":265198361,"owners_count":23726449,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2025-06-08T07:08:17.994Z","updated_at":"2025-07-13T20:06:50.322Z","avatar_url":"https://github.com/jeanboydev.png","language":"Kotlin","readme":"# Android-KotlinTest\n\n## Kotlin 用途\n\n- 用于服务器端开发\n- 用于 Android 开发\n- 用于 Javascript 开发\n- 用于原生开发\n- 用于数据科学\n\n## Kotlin 特点\n\n- 性能：由于非常相似的字节码结构，Kotlin 应用程序的运行速度与 Java 类似。随着 Kotlin 对内联函数的支持，使用 lambda 表达式的代码通常比用 Java 写的代码运行得更快。\n- 互操作性：Kotlin 可与 Java 进行 100％ 的互操作\n\n\n## 单例模式\n\n- 饿汉模式\n\n```kotlin\nobject Singleton {}\n```\n\n- 懒汉模式\n\n```kotlin\nclass Singleton private constructor() {\n    companion object {\n        private var instance: Singleton? = null\n            get() {\n                if (field == null) {\n                    field = Singleton()\n                }\n                return field\n            }\n\n        fun get(): Singleton {\n            return instance!!\n        }\n    }\n}\n```\n\n- 线程安全懒汉模式\n\n```kotlin\nclass Singleton private constructor() {\n    companion object {\n        private var instance: Singleton? = null\n            get() {\n                if (field == null) {\n                    field = Singleton()\n                }\n                return field\n            }\n\n        @Synchronized\n        fun get(): Singleton {\n            return instance!!\n        }\n    }\n}\n```\n\n- 双重校验锁模式\n\n```kotlin\nclass Singleton private constructor() {\n    companion object {\n        val instance: Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {\n            Singleton()\n        }\n    }\n}\n```\n\n- 静态内部类模式\n\n```kotlin\nclass Singleton private constructor() {\n    companion object {\n        val instance = SingletonHolder.holder\n    }\n\n    private object SingletonHolder {\n        val holder = Singleton()\n    }\n}\n```\n\n- 枚举模式\n\n```kotlin\nenum class Singleton {\n    INSTANCE\n}\n```\n## 对象（object）\n\nKotlin 中的对象指的是使用 object 关键字定义的 类型声明，一般用作单例模式和伴生对象。\n\n```kotlin\nobject Test {\n    val name = \"Haha\"\n    \n    fun say() {\n        println(\"Hello\")\n    }\n}\n```\n\n这样，我们就能得到一个单例类。\n\n## 伴生对象（companion object）\n\nKotlin 没有静态成员。静态成员在 Java 中有很大的作用，因为 Java 没有全局变量，也不存在包级函数，一切属性和方法都是在类里面，所以在写一些工具函数和全局变量时，都需要用到 static 关键字修饰的静态成员。\n\nKotlin 之所以能抛弃静态成员，主要原因在于它允许包级属性和函数的存在，而且 Kotlin 为了维持与 Java 完全的兼容性，为静态成员提供了多种替代方案：\n\n- 使用包级属性和包级函数：主要用于 全局常量 和 工具函数 \n- 使用伴生对象：主要用于与类有紧密联系的变量和函数\n- 使用 @JvmStatic 注解：与伴生对象搭配使用，将变量和函数声明为真正的 JVM 静态成员\n\n\n```kotlin\nclass Test{\n    companion object { // 伴生对象\n        const val STATIC = \"常量\"\n    }\n}\n```\n\nKotlin 允许在类中使用 companion object 创建伴生对象，用伴生对象的成员来代替静态成员。使用伴生对象实际上是在这个类内部创建了一个名为 Companion 的静态单例内部类。伴生对象中定义的属性会直接编译为外部类的静态字段，而函数会被编译为伴生对象的方法。\n\n### @JvmStatic 注解\n\n@JvmStatic 注解只能用在伴生对象里，修饰伴生对象内的属性和函数，用来告诉编译器将属性和函数编译为真正的 JVM 静态成员。需要注意到，如果在伴生对象声明里使用 @JvmStatic 注解，那么没有加该注解的属性和函数将不会被编译为静态成员：\n\n```kotlin\nclass Person(val name: String) {\n  companion object {\n    @JvmStatic \n    val anonymous = Person(\"Anonymous\")\n    fun say() = println(\"Hello\")\n  }\n}\n```\n\n## lateinit var 和 by lazy\n\nKotlin 中有两种延迟初始化的方式。一种是 lateinit var，一种是 by lazy。\n\n### lateinit var\n\n```kotlin\nlateinit var name: String\n```\n\nlateinit var 只能用来修饰类属性，不能用来修饰局部变量，并且只能用来修饰对象，不能用来修饰基本类型（因为基本类型的属性在类加载后的准备阶段都会被初始化为默认值）。\n\nlateinit var 的作用也比较简单，就是让编译期在检查时不要因为属性变量未被初始化而报错。后续在哪里以及何时初始化还需要开发者自己决定。\n\n### by lazy\n\nby lazy 本身是一种属性委托。属性委托的关键字是by。\n\n```kotlin\nval name: Int by lazy { 1 }\n\npublic fun test(){\n    val bar by lazy { \"hello\" }\n    println(bar)\n}\n```\n\n以 name 属性为代表来讲解 by lazy 的原理，局部变量的初始化也是一样的原理。\n\nby lazy 要求属性声明为 val，即不可变变量，在 Java 中相当于被 final 修饰。\n\n这意味着该变量一旦初始化后就不允许再被修改值了（基本类型是值不能被修改，对象类型是引用不能被修改）。{}内的操作就是返回唯一一次初始化的结果。\n\nby lazy 可以使用于类属性或者局部变量。\n\n## 可见性修饰符\n\n- private 意味着只在这个类内部（包含其所有成员）可见；\n- protected—— 和 private一样 + 在子类中可见。\n- internal —— 能见到类声明的 本模块内 的任何客户端都可见其 internal 成员；\n- public —— 能见到类声明的任何客户端都可见其 public 成员。\n\n## 扩展\n\n扩展并不是真正的修改了被扩展类。而只是在 Kotlin 中的调用像是修改了被扩展类。\n\n```kotlin\n// 为 String 扩展一个 size() 函数\nfun String.size(): Int {\n    return length\n}\n```\n\n## 数据类（data）\n\n```kotlin\ndata class User(val name: String, val age: Int)\n```\n\n当我们声明一个数据类时，编辑器自动为这个类做了一些事情。\n\n- 生成 equals() 函数与 hasCode() 函数\n- 生成 toString() 函数，由类名（参数1 = 值1，参数2 = 值2，....）构成\n- 由所定义的属性自动生成 component1()、component2()、...、componentN() 函数，其对应于属性的声明顺序。\n- copy() 函数\n\n## 密封类（sealed）\n\n密封类用来表示受限的类继承结构：当一个值为有限几种的类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展：枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。\n\n一个密封类是自身抽象的，它不能直接实例化并可以有抽象（abstract）成员。\n\n密封类不允许有非-private 构造函数（其构造函数默认为 private）。\n\n```kotlin\nsealed class Test()\n```\n\n密封类是不能被实例化的。\n\n```kotlin\nsealed class Test {\n    data class Person(val name: String): Test()\n    object a: Test() // 单例模式\n}\n```\n\n我们知道普通的继承类使用 open 关键字定义，在项目中的类都可继承至该类。\n\n而密封类的子类必须是在密封类的内部或必须存在于密封类的同一文件。这一点就可以有效的代码保护。\n\n```kotlin\n// 使用\nval test = Test.Person(\"haha\")\n```\n\n## 类型别名（typealias）\n\n类型别名为现有类型提供替代名称，类型别名不会引入新类型 它们等效于相应的底层类型。\n\n```kotlin\ntypealias ArrayList\u003cE\u003e = java.util.ArrayList\u003cE\u003e\n```\n\n## 内联函数\n\n在程序编译时能将程序中内联函数的调用表达式直接替换成内联函数的函数体。\n\n内联函数可以消除函数调用的开销。\n\n```kotlin\ninline fun test(a: Int, b: Int): Int {\n    println(\"a: $a, b: $b\")\n    return a + b\n}\n```\n\n## 内联类（inline class）\n\n内联类可以消除创建对象的开销。\n\n```kotlin\ninline class Test(val value:String) {\n\n}\n```\n\n内联类必须有一个主构造函数，并且在主构造函数里必须有且只有一个 val 属性，除此之外，不能再拥有其他的字段。\n\n## 委托（by）\n\n在委托模式中，当有两个对象参与处理同一个请求是，接受请求的对象将请求委托给另一个对象来处理。\n\n委托模式已证明是实现继承的一个很好的替代方式。\n\nKotlin中委托分为类委托和委托属性，Kotlin官方库也封装了一些常用的委托。\n\n### 类委托\n\n类 Derived 可以继承一个接口 Base，并将其所有共有的方法委托给一个指定的对象，也就是说把类 Derived 因继承而需要实现的方法委托给一个对象，从而不需要在该类内显式的实现：\n\n```kotlin\ninterface Base {\n    fun print()\n}\n\nclass BaseImpl(val x: Int) : Base {\n    override fun print() { print(x) }\n}\n\nclass Derived(b: Base) : Base by b\n\nfun main() {\n    val b = BaseImpl(10)\n    Derived(b).print()\n}\n```\n\n如果 Derived 类没有写 by b，那么就必须重写 print 方法，否则编译器会报错。\n\n### 属性委托\n\n属性的委托指的是一个类中的某个属性的值不是在类中直接进行定义，而是由某个类的方法来进行 setter 和 getter。默认属性委托都是线程安全的。属性委托适合那些属性的需要复杂的计算但是计算过程可以被重用的场合。\n\n\u003e 语法：val/var \u003c属性名\u003e: \u003c类型\u003e by \u003c表达式\u003e\n\n- by lazy\n\n```kotlin\nval name: Int by lazy { 1 }\n```\n\n- by Delegates.observable()\n\n```kotlin\nvar a: Int by Delegates.observable(1) { \n    property, oldValue, newValue -\u003e\n\n}\n```\n\n- by Delegates.nonNull()\n\n```kotlin\nvar a: Int by Delegates.notNull()\n```\n\n## 操作符重载（operator）\n\n将一个函数标记为重载一个操作符，也就是操作符重载。\n\n```kotlin\nclass Data(var value: String) {\n\n    operator fun plus(other: Data): Data {\n        this.value = this.value + \"_**_\" + other.value\n        return this\n    }\n}\n\nfun main() {\n    val str = Data(\"haha\") + Data(\"ooo\")\n    println(str.value) // haha_**_ooo\n}\n```\n\n## lambda 表达式\n\n### Lambda 表达式的特点\n\n- Lambda 表达式总是被大括号括着\n- 参数（如果存在）在 -\u003e 之前声明（参数类型可以省略）\n- 函数体（如果存在）在 -\u003e 后面\n\n```kotlin\n// 无参数\nvar test = { }\n\n// 有参数 in -\u003e out\nvar test2 = { name: String -\u003e\n    println(name)\n    it + \"aaa\" // 不能直接使用 return，最后一个表达式为返回值\n}\n\n// 作为参数\nfun test3(a: Int, b: (num: Int) -\u003e Int): Int {\n    return a + b.invoke(2)\n}\n```\n\n## 闭包\n\n所谓闭包，即是函数中包含函数，这里的函数我们可以包含（Lambda表达式，匿名函数，局部函数，对象表达式）。\n\n看一段 Java 代码：\n\n```java\npublic class TestJava{\n\n    private void test() {\n        private void test() { // 错误，因为Java中不支持函数包含函数\n        }\n    }\n\n    private void test1(){} // 正确，Java中的函数只能包含在对象中+\n}\n```\n\n看一段 Kotlin 代码：\n\n```kotlin\nfun test1(){\n    fun test2() { // 正确，因为 Kotlin 中可以函数嵌套函数\n    }\n}\n```\n\n- 携带状态\n\n让函数返回一个函数，并携带状态值。\n\n```kotlin\nfun test(b: Int): () -\u003e Int {\n    var a = 3\n    return fun(): Int {\n        a++\n        return a + b\n    }\n}\n```\n\n- 引用外部变量，并改变外部变量的值\n\n```kotlin\nvar sum : Int = 0\nval arr = arrayOf(1,3,5,7,9)\narr.filter { it \u003c 7  }.forEach { sum += it }\n```\n\n广义上来说，在 Kotlin 语言之中，函数、条件语句、控制流语句、花括号逻辑块、Lambda 表达式都可以称之为闭包，但通常情况下，我们所指的闭包都是在说 Lambda 表达式。\n\n\n## 解构声明\n\nKotlin 可以将一个对象解构为多个变量：\n\n```kotlin\nval (name, age) = person\n```\n\n这种语法被称为解构声明。解构声明一次创建多个变量。比如声明 name 和 age 两个新的变量，可以单独使用。\n\n解构声明最终编译为下面的代码：\n\n```kotlin\nval name = person.component1()\nval age = person.component2()\n```\n\ncomponent1() 和 component2() 函数是 Kotlin 中广泛使用的惯例原则的例子（如+、* 操作符，for 循环等）。解构声明右侧能放任意对象，只要可以调用所需的组件函数，如组件 component3()，component4() 等等。\n\n解构声明同样可以在 for 循环中使用：\n\n```kotlin\nfor ((a, b) in collection) {\n //...\n}\n```\n\n变量 a 和 b 为集合中元素 component1() 和 component2() 的值。\n\n### 一个函数返回两个值\n\n如果需要一个函数返回两个值，如：一个返回对象和一些排序状态，Kotlin 可以通过声明一个 data 类并返回它的实例方式。\n\n```kotlin\ndata class Result(val result: Int , val state: Status)\n\nfun function(): Result{\n    // 计算\n    return Result(result ,status)\n}\n\n// 现在可以使用这个函数了\nval (result , status) = function()\n```\n\n### 解构声明和映射\n\n下面示例可能是迭代 Map 的好的方式：\n\n```kotlin\nfor((key , value ) in map){\n    // ...\n}\n```\n\n要让这正常工作，我们得\n\n- 通过提供一个 iterator() 函数让映射表现得像一个队列值，\n- 通过提供函数 component1() and component2() 让每组元素表现得像一对。\n\n而且事实上，标准库提供了这些扩展：\n\n```kotlin\noperator fun \u003cK, V\u003e Map\u003cK, V\u003e.iterator(): Iterator\u003cMap.Entry\u003cK, V\u003e\u003e = entrySet().iterator()\noperator fun \u003cK, V\u003e Map.Entry\u003cK, V\u003e.component1() = getKey()\noperator fun \u003cK, V\u003e Map.Entry\u003cK, V\u003e.component2() = getValue()\n```\n\n所以可以在有映射 for 循环（与 data 类集合一样）中自由地使用解构声明。\n\n## 作用域函数\n\nKotlin标准库包含几个函数，它们的唯一目的是在对象的上下文中执行代码块。当您对提供lambda表达式的对象调用这样一个函数时，它将形成一个临时作用域。在这个范围内，您可以访问没有名称的对象。这些函数称为作用域函数。\n\n```kotlin\n// 创建画笔，并设置一些基础属性\nval paint = Paint()\npaint.isAntiAlias = true\npaint.color = Color.parseColor(\"#999999\")\npaint.textSize = sp(8f).toFloat()\n\n// apply 作用域函数来优化一下\nval mRangTextPaint = Paint().apply {\n  isAntiAlias = true\n  color = Color.parseColor(\"#999999\")\n  textSize = sp(8f).toFloat()\n}\n```\n\n作用域函数猛地一看很相似，但是他们有以下两个主要区别：\n\n| 作用域函数 | Object reference | Return value  |\n| :--------: | :--------------: | :-----------: |\n|    run     |       this       | Lambda result |\n|    with    |       this       | Lambda result |\n|   apply    |       this       |  上下文对象   |\n|    let     |        it        | Lambda result |\n|    also    |        it        |  上下文对象   |\n\n- let\n\nlet 经常用于仅使用非空值执行代码块。如需对非空对象执行操作，可对其使用安全调用操作符 ?. 并调用 let 在 lambda 表达式中执行操作。\n\n```kotlin\nval str: String? = \"Hello\" \n//processNonNullString(str)       // 编译错误：str 可能为空\nval length = str?.let { \n    println(\"let() called on $it\")\n    processNonNullString(it)      // 编译通过：'it' 在 '?.let { }' 中必不为空\n    it.length\n}\n```\n\n- with\n\n在代码中，with 可以理解为对于这个对象，执行以下操作。\n\n```kotlin\nval numbers = mutableListOf(\"one\", \"two\", \"three\")\nwith(numbers) {\n    println(\"'with' is called with argument $this\")\n    println(\"It contains $size elements\")\n}\n```\n\n- run\n\nrun 和 with 做同样的事情，但是调用方式和 let 一样——作为上下文对象的扩展函数。\n\n- apply\n\napply 的常见情况是对象配置。这样的调用可以理解为将以下赋值操作应用于对象。\n\n```kotlin\nval adam = Person(\"Adam\").apply {\n    age = 32\n    city = \"London\"        \n}\n```\n\n- also\n\nalso 对于执行一些将上下文对象作为参数的操作很有用。可以将其理解为并且执行以下操作。\n\n```kotlin\nval numbers = mutableListOf(\"one\", \"two\", \"three\")\nnumbers\n    .also { println(\"The list elements before adding new one: $it\") }\n    .add(\"four\")\n```\n\n### 使用场景\n\n很多人接触到作用域函数的时候，最头疼的问题不是不会用，而是不知道如何选择合适的作用域函数。之所以出现这种情况，是因为其实作用域函数在多数情况下是可以互换的，因此官方文档也给我们推荐了各个函数常见的使用场景。\n\n![](https://user-gold-cdn.xitu.io/2019/9/6/16d049bbdb6f658d?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)\n\n## 协程\n\nhttps://www.bennyhuo.com/2019/04/01/basic-coroutines/\n\nhttps://kaixue.io/tag/kotlin-xie-cheng/\n\nhttps://www.jianshu.com/p/2659bbe0df16\n\n「协程 Coroutines」源自 Simula 和 Modula-2 语言，这个术语早在 1958 年就被 Melvin Edward Conway 发明并用于构建汇编程序，说明协程是一种编程思想，并不局限于特定的语言。\n\nGo 语言也有协程，叫 Goroutines，从英文拼写就知道它和 Coroutines 还是有些差别的（设计思想上是有关系的），否则 Kotlin 的协程完全可以叫 Koroutines 了。\n\n协程是一种非抢占式或者说协作式的计算机程序并发调度的实现，程序可以主动挂起或者恢复执行。\n\n我们在 Java 虚拟机上所认识到的线程大多数的实现是映射到内核的线程的，也就是说线程当中的代码逻辑在线程抢到 CPU 的时间片的时候才可以执行，否则就得歇着，当然这对于我们开发者来说是透明的；而经常听到所谓的协程更轻量的意思是，协程并不会映射成内核线程或者其他这么重的资源，它的调度在用户态就可以搞定，任务之间的调度并非抢占式，而是协作式的。\n\n```kotlin\npublic fun CoroutineScope.launch(\n    // 上下文\n    context: CoroutineContext = EmptyCoroutineContext,\n    // 启动模式\n    start: CoroutineStart = CoroutineStart.DEFAULT,\n    block: suspend CoroutineScope.() -\u003e Unit\n): Job {\n    val newContext = newCoroutineContext(context)\n    val coroutine = if (start.isLazy)\n        LazyStandaloneCoroutine(newContext, block) else\n        StandaloneCoroutine(newContext, active = true)\n    coroutine.start(start, coroutine, block)\n    return coroutine\n}\n```\n\n### 基本使用\n\n```kotlin\n// 方法一，使用 runBlocking 顶层函数\nrunBlocking {\n    getImage(imageId)\n}\n\n// 方法二，使用 GlobalScope 单例对象\n// 可以直接调用 launch 开启协程\nGlobalScope.launch {\n    getImage(imageId)\n}\n\n// 方法三，自行通过 CoroutineContext 创建一个 CoroutineScope 对象\n// 需要一个类型为 CoroutineContext 的参数\nval coroutineScope = CoroutineScope(context)\ncoroutineScope.launch {\n    getImage(imageId)\n}\n```\n\n- 方法一通常适用于单元测试的场景，而业务开发中不会用到这种方法，因为它是线程阻塞的。\n- 方法二和使用 runBlocking 的区别在于不会阻塞线程。但在 Android 开发中同样不推荐这种用法，因为它的生命周期会和 app 一致，且不能取消。\n- 方法三是比较推荐的使用方法，我们可以通过 context 参数去管理和控制协程的生命周期（这里的 context 和 Android 里的不是一个东西，是一个更通用的概念，会有一个 Android 平台的封装来配合使用）。\n\n协程最常用的功能是并发，而并发的典型场景就是多线程。可以使用 Dispatchers.IO 参数把任务切到 IO 线程执行：\n\n```kotlin\ncoroutineScope.launch(Dispatchers.IO) {\n   // ...\n}\n```\n\n也可以使用 Dispatchers.Main 参数切换到主线程：\n\n```kotlin\ncoroutineScope.launch(Dispatchers.Main) {\n   // ...\n}\n```\n\n### 启动模式\n\n- DEFAULT：饿汉式\n- LAZY：懒汉式\n- ATOMIC\n- UNDISPATCHED\n\n### 上下文\n\nCoroutineScope，可以理解为协程本身，包含了 CoroutineContext。\n\nCoroutineContext，协程上下文，是一些元素的集合，主要包括 Job 和 CoroutineDispatcher 元素，可以代表一个协程的场景。\n\nEmptyCoroutineContext 表示一个空的协程上下文。\n\n### 拦截器\n\n### 调度器\n\nCoroutineDispatcher，协程调度器，决定协程所在的线程或线程池。它可以指定协程运行于特定的一个线程、一个线程池或者不指定任何线程（这样协程就会运行于当前线程）。`coroutines-core`中 CoroutineDispatcher 有三种标准实现`Dispatchers.Default`、`Dispatchers.IO`，`Dispatchers.Main`和`Dispatchers.Unconfined`，Unconfined 就是不指定线程。\n\n`launch`函数定义如果不指定`CoroutineDispatcher`或者没有其他的`ContinuationInterceptor`，默认的协程调度器就是`Dispatchers.Default`，`Default`是一个协程调度器，其指定的线程为共有的线程池，线程数量至少为 2 最大与 CPU 数相同。\n\n### 异常处理\n\n### 挂起函数（suspend）\n\n\n\n## async\n\n\n\n## 通道\n\n## 管道\n\n## Mutex\n\n## Actors\n\n\n\n\n\n\n\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjeanboydev%2Fandroid-kotlintest","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fjeanboydev%2Fandroid-kotlintest","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjeanboydev%2Fandroid-kotlintest/lists"}