AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

抽丝剥茧聊Kotlin协程之认真聊聊协程是什么

2022-05-10 150
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 抽丝剥茧聊Kotlin协程之认真聊聊协程是什么

1. 前言

关于协程，可能大家最经常听到的一句话就是“协程是轻量级的线程”。一脸懵逼，有没有？这可是官方的slogan，严格意义上讲，一方面官方是想让大家把协程和线程产生一个直观关联，另一方面想宣传协程在性能上比线程更优，充分地说服大家去使用它。本文我将尝试把协程是什么讲明白。


2. 聊聊线程


既然说“协程是轻量级的线程”。那我们有必要先回顾下线程是什么？ 在泛Java程序中，要启动一个线程那太easy了，new一个Thread，重写run方法，调用start方法，就是这么简单。


public fun thread(
    start: Boolean = true,
    isDaemon: Boolean = false,
    contextClassLoader: ClassLoader? = null,
    name: String? = null,
    priority: Int = -1,
    block: () -> Unit
): Thread {
    val thread = object : Thread() {
        public override fun run() {
            block()
        }
    }
    if (isDaemon)
        thread.isDaemon = true
    if (priority > 0)
        thread.priority = priority
    if (name != null)
        thread.name = name
    if (contextClassLoader != null)
        thread.contextClassLoader = contextClassLoader
    if (start)
        thread.start()
    return thread
}

简单是简单，不过也有不少弊端呢：


  1. 如果创建的线程数量超过了最大文件描述符数量，程序会报OOM的（当创建的线程的速度>线程消耗的速度时）
  2. 如果需要频繁创建线程去执行耗时非常短的代码，频繁的切换线程对性能也是有影响的
  3. 线程之间的通信比较复杂，把A线程的数据传递到B线程不那么容易

因为有了以上弊端，于是我们有了线程池。


3. 聊聊线程池

由于本文重点是讲协程，如果有同学对线程池不了解可以适当补补课，网上资料很多也不难。


线程池想必大部分同学都很熟悉了。缓存池，对象池，连接池，各种池相关的技术就是缓存技术。线程池缓存的对象就是线程。


public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

我们可以看到线程池几个核心参数：


  1. corePoolSize核心线程池数量
  2. maximumPoolSize最大线程池数量
  3. BlockingQueue<Runnable> workQueue 工作队列，工作队列中保存的是Runnable对象


接下来再看下工作线程Worker的源码，它继承自Thread，它的run方法调用了runWorker方法，源码如下：


//ThreadPoolExecutor.java
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        while (task != null || (task = getTask()) != null) {
            w.lock();
            // If pool is stopping, ensure thread is interrupted;
            // if not, ensure thread is not interrupted.  This
            // requires a recheck in second case to deal with
            // shutdownNow race while clearing interrupt
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}


我们看到该方法主要就是循环从workQueue中拿取可执行的runnable去执行。细心的同学可能会提出疑问了，如果while循环的条件不成立，那岂不是会导致线程直接退出。这种想法其实是个误区了，由于workQueue是BlockingQueue，如果队列中没有runnable对象，此处代码是会阻塞的，跳不出循环。


那么回到文章开头，"协程是轻量级的线程"，到底何物比线程还要轻量级。对了聪明的读者可能已经猜出来了，workQueue中的runnable。为了方便理解，我们可以把协程理解为线程执行的最小单位，工作队列中的Runnable，有源码为证。

代码来自kotlinx-coroutines-core-jvm:1.4.1
//1. AbstractCoroutine
public abstract class AbstractCoroutine<in T> (...): JobSupport(active), 
Job, Continuation<T>, CoroutineScope 
//2. DispatchedContinuation
internal class DispatchedContinuation<in T>(
    @JvmField val dispatcher: CoroutineDispatcher,
    @JvmField val continuation: Continuation<T>
) : DispatchedTask<T>(MODE_UNINITIALIZED), CoroutineStackFrame, Continuation<T> by continuation
//3. DispatchedTask
internal abstract class DispatchedTask<in T>(
    @JvmField public var resumeMode: Int
) : SchedulerTask() 
internal actual typealias SchedulerTask = Task
//4.Task
internal abstract class Task(
    @JvmField var submissionTime: Long,
    @JvmField var taskContext: TaskContext
) : Runnable {
    constructor() : this(0, NonBlockingContext)
    inline val mode: Int get() = taskContext.taskMode // TASK_XXX
}


上述源码也可以简化为


public abstract class AbstractCoroutine<in T> 
(...): Runnable


简单讲协程就是一个Runnable，而且这个Runnable必须是存储在工作队列中，才能发挥它轻量级的优势。


题外话：线程，死循环，队列，MessageQueue。Android开发者最熟悉的MainThread不正天然的满足这些特性吗。难道说往Handler中post一个Runnable也是启动一个协程吗？如果这样类比能够让你更容易理解协程，那就这样理解吧，这样理解也没问题。只不过协程能做的远比往主线程post一个线程最小单位多多了。


既然线程池，MainThread已经充分地发挥了线程的性能。那么为什么还要有协程呢？协程在他们之上又解决了什么问题呢？


4. 聊聊协程


首先来看一个最简单的例子，在Activity中开启一个协程，然后在子线程中休眠10s，结束后在主线程中打印出子线程中返回的值。


//TestActivity.java
MainScope().launch {
    val result = withContext(Dispatchers.IO) {
        Thread.sleep(10_000)
        println("I am running in ${Thread.currentThread()}")
        "Hello coroutines"
    }
    println("I am running in ${Thread.currentThread()} result is $result")
}


打印结果如下，我们看到在子线程中睡眠，在主线程中打印子线程中返回的值。


2021-11-22 22:29:02.868 3407-3463/com.peter.viewgrouptutorial I/System.out: 
I am running in Thread[DefaultDispatcher-worker-1,5,main]
2021-11-22 22:29:02.874 3407-3407/com.peter.viewgrouptutorial I/System.out: 
I am running in Thread[main,5,main] result is Hello coroutines


咋一看，大家可能会有疑问了，老兄，实现这种需求，有必要这么复杂吗，老弟我三下五除二搞定好吗？看我的：


thread {
    Thread.sleep(10_000)
    println("I am running in ${Thread.currentThread()}")
    val result = "Hello coroutines"
    Handler(Looper.getMainLooper()).post {
        println("I am running in ${Thread.currentThread()} result is $result")
    }
}


轻轻松松几行代码搞定，稳重而且不失风度，打印结果一模一样。


2021-11-22 22:35:59.016 3597-3655/com.peter.viewgrouptutorial I/System.out: 
I am running in Thread[Thread-3,5,main]
2021-11-22 22:35:59.020 3597-3597/com.peter.viewgrouptutorial I/System.out: 
I am running in Thread[main,5,main] result is Hello coroutines


那么问题来了，如果需求是在子线程中睡眠10s，将返回值返回给另一个子线程呢？当然用传统的线程也不是不能实现，如果用协程那就相当简单了


// 为了模拟出效果，特意使用只有一个线程的线程池来当Dispatcher
MainScope().launch(Executors.newFixedThreadPool(1).asCoroutineDispatcher()) {
    val result = withContext(Dispatchers.IO) {
        Thread.sleep(10_000)
        println("I am running in ${Thread.currentThread()}")
        "Hello coroutines"
    }
    println("I am running in ${Thread.currentThread()} result is $result")
}


打印结果如下，注意看是两个不同的线程：


2021-11-22 22:41:01.953 3872-3927/com.peter.viewgrouptutorial I/System.out: 
I am running in Thread[DefaultDispatcher-worker-1,5,main]
2021-11-22 22:41:01.960 3872-3926/com.peter.viewgrouptutorial I/System.out:
I am running in Thread[pool-1-thread-1,5,main] result is Hello coroutines


5. 总结

所以在我看来，协程有以下几个特性：


  1. 将协程体封装成线程可执行的最小单位Runnable，准确讲是协程中的Continuation，通过分发机制分发到对应的线程对应的工作队列中
  2. Continuation会保存协程栈帧中的数据，在切换线程时把协程栈帧带过去，在切回线程时，又通过它把数据带回来。（没错，类似callback机制）
  3. 线程池对开发者封装了线程，只需要往里面submit Runnable就可以了。而协程同时对开发者封装了线程和Callback，开发者无需关心线程和线程切换的内在逻辑。
//TestActivity.java
MainScope().launch {
    val result = withContext(Dispatchers.IO) {
        Thread.sleep(10_000)
        println("I am running in ${Thread.currentThread()}")
        "Hello coroutines"
    }
    println("I am running in ${Thread.currentThread()} result is $result")
}
val coroutinesBodyRunnable = java.lang.Runnable {
    thread {
        Thread.sleep(10_000)
        println("I am running in ${Thread.currentThread()}")
        val result = "Hello coroutines"
        Handler(Looper.getMainLooper()).post {
            println("I am running in ${Thread.currentThread()} result is $result")
        }
    }
}
Handler(Looper.getMainLooper()).post(coroutinesBodyRunnable)


以上代码是等价的。时间原因，具体原理，后续再讲，敬请期待。如果觉得文章有帮助，帮我分享给周围的朋友吧。期待我们可以在评论中碰撞出更多的火花，一起探讨技术，一起进步。


文章标签：
Java
Android开发
缓存
存储
开发者
Kotlin
关键词：
Kotlin协程
协程kotlin协程
抽丝剥茧kotlin协程协程
协程抽丝剥茧
抽丝剥茧Kotlin协程
游客k7ja6kkd3nere
目录
相关文章
Ant.Dream
|
20天前
|
JSON 调度 数据库
Android面试之5个Kotlin深度面试题：协程、密封类和高阶函数
本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点。文章详细解析了Kotlin中的协程、扩展函数、高阶函数、密封类及`inline`和`reified`关键字在Android开发中的应用，帮助读者更好地理解和使用这些特性。
Ant.Dream
16 1
wljslmz
|
3月前
|
调度 开发者 UED
Kotlin 中的协程是什么？
【8月更文挑战第31天】
wljslmz
162 0
Ant.Dream
|
5月前
|
存储 Java 调度
Android面试题之Kotlin 协程的挂起、执行和恢复过程
了解Kotlin协程的挂起、执行和恢复机制。挂起时，状态和上下文（局部变量、调用栈、调度器等）被保存；挂起点通过`Continuation`对象处理，释放线程控制权。当恢复条件满足，调度器重新分配线程，调用`resumeWith`恢复执行。关注公众号“AntDream”获取更多并发知识。
Ant.Dream
122 2
肥猪肥猪-17824
|
6月前
|
移动开发 Android开发 开发者
构建高效Android应用：Kotlin与协程的完美融合
【5月更文挑战第25天】 在移动开发的世界中，性能和响应性是衡量应用质量的关键指标。随着Kotlin的流行和协程的引入，Android开发者现在有了更强大的工具来提升应用的性能和用户体验。本文深入探讨了Kotlin语言如何与协程相结合，为Android应用开发带来异步处理能力的同时，保持代码的简洁性和可读性。我们将通过实际案例分析，展示如何在Android项目中实现协程，以及它们如何帮助开发者更有效地管理后台任务和用户界面的流畅交互。
肥猪肥猪-17824
42 1
mrq4nk6ni2neg
|
6月前
|
移动开发 监控 Android开发
构建高效安卓应用：Kotlin 协程的实践与优化
【5月更文挑战第16天】 在移动开发领域，性能优化一直是开发者们追求的重要目标。特别是对于安卓平台来说，由于设备多样性和系统资源的限制，如何提升应用的响应性和流畅度成为了一个关键议题。近年来，Kotlin 语言因其简洁、安全和高效的特点，在安卓开发中得到了广泛的应用。其中，Kotlin 协程作为一种轻量级的并发解决方案，为异步编程提供了强大支持，成为提升安卓应用性能的有效手段。本文将深入探讨 Kotlin 协程在安卓开发中的应用实践，以及通过合理设计和使用协程来优化应用性能的策略。
mrq4nk6ni2neg
62 8
肥猪肥猪-17824
|
6月前
|
移动开发 数据库 Android开发
构建高效Android应用：探究Kotlin的协程优势
【5月更文挑战第22天】随着移动开发技术的不断进步，Android平台的性能优化已经成为开发者关注的焦点。在众多提升应用性能的手段中，Kotlin语言提供的协程概念因其轻量级线程管理和异步编程能力而受到广泛关注。本文将深入探讨Kotlin协程在Android开发中的应用，以及它如何帮助开发者构建出更高效、响应更快的应用，同时保持代码的简洁性和可读性。
肥猪肥猪-17824
46 2
历年考试不作弊
|
6月前
|
移动开发 Android开发 开发者
构建高效安卓应用：Kotlin 协程的实践指南
【5月更文挑战第18天】 随着移动开发技术的不断进步，安卓平台亟需一种高效的异步编程解决方案来应对日益复杂的应用需求。Kotlin 协程作为一种新兴的轻量级线程管理机制，以其简洁的语法和强大的功能，成为解决这一问题的关键。本文将深入探讨Kotlin协程在安卓开发中的实际应用，从基本概念到高级技巧，为开发者提供一份全面的实践指南，旨在帮助读者构建更加高效、稳定的安卓应用。
历年考试不作弊
44 3
君子世无双~
|
6月前
|
移动开发 安全 Android开发
构建高效Android应用：Kotlin与协程的完美结合
【5月更文挑战第17天】 在移动开发领域，性能优化和流畅的用户体验是关键。对于Android平台而言，Kotlin语言凭借其简洁性和功能安全性成为开发的首选。与此同时，协程作为一种新的并发处理方式，在简化异步编程方面展现出巨大潜力。本文将深入探讨如何通过Kotlin语言以及协程技术，提升Android应用的性能和响应能力，并确保用户界面的流畅性。
君子世无双~
36 1
请看我回答~
|
6月前
|
移动开发 数据库 Android开发
构建高效Android应用：Kotlin与协程的完美结合
【5月更文挑战第7天】 在移动开发领域，性能优化和资源管理始终是核心议题。随着Kotlin语言的普及，其提供的协程特性为Android开发者带来了异步编程的新范式。本文将深入探讨如何通过Kotlin协程来优化Android应用的性能，实现流畅的用户体验，并减少资源消耗。我们将分析协程的核心概念，并通过实际案例演示其在Android开发中的应用场景和优势。
请看我回答~
53 4
请看我回答~
|
6月前
|
移动开发 数据处理 Android开发
构建高效Android应用：Kotlin的协程与Flow的使用
【5月更文挑战第23天】 在移动开发领域，性能优化和异步编程一直是核心议题。随着Kotlin语言在Android开发中的普及，其提供的协程(coroutines)和流式编程(Flow)功能为开发者带来了革命性的工具，以更简洁、高效的方式处理异步任务和数据流。本文将深入探讨Kotlin协程和Flow在Android应用中的实际应用，以及它们如何帮助开发者编写更加响应迅速且不阻塞用户界面的应用程序。我们将通过具体案例分析这两种技术的优势，并展示如何在现有项目中实现这些功能。
请看我回答~
87 0