菜鸟追梦旅行

这个屌丝很懒，什么也没留下！

热门标签

【Kotlin实操】1.Kotlin协程原理与上手体验_kotlin observable.zip

作者：菜鸟追梦旅行 | 2024-03-21 01:51:57

踩

kotlin observable.zip

1.异步？我们为什么使用异步

同步（Sync）

所谓同步，就是发出一个功能调用时，在没有得到结果之前，该调用就不返回，这样就不能继续执行后续操作。
在这里插入图片描述

异步（Async）

所谓同步，就是调用发出后，调用者在没有得到结果之前，就可以继续执行后续操作。当这个调用完成后，通过状态、通知和回调来通知调用者。

在这里插入图片描述
为什么使用异步——提升效率
异步一般都能够提升效率这也是我们使用异步的主要原因

异步带来的问题——回调嵌套
异步调用有依赖关系时每增加一个调用回调的嵌套层级也相应增加

比如 3个接口调用串行，回调嵌套保证了执行顺序：
请求接口1成功–>请求接口2成功–>请求接口3成功–>更新UI

//请求 接口1
api1 (
    cllback(
        //请求接口2
        api2(
            callback(
                //请求接口3
                api3(
                    callback(
                        //更新UI 
                    )
                )
            )
        )  
    )
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

再比如3个接口并行，回调逻辑保证了执行顺序
请求结果需要汇总后更新UI

//并行 汇总
  api1(
  callback(
       if(api2已完成 && api3已完成){
           updateUI()
       }
    )
  )
  api2(callback(
      if(api1已完成 && api3已完成){
          updateUI()
      }
  	)
  )
  
  api3(callback(
      if(api1已完成 && api2已完成){
          updateUI()
      }
    )
  )
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

if(api2已完成 && api3已完成)
if(api1已完成 && api3已完成)
if(api1已完成 && api2已完成)
1
2
3

嗯这~ 谁用谁知道

2.RxJava不香吗？为什么是协程？

那怎么解决异步调用的回调嵌套呢
说到异步大名鼎鼎的RxJava是怎么做的
RxJava的链式调用

//1.串行 flatmap
api1()
	.flatMap {  
     	api2()
   	}.flatMap {  
    	api3()
   	}.subscribe {  
    	updateUI()
   	}

//2.串行 cocat
Observable.concat(api1(), api2(), api3())
		  .subscribe{
			updateUI()
		  }
		  
//3.并行 merge
Observable.merge(api1(), api2(), api3())
		  .subscribe{
			updateUI()
		  }
		  
//4.并行 zip
Observable.zip(api1(), api2(),BiFunction.apply{
		   	value1 + value2
		  })
		  .subscribe{
			updateUI()
		  }
		  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

嗯 RxJava的链式调用能在调用逻辑复杂时依然保持调用形式上的简单
那么问题来了既然有RxJava 还要什么Kotlin协程？（要啥自行车）
Another way!

3.协程怎么用？

协程实现串行3个接口访问 launch{} 按前后顺序书写即可

//串行 
launch{
	value1 = api1()
	vale2 = api2(vlaue1) 
	value3 = api3(value2)
	
	updateUI(value3)
} 

suspend fun api1():Value1{...}
suspend fun api2():Value2{...}
suspend fun api3():Value3{...}

fun updateUI(){...}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

接下来看一下并行数据汇总 async{} await()

launch{
	value1 = async{ api1() }
	value2 = async{ api2() }
	value3 = async{ api3() }
	//这里会等待value1 value2 value3都请求完成
	updateUI(value1.await(), value2.await(), value3.await())
}

suspend fun api1():Value1{...}
suspend fun api2():Value2{...}
suspend fun api3():Value3{...}

fun updateUI(){...}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.协程是个啥？

什么是进程、线程、协程？

协程是一种编程概念就像进程、线程一样。 Go、Python等编程语言都有协程的概念。
进程是应用程序的启动实例，进程拥有代码和打开的文件资源、数据资源、独立的内存空间。进程的调度者是系统。
线程从属于进程，是程序的实际执行者，一个进程至少包含一个主线程，也可以有更多的子线程，线程拥有自己的栈空间。线程的调度者是系统。
协程是一种比线程更加轻量级的存在，正如一个进程可以拥有多个线程一样，一个线程可以拥有多个协程。协程的调度者是用户。

进程线程协程的关系图：
在这里插入图片描述

Kotlin中的协程“

Google Android 上的 Kotlin 协程
协程是在版本 1.3 中添加到 Kotlin 的，它基于来自其他语言的既定概念。
协程是一种并发设计模式，您可以在 Android 平台上使用它来简化异步执行的代码 (用同步的方式编写异步代码真香)。
协程是我们在 Android 上进行异步编程的推荐解决方案。

轻量：
单个线程上运行多个协程，因为协程支持暂停，不会使正在运行协程的线程阻塞。暂停比阻塞节省内存，且支持多个并行操作。
内存泄露更少：
使用结构化并发机制在一个作用域内执行多个操作。
内置取消支持：
取消功能会自动通过正在运行的协程层次结构传播。
Jetpack 集成：
许多 Jetpack 库都包含提供全面协程支持的扩展。

关于Kotlin的协程这里引出几个问题

问题1.协程暂停是怎么实现的？
问题2.协程暂停后如何恢复？
问题3.线程切换怎么实现的？
问题4.协程是非阻塞式的更轻量更高效吗？

5.Kotlin协程的原理

1.Continuation
从方法调用方式说起
在这里插入图片描述
Java内存分区图这里只关注虚拟机栈

Java虚拟机栈是线程私有的，他的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：
每个方法在执行的同时都会创建一个栈帧(frame)用于存储局部变量、操作数、操作数栈、动态链接、方法出口(return)等信息。
每一个方法的调用过程直至执行完成的过成，就对应着一个栈帧(frame)在虚拟机栈中入栈到出栈的过程。

可见Java方法是通过Java方法栈实现调用。

Continuation是另一种函数调用方式。

上下文信息保存在continuation record中组成树/图的结构。
调用函数就等于给当前节点生成一个子节点，然后把系统寄存器移动到这个子节点。函数的退出等于从当前节点退回到父节点。
节点的删除是由gc来管理

这样的调用方式和堆栈方式相比的好处在哪里呢？

好处就是，它可以让你从任意一个节点跳到另一个节点。而不必遵循堆栈方式的一层一层的return方式。

比如说，在当前的函数内，你只要有一个其它函数的节点信息，完全可以选择return到那个函数，而不是返回到自己的调用者。
你也可以在一个函数的任何位置储存自己的上下文信息，然后，在以后某个适当的时刻，从其它的任何一个函数里面返回到自己现在的位置。（重点）

Continuation思想的一个重要应用场景就是Continuation-passing style(CPS) 续体风格

2.CPS变换

CPS的基本思想是：当需要返回某些数据的时候，不是直接把它当作函数的返回值，而是接受一个叫做continuation的参数。这个参数就是一个call-back函数, 它接受这个数据，并做需要做的事情。

//普通函数
fun foo(x)
{
   return x;
}

//CPS风格函数
fun foo(x, continuation)
{
   continuation(x);
 
   //注意：调用continuation(x)相当于“return”，之后的语句都不会被执行了。
   assert(false, "should not be here");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

CPS的使用特点：

CPS函数都有一个额外的参数 continuation(续体) ，表示控制流。函数需要返回，必须显式的调用 continuation
CPS所有函数都是尾调用(在函数的末尾调用了另外一个函数，这种调用称为尾调用，tail call)
CPS代码基本没法阅读和理解，最初主要用于编译高级语言时一种中间代码表示，有了这种中间代码，编译器的复杂度大大降低
CPS在异步编程里，分布式编程里大显身手(重点)

so，我知道了这些有什么用？客官请注意 异步编程 (点题了啊)，在说CPS在异步编程的应用之前我们先来了解下续体拦截器

我们知道

CPS函数调用的时候，必须传进来一个Continuation；
Continuation调用可以在一个函数的任何位置储存自己的上下文信息，然后，在以后某个适当的时刻，从其它的任何一个函数里面返回到自己现在的位置；

如果需要在跨线程场景下发起Continuation调用需要指定Continuation运行的线程这个要用到续体拦截器(ContinuationInterceptor)

ContinuationInterceptor（续体拦截器），续体拦截器负责拦截协程在恢复后应执行的代码（即续体）并将其在指定线程或线程池恢复。

3.suspend 关键字
suspend 挂起
用于修饰函数被suspend修饰的函数称之为挂起函数
挂起函数只能在另一个挂起函数或者协程中被调用
挂起函数不仅支持call和return 还“支持” suspend和resume

Kotlin 中被 suspend 修饰符修饰的函数在编译期间会被编译器做特殊处理。而这个特殊处理的第一道工序就是：CPS（续体传递风格）变换，它会改变挂起函数的函数签名。

举个栗子：

挂起函数 getIpAddress() 的函数签名如下所示：

suspend fun getIpAddress(ip: String): String {
    return withContext(Dispatchers.IO) {
        println("getIpAddress ${Thread.currentThread().name}")
        val json = URL(IPAddress.IP.replace("IP", ip)).readText()
        val resultType = object : TypeToken<BaseBean<IPBean>>() {}.type
        val bean = Gson().fromJson<BaseBean<IPBean>>(json, resultType)
        val city = bean.result.City
        println("city-->$city")
        city
    }
}
1
2
3
4
5
6
7
8
9
10
11

在编译期发生 CPS 变换之后：

  
public final Object getIpAddress(String paramString, Continuation paramContinuation) {
  CoroutineContext coroutineContext = (CoroutineContext)Dispatchers.getIO();
  ApiDataCoroutine$getIpAddress$2 apiDataCoroutine$getIpAddress$2 = new ApiDataCoroutine$getIpAddress$2();
  this(paramString, null);
  apiDataCoroutine$getIpAddress$2 = apiDataCoroutine$getIpAddress$2;
  return BuildersKt.withContext(coroutineContext, apiDataCoroutine$getIpAddress$2, paramContinuation);
}
1
2
3
4
5
6
7
8

Kotlin中的Continuation声明类型为接口

interface Continuation<in T> {
   //协程上下文
   val context: CoroutineContext
   //续体恢复时调用
   fun resumeWith(result: Result<T>)
}
1
2
3
4
5
6

续体Continuation，它包装了协程在挂起之后应该继续执行的代码
协程可以在挂起函数的地方挂起(Continuation续体暂停)，挂起结束后恢复（Continuation 续体恢复）

4.状态机
举个栗子
接口串行

根据Ip获取所属地址city 成功后更新UI
拿到city后查询天气预报成功后更新UI

 GlobalScope.launch(Dispatchers.Main) {
 		 println("协程Start ${Thread.currentThread().name}")
         val city = getIpAddress(ip) //IO线程获取IP所属地
         updateCityUI(cityTv, city)//主线程更新UI

         val weather = getWeather(city)//IO线程获取IP所属地的天气 需要参数city
         updateWeatherUI(weatherTv, weather)//主线程更新UI
         println("协程End ${Thread.currentThread().name}")
        }

 suspend fun getIpAddress(ip: String): String {
     return withContext(Dispatchers.IO) {
             val json = URL(IPAddress.IP.replace("IP", ip)).readText()
             ......
             val city = bean.result.City
             city
         }
     }
     
 suspend fun getWeather(city: String): String {
     return withContext(Dispatchers.IO) {
         Thread.sleep(2_000)
         val json = URL(IPAddress.WEATHER.replace("CITY", city.substring(0, 2))).readText()
         ......
         val weather = bean.result.future[0].weather
         weather
     }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

以上代码反编译后

 
    public final Object invokeSuspend(Object paramObject) {
        Object object1 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
        int i = this.label;
        Object object2 = "Thread.currentThread()";
        byte b1 = 4;
        byte b2 = 3;
        byte b3 = 2;
        byte b4 = 1;
        switch (this.label) {
            case 0: {
                ResultKt.throwOnFailure(paramObject);
                CoroutineScope coroutineScope = this.p$;
                StringBuilder stringBuilder2 = new StringBuilder();
                this();
                stringBuilder2.append("");
                Thread thread = Thread.currentThread();
                Intrinsics.checkExpressionValueIsNotNull(thread, (String) object2);
                String str3 = thread.getName();
                stringBuilder2.append(str3);
                String str2 = stringBuilder2.toString();
                System.out.println(str2);
                ApiDataCoroutine apiDataCoroutine2 = ApiDataCoroutine.INSTANCE;
                str3 = this.$ip;
                this.L$0 = coroutineScope;
                this.label = b4;
                Object object4 = apiDataCoroutine2.getIpAddress(str3, (Continuation) this);
                if (object4 == object1)
                    return object1;
                object4 = object4;
                StringBuilder stringBuilder1 = new StringBuilder();
                this();
                stringBuilder1.append("city-->");
                stringBuilder1.append((String) object4);
                String str1 = stringBuilder1.toString();
                System.out.println(str1);
                ApiDataCoroutine apiDataCoroutine1 = ApiDataCoroutine.INSTANCE;
                TextView textView = this.$cityTv;
                this.L$0 = coroutineScope;
                this.L$1 = object4;
                this.label = b3;
                Object object3 = apiDataCoroutine1.updateCityUI(textView, (String) object4, (Continuation) this);
                break;
            }
            case 1: {
                i = 0;
                Object object5 = this.L$0;
                Object object3 = object5;
                object3 = object5;
                ResultKt.throwOnFailure(paramObject);
                object5 = paramObject;
                object5 = object5;
                StringBuilder stringBuilder = new StringBuilder();
                this();
                stringBuilder.append("city-->");
                stringBuilder.append((String) object5);
                String str = stringBuilder.toString();
                System.out.println(str);
                ApiDataCoroutine apiDataCoroutine = ApiDataCoroutine.INSTANCE;
                TextView textView = this.$cityTv;
                this.L$0 = object3;
                this.L$1 = object5;
                this.label = b3;
                Object object4 = apiDataCoroutine.updateCityUI(textView, (String) object5, (Continuation) this);
                break;
            }
            case 2: {
                i = 0;
                b3 = 0;
                Object object6 = this.L$1;
                Object object4 = object6;
                object4 = object6;
                object6 = this.L$0;
                Object object3 = object6;
                object3 = object6;
                ResultKt.throwOnFailure(paramObject);
                object6 = ApiDataCoroutine.INSTANCE;
                this.L$0 = object3;
                this.L$1 = object4;
                this.label = b2;
                Object object5 = object6.getWeather((String) object4, (Continuation) this);
                break;
            }
            case 3: {
                i = 0;
                b2 = 0;
                Object object4 = this.L$1;
                Object object5 = object4;
                object5 = object4;
                object4 = this.L$0;
                Object object3 = object4;
                object3 = object4;
                ResultKt.throwOnFailure(paramObject);
                object4 = object5;
                object5 = paramObject;
                object5 = object5;
                StringBuilder stringBuilder = new StringBuilder();
                this();
                stringBuilder.append("");
                thread = Thread.currentThread();
                Intrinsics.checkExpressionValueIsNotNull(thread, (String) object2);
                object2 = thread.getName();
                stringBuilder.append((String) object2);
                object2 = stringBuilder.toString();
                System.out.println(object2);
                object2 = ApiDataCoroutine.INSTANCE;
                TextView textView = this.$weatherTv;
                this.L$0 = object3;
                this.L$1 = object4;
                this.L$2 = object5;
                this.label = b1;
                object2 = object2.updateWeatherUI(textView, (String) object5, (Continuation) this);
                break;
            }
            case 4:
                i = 0;
                Object object3 = this.L$2;
                Object object4 = object3;
                object4 = object3;
                object3 = this.L$1;
                object2 = object3;
                object2 = object3;
                object3 = this.L$0;
                object1 = object3;
                object1 = object3;
                ResultKt.throwOnFailure(paramObject);
                break;
            default:
                object1 = new IllegalStateException();
                super("call to 'resume' before 'invoke' with coroutine");
                throw object1;
                break;
        }
        return Unit.INSTANCE;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

6.总结

Kotlin的协程就是Kotlin提供的一套线程框架，本质上和Handler，AsyncTask，RxJava 是一致的。只不过协程封装的更友好，使用起来更方便。
协程可以用同步的方式写异步代码。
协程并没有比线程更高效、更轻量级。

参考文章

怎样理解同步异步和阻塞非阻塞
 同步(Synchronous)和异步(Asynchronous)
忘了RxJava吧——你需要的是拥抱Kotlin协程
 Kotlin 协程真的比 Java 线程更高效吗
 Kotlin Coroutines Offical Doc

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/277525