异步编程四:协程

书接上回,我们一起体验了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模式,代码在书写难度和可读性、可维护性上都有明显的优势。

( 完整代码 包路径有点乱,请无视)

如果我要提升并发度,也可以利用 asyncawait 关键字来重构,我们把计算式进行数学转换为 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的独树一帜的异常处理机制,代码写起来没有链式的那么好看。

总结

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

我来评几句
登录后评论

已发表评论数()

相关站点

热门文章