书接上回，我们一起体验了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的独树一帜的异常处理机制，代码写起来没有链式的那么好看。
总结
协程最关键的优点是吧代码的执行和操作系统线程进行了解耦，代码阻塞但线程不阻塞。可以让开发人员以同步的方式写异步的代码。真是异步编程的大杀器。
有疑问加站长微信联系（非本文作者）
