Kotlin 的Coroutine

前面说过传统web框架Tomcat采用的多线程方式，当请求接入服务器时，Tomcat会为每个请求链接分配一个线程。当请求不是很多的时候，系统不会出现问题，请求数目超过最大分配线程数，这个时候会有多个线程阻塞住，会出现一些问题。

多线程在执行的时候，知识看上去是同时执行，因为线程执行是通过cpu来进行调度的，cpu通过在每个线程之间来回切换，使其看上去是同时执行的一样。其实cpu在某个时间片内只能执行一个线程，当这个线程执行一会它就会去执行其他线程。当cpu从一个线程切换到另一个线程时候会执行如下操作：

• 保存当前执行线程的执行上下文
• 载入另一个线程的执行上下文

协程是一个无优先级的调度组件，允许子程序在特定地方挂起恢复。
线程包含于进程，协程包含于线程。
只要内存够用，一个线程中可以有任意多个协程，但某一时刻只能由一个协程运行，多个协程该线程分配到的计算机资源。

fun main(args: Array<String>) {
    GlobalScope.launch { // 在后台启动一个协程
        delay(1000L) // 延迟一秒(非阻塞)
        println("World!") // 延迟之后输出
    }
    println("Hello,") // 协程被延迟了一秒，但是主线程继续执行
    Thread.sleep(2000L) // 为了使JVM保活，阻塞主线程2秒钟(这段代码删掉会出现什么情况？？？)
}

launch 构造了一个协程，该协程内部调用了delay方法，该方法会挂起协程，但是不会阻塞线程，所以在协程推迟1s的时间，线程中的“Hello”会先输出，然后“World！”才会输出

协程的切换可以通过程序自己控制，是工作在线程之上的，不需要操作系统调度，理论上降低了开销。

1. launch 与 runBlocking

上面的例子只是为了说明线程和协程理论的相似处，存在不合理的地方。我们既使用了delay方法，又使用了sleep方法。

• delay 只能在协程中使用，用于挂起协程，不会阻塞线程。
• sleep 用来阻塞线程

fun main(args: Array<String>) = runBlocking{
    launch { // 在后台启动一个协程
        delay(1000L) // 延迟一秒(非阻塞)
        println("World!") // 延迟之后输出
    }
    println("Hello,") // 协程被延迟了一秒，但是主线程继续执行
    Thread.sleep(2000L) // 为了使JVM保活，阻塞主线程2秒钟(这段代码删掉会出现什么情况？？？)
}

这个例子和上面的基本没有变化，结果也一样，我们看到两个函数
launch和runBlocking 这两个函数都会启动一个协程，不同的是runBlocking启动一个主协程，launch启动的协程能在runBlocking中运行（反过来不行）。runBlocking 方法仍旧会阻塞当前执行的线程。

2. 协程的生命周期与join

delay和sleep都是延迟执行，目的都是保活程序。
但是我们执行IO操作的时候并不知道操作执行多久，没法设定一个时间让程序保活，为了让协程执行完毕前一直保活，我们可以使用join

fun main(args: Array<String>) = runBlocking {
    val job = launch {
        search()
    }
    println("Hello,")
    job.join()
}

suspend fun search() {
    delay(1000L)
    println("World!")
}

出现了一个新的关键词suspend。用suspend的方法，和其他方法没有大的区别，不同的是suspend方法内部还可以调用其他suspend修饰的方法，只能在协程内部或其他suspend方法中执行，普通方法则不行。delay就是一个suspend修饰的方法。

fun main(args: Array<String>) = runBlocking<Unit> {
    val one = searchItemlOne()
    val two = searchItemTwo()
    println("The items is ${one} and ${two}")
}

fun main(args: Array<String>) = runBlocking<Unit> {
    val one = async { searchItemlOne() }
    val two = async { searchItemTwo() }
    println("The items is ${one.await()} and ${two.await()}")
}

再看下上面的例子，执行结果是一样的，第一个在协程内部执行是顺序的，类似java中的同步，限执行searchItemlOne在执行searchItemTwo。为了让两个方法并行执行，使用Kotlin中的async与await。async类似前面的launch都是创建了一个子协程，不同的是async有返回值，返回Deferred对象。

Deferred 是一个非阻塞可以取消的future，是一个带有结果的job
launch 也会返回一个job对象，但是没有返回值

我们还用到了await，future是非阻塞，意思将来会有一个结果返回。await可以等待这个值查询到后，将它获取出来。

fun main() = runBlocking{
    val time = measureTimeMillis {
        val one = searchItemlOne()
        val two = searchItemTwo()
        println("The items is ${one} and ${two}")
    }
    println("Cost time is ${time} ms")
}

The items is item-one and item-two
Cost time is 2034 ms

再看并行

fun main(args: Array<String>) = runBlocking{
    val time = measureTimeMillis {
        val one = async { searchItemlOne() }
        val two = async { searchItemTwo() }
        println("The items is ${one.await()} and ${two.await()}")
    }

    println("Cost time is ${time} ms")
}

The items is item-one and item-two
Cost time is 1170 ms

从理论代码看不出差别，但是从时间打印来看，并行效果就明显了。