异步编程四：协程

书接上回，我们一起体验了reactor模式，也了解到了其解决什么场景下的问题。
我们将一同感受一下协程的魅力，基于本系列文章最开始的例子 a + ((b -c）+ d) -e -f + g, 本文将使用协程的方式来实现，并与之前的实现方式进行对比。

Kotlin协程解决方案

本节依然基于vertx，同时利用kotlin的协程，来实现 a + ((b -c）+ d) -e -f + g 。
需要读者对vertx和kotlin有一定了解，准备工作可以阅读 [vertx-lang-kotlin-coroutines] (https://vertx.io/docs/vertx-lang-kotlin-coroutines/kotlin/) 和 coroutines-guide。
下面直接贴代码，可以与之前的promise和reactor模式的代码进行对比，实现的功能是一样的。

suspend fun calc(context: RoutingContext){
    var a = context.request().getParam("a").toInt()
    var b = context.request().getParam("b").toInt()
    var c = context.request().getParam("c").toInt()
    var d = context.request().getParam("d").toInt()
    var e = context.request().getParam("e").toInt()
    var f = context.request().getParam("f").toInt()
    var g = context.request().getParam("g").toInt()

    var result = a asyncAdd ((b asyncSub c) asyncAdd d) asyncSub e asyncSub f asyncAdd g
    context.request().response().end(result.toString())
}

suspend infix fun Int.asyncAdd(input : Int) : Int {
    return calc(this, input, CalcOperator.add)
}

suspend infix fun Int.asyncSub(input : Int) : Int {
    return calc(this, input, CalcOperator.sub)
}

suspend fun calc(a: Int, b: Int, operator: CalcOperator) : Int {
    return webClient.get(7777, "pi", "/${operator.name}?a=$a&b=$b")
        .expect(ResponsePredicate.SC_OK).sendAwait().bodyAsString().toInt()

}

可以看到代码精简了许多，其中最核心的计算逻辑就在这一部分：

var result = a asyncAdd ((b asyncSub c) asyncAdd d) asyncSub e asyncSub f asyncAdd g

这是一种同步的代码书写方式，如果我们需要添加额外的业务逻辑或异常处理逻辑，就很简单：

var r1 = b asyncSub c
if(r1 < 0){
    r1 = -r1
}
var r2 = 0
try {
    r2 = a asyncAdd r1
} catch (e : Exception){
    //异常处理逻辑
}
...

这就是妥妥的大多数人最熟悉的编程方式 --- 命令式编程，if ... else ... try ... catch ...，相信刚毕业的学生也可以驾轻就熟。就解决异步执行编排问题上，相比于promise模式、reactor模式，代码在书写难度和可读性、可维护性上都有明显的优势。
(完整代码 包路径有点乱，请无视)
如果我要提升并发度，也可以利用async和await关键字来重构，我们把计算式进行数学转换为 a + b + d + g - (c + e + f), 然后把计算进行并发改造

var r1 = async { a asyncAdd b }
var r2 = async { d asyncAdd g }
var r3 = async { c asyncAdd e asyncAdd f }
var result = r1.await() asyncAdd r2.await() asyncSub r3.await()

这样 a + b, d + g, c + e + f三个动作，四次网络请求就可以并发执行，可以降低总体耗时。

golang 的协程解决方案

//a + (（b -c）+ d) -e -f + g
func sayHelloName(w http.ResponseWriter, r *http.Request){
    r.ParseForm()
    a, _ := strconv.Atoi(r.FormValue("a"))
    b, _ := strconv.Atoi(r.FormValue("b"))
    c, _ := strconv.Atoi(r.FormValue("c"))
    d, _ := strconv.Atoi(r.FormValue("d"))
    e, _ := strconv.Atoi(r.FormValue("e"))
    f, _ := strconv.Atoi(r.FormValue("f"))
    g, _ := strconv.Atoi(r.FormValue("g"))

    bSubC, err := asyncSub(b, c)
    errorHandler(err)

    aAddD, err := asyncAdd(a, d)
    errorHandler(err)

    eAddF, err := asyncAdd(e, f)
    errorHandler(err)

    bSubCAddAAddD, err := asyncAdd(bSubC, aAddD)
    errorHandler(err)

    bSubCAddAAddDSubESubF, err := asyncSub(bSubCAddAAddD, eAddF)
    errorHandler(err)

    result, err := asyncAdd(bSubCAddAAddDSubESubF, g)
    errorHandler(err)

    fmt.Fprintf(w, strconv.Itoa(result))
}

func errorHandler(err error){
    if err == nil {
        return
    }
    panic(err)
}

func Start(){
    http.HandleFunc("/", sayHelloName)
    err := http.ListenAndServe(":9090", nil)
    if err != nil{
        log.Fatal("ListenAndServe: ", err)
    }
}

func asyncAdd(a, b int) (int, error) {
    return asyncCalc(a, b, "add")
}

func asyncSub(a, b int) (int, error) {
    return asyncCalc(a, b, "sub")
}

func asyncCalc(a, b int, operator string) (int, error) {
    url := fmt.Sprintf("http://pi:7777/%s?a=%d&b=%d", operator, a, b)
    r, err := doHttpGet(url)
    if err != nil {
        return 0, err
    }
    result, _ := strconv.Atoi(*r)
    return result, nil
}

func doHttpGet(url string) (responseBody *string, err error){
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    content, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    result := string(content)
    return &result, nil
}

可以看到基于golang的协程，一样是同步的方式；不过“得益”于golang的独树一帜的异常处理机制，代码写起来没有链式的那么好看。

总结

协程最关键的优点是吧代码的执行和操作系统线程进行了解耦，代码阻塞但线程不阻塞。可以让开发人员以同步的方式写异步的代码。真是异步编程的大杀器。

系列文章快速导航：
异步编程一：异步编程的魅力
异步编程二：promise模式
异步编程三：reactor模式
异步编程四：协程