Kotlin 协程真的比 Java 线程更高效吗？

我们需要注意的是：对于开发者而言，并不关心实现并发任务的到底是线程还是进程还是协程或者是什么其他。我们只关心提交的并发任务是否可以完成。

来看一下这段极简的Java代码。

package com.wuyue;
  
public class JavaCode {
    public static void main(String[] args) {
  
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("iqoo" + "  " + Thread.currentThread().getName());
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("x27" + "  " + Thread.currentThread().getName());
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
  
    }
}

（滑动可查看）

package main
  
  
import (
    "fmt"
    "runtime"
    "strconv"
    "time"
  
    "golang.org/x/sys/windows"
)
  
func name(s string) {
    for {
        //为了演示起来方便 我们每个协程都是相隔一秒才打印，否则命令行中刷起来太快，不好看执行过程
        time.Sleep(time.Second)
        str := fmt.Sprint(windows.GetCurrentThreadId())
        var s = "iqoo" + s + " belong thread " + str
        fmt.Println(s)
  
    }
}
  
func main() {
    //逻辑cpu数量为4，代表我这个go程序 有4个p可以使用。每个p都会被分配一个系统线程。
    //这里因为我电脑的cpu是i5 4核心的，所以这里返回的是4. 如果你的机器是i7 四核心的，那这里返回值就是8了
    //因为intel的i7 cpu 有超线程技术，简单来说就是一个cpu核心 可以同时运行2个线程。
    fmt.Println("逻辑cpu数量:" + strconv.Itoa(runtime.NumCPU()))
    str := fmt.Sprint(windows.GetCurrentThreadId())
    fmt.Println("主协程所属线程id =" + str)
    //既然在我机器上golang默认是4个逻辑线程，那我就将同步任务扩大到10个，看看执行结果
    for i := 1; i <= 10; i++ {
        go name(strconv.Itoa(i))
    }
    // 避免程序过快直接结束
    time.Sleep(100 * time.Second)
  
}

（滑动可查看 ）

那同样的需求，用Kotlin-JVM可以来完成吗？答案是不可以。简单来说，如果Kotlin-JVM 能提供Go类似的协程能力，那应该能完成如下的需求（但实际上使用Kotlin语言是无法完成下面的需求的）：

1. N个并发任务分别打印不同的字符串。就跟上述Go和Java的例子一样。

2. 在打印的时候需要打印出所属的线程id或者线程name，且这id和name要保证一样。因为只有一样 才可以证明是在一个线程上完成了并发任务，而不是靠JVM的Thread来完成并发任务。

我们都知道任何一门现代语言都对外提供了一定的并发能力，且一般都在语言层面提供了“锁”的实现。比如开启10个线程 对一个int变量 进行++操作，要保证打印出来的顺序一定得是1,2,3,4...10. 这样的Java代码很好写，一个synchronized关键字就可以，我们看看Go中的协程是否有类似的能力？

package main
  
  
import (
    "fmt"
    "strconv"
    "sync"
    "time"
  
    "golang.org/x/sys/windows"
)
  
var Mutex sync.Mutex
  
var i = 0
  
func name(s string) {
    Mutex.Lock()
    str := fmt.Sprint(windows.GetCurrentThreadId())
    fmt.Println("i==" + strconv.Itoa(i) + "  belong thread id " + str)
    i++
    defer Mutex.Unlock()
  
}
  
func main() {
    for i := 1; i <= 10; i++ {
        go name(strconv.Itoa(i))
    }
    // 避免程序过快直接结束
    time.Sleep(100 * time.Second)
  
}

（滑动可查看 ）

这里要提一下的是，很多人都以为Kotlin是谷歌出的，是谷歌的亲儿子，实际上这是一种错误的想法。Kotlin是JB Team的产物，并不是谷歌亲自操刀开发的，最多算是个谷歌的干儿子。这个 JB Team 很多人应该知道，是IDEA的开发团队Android Studio也是脱胎自 IDEA。  

关于这个讨论，JB Team的意思是说 Kotlin 在自己的语言级别并没有实现一种同步机制，还是依靠的 Kotlin-JVM中的 Java关键字。尤其是synchronized。既然并发的机制都是依靠的JVM中的sync或者是lock来保证，为何称之为自己是协程的？

我们知道在主流JVM的实现中，是没有协程的，实际上JVM也不知道上层的JVM语言到底是啥，反正JVM只认class文件，至于这个class文件是Java编译出来的，还是Kotlin编译出来的，或是如groovy等其他语言，那都不重要，JVM不需要知道。

基于这个讨论 我们可以确定的是，Kotlin语言没有提供锁的关键字，所有的锁实现都交给了JVM自己处理。其实就是交给线程来处理了。也就是说，虽然 Kotlin-JVM 声称自己是协程，但实际上干活的还是JVM中Thread那一套东西。

写一个简单的代码验证一下，简单写一个Kotlin的类，因为Kotlin本身没有提供同步的关键字，所以这里就用Kotlin官方提供的sync注解。

class PrintTest {
    @Synchronized fun print(){
        println("hello world")
    }
  
    @Synchronized fun print2(){
        println("hello world")
    }
}

（滑动可查看）

那么既然证明了，Kotlin-JVM中的协程并不是真协程，那么这个东西到底是什么，应该怎么用？

个人理解Kotlin-JVM的线程应该就仅仅是针对Java中的Thread做了一次更友好的封装。让我们更方便的使用Java中的线程才是Kotlin-JVM中的协程的真正目的。

本质上和Handler，AsyncTask，RxJava 基本是一致的。只不过Kotlin中的协程比他们更方便一些。这其中最核心的是suspend这个Kotlin协程中的关键字。

class MainActivity : AppCompatActivity() {
  
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        GlobalScope.launch(Dispatchers.Main) {
            getInfo()
            getInfoNoContext()
            Log.v("wuyue", "我又切回来了 in thread " + Thread.currentThread().name)
        }
    }
  
    /**
     * 挂起就是切换线程 没其他作用，最多就是切到其他线程以后还可以自动切回来，避免过多的callback
     * 所有被suspend标记的函数 要么在协程里被调用，要么在其他挂起函数里被调用，否则就无法实现
     * 切走以后又可以切回来的效果
     */
    suspend fun getInfo() {
        /**
         * withContext挂起函数 内部实现了挂起的流程，suspend其实并没有这个功能
         * kotlin中有很多挂起函数，withContext 应该是最常用的
         */
        withContext(Dispatchers.IO) {
            Log.v("wuyue", "getInfo in thread " + Thread.currentThread().name)
        }
    }
  
    /**
     * 这个函数 虽然用suspend标记 但是并没有 用withContext 指定挂起，
     * 所以是没办法实现切线程的作用的，自然而然也就无法实现 所谓的挂起了
     * 个人理解这个suspend关键字的作用就是提醒 调用者注意 你如果调用的是一个被suspend标记的函数
     * 那么一定要注意 这个函数可能是一个后台任务，是一个耗时的操作，你需要在一个协程里使用他。
     * 如果不在协程里使用，那么kotlin的编译 就会直接报错了。
     *
     *
     * 这点其实对于android来讲还是很有用的，你所有认为耗时的操作都可以用suspend来标记，然后在内部指定
     * 这个协程的thread 为 io thread， 如果调用者没有用launch来 call 这个方法，那么编译就报错。
     * 自然而然就避免了很多 主线程操作io的问题
     *
     */
    suspend fun getInfoNoContext() {
        Log.v("wuyue", "getInfoNoContext in thread " + Thread.currentThread().name)
    }
  
}

（滑动可查看）

这段代码很简单，可以多看一下注释。很多人都会被所谓Kotlin协程的 非阻塞式 吓到，其实你就理解成Kotlin中所宣传的非阻塞式，无非是用阻塞的写法来完成非阻塞的任务而已。

试想一下，我们上述Kotlin中的代码 如果用Thread来写，就会比较麻烦了，甚至还需要用到回调（如果你不用handler的话）。这一点上Kotlin 协程的作用和RxJava其实是一致的，只不过Kotlin做的更彻底，比RxJava更优雅更方便更简洁。

考虑一种稍微复杂的场景，某个页面需要2个接口都返回以后才能刷新展示，此种需求，如果用原生的Java concurrent并发包是可以做的，但是比较麻烦，要考虑各种异常带来的问题。

比较好的实现方式是用RxJava的zip操作符来做，在有了Kotlin以后，如果利用Kotlin，这段代码甚至会比zip操作符还要简单。例如：

class MainActivity : AppCompatActivity() {
  
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        GlobalScope.launch(Dispatchers.Main) {
            Log.v("wuyue", "time 1==" + System.currentTimeMillis())
            val sum = withContext(Dispatchers.IO) {
                val requestA = async { requestA() }
                val requestB = async { requestB() }
                requestA.await() +"_____" +requestB.await()
            }
            Log.v("wuyue", "time 2==" + System.currentTimeMillis() + " get sum=" + sum)
        }
    }
  
    /**
     * 3s以后 才拿到请求结果 IQOO
     */
    fun requestA(): String {
        sleep(3 * 1000)
        Log.v("wuyue", "requestA in " + Thread.currentThread().name)
        return "IQOO"
    }
  
    /**
     * 5秒以后拿到请求结果 B
     */
    fun requestB(): String {
        sleep(5 * 1000)
        Log.v("wuyue", "requestB in " + Thread.currentThread().name)
        return "X27"
    }
  
}

（滑动可查看）

最后对本文做一个总结：

1. Kotlin-JVM中所谓的协程是假协程，本质上还是一套基于原生Java Thread API 的封装。和Go中的协程完全不是一个东西，不要混淆,更谈不上什么性能更好。

2. Kotlin-JVM中所谓的协程挂起，就是开启了一个子线程去执行任务（不会阻塞原先Thread的执行，要理解对于CPU来说，在宏观上每个线程得到执行的概率都是相等的），仅此而已，没有什么其他高深的东西。

3. Kotlin-Native是有机会实现完整真协程方案的。虽然我个人不认为JB TEAM 在这方面能比Go做的更好，所以这个项目意义并不是很大。

4. Kotlin-JVM中的协程最大的价值是写起来比RxJava的线程切换还要方便。几乎就是用阻塞的写法来完成非阻塞的任务。

5. 对于Java来说，不管你用什么方法，只要你没有魔改JVM，那么最终你代码里start几个线程，操作系统就会创建几个线程，是1比1的关系。

6. OpenJDK正在做JVM的协程实现，项目名称为loom，有兴趣的同学可以查看对应资料。

7. Kotlin官网中那个创建10w个Kotlin协程没有oom的例子其实有误导性，本质上那10w个Kotlin协程就是10w个并发任务仅此而已，他下面运行的就是一个单线程的线程池。你往一个线程池里面丢多少个任务都不会OOM的（前提是你的线程池创建的时候设定了对应的拒绝策略，否则无界队列下，任务过多一定会OOM），因为在运行的始终是那几个线程。

vivo移动互联网是基于vivo 智能手机所建立的完整移动互联网生态圈，围绕vivo大数据运营，打造包括应用、游戏、资讯、品牌、电商、内容、金融、搜索的全方位服务生态，满足海量用户的多样化需求。