前言

• 前一篇文已经简单讲解怎么通过goroutines的能力编写并发http压测脚本，但前文有提到过，主线程为了等待goroutine都运行完毕，不得不在程序的末尾使用time.Sleep() 来睡眠一段时间，等待其他线程充分运行。对于简单的代码，100个for循环可以在1秒之内运行完毕，time.Sleep() 也可以达到想要的效果，但是对于大多数真实业务和工作场景来说，1秒肯定会不够的，并且大部分时候我们都无法预知for循环内代码运行时间的长短。这时候就不能使用time.Sleep() 来完成等待操作了，这里我们就可以使用golang的一个类似于计数器的组件sync.WaitGroup

sync.WaitGroup模块

• WaitGroup 对象内部有一个计数器，最初从0开始，它有三个方法：Add(), Done(), Wait() 用来控制计数器的数量。Add(n) 把计数器设置为n ，Done() 每次把计数器-1 ，wait() 会阻塞代码的运行，直到计数器地值减为0，结合goroutines使用

import (
    "fmt"
    "sync"
)


func main() {
    wg := sync.WaitGroup{}
    wg.Add(20)
    for i := 0; i < 20; i++ {
        go func(i int) {
            fmt.Println(i)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

可以执行查看一些输出

go run synctest.go
1
5
2
3
4
7
6
19
15
0
10
14
18
16
12
8
11
13
17
9

• 这里首先把wg 计数设置为20， 每个for循环运行完毕都把计数器减一，主函数中使用Wait() 一直阻塞，直到wg为0,也就是所有的20个for循环都运行完毕，WaitGroup 通过计数器的方式很好地控制了gorountines和主线程的执行关系

sync.WaitGroup模块编写场景化的压测脚本

• 有了sync.WaitGroup提供的能力，我们可以更好的基于一些场景去编写压测脚本
• 有这样子的一个服务器

#! /usr/bin/env 
#coding=utf-8
import socket
import json
import requests

from flask import Flask, request,jsonify,g

app = Flask(__name__)

filename='demo.txt'

@app.route('/apisetdata', methods=['POST'])
def setdata():
        msg=request.json["msg"]
        print(msg)
        with open(filename, 'w') as f:
            f.write(str(msg))
            f.close()

        resp=jsonify({"code":200,"state":"set msg ok","msg":msg})
        resp.status_code=200
        return resp


@app.route('/apigetdata', methods=['GET'])
def getdata():
        f = open(filename, 'r')
        msg=f.read()
        resp=jsonify({"code":200,"state":"get msg ok","msg":msg})
        resp.status_code=200
        return resp


if __name__ == "__main__":
    app.run(debug=True)

• msg保存着demo.txt的内容，通过apigetdata接口可以获取内容，通过apisetdata接口可以修改demo.txt的内容，我们现在需要对修改demo.txt的内容后查询这个场景进行压测，这样我们就可以获得这样的压测脚本

package main

import (
    "fmt"
    "net/http"
    "sync"
    "time"
    "bytes"
    "encoding/json"
    "io/ioutil"
    simplejson "github.com/bitly/go-simplejson"
)


var (
    success = 0
    failure = 0
    useTime = 0.0 //记录请求成功失败数和使用时间
)

var (
    num =100 //要发送的请求数
    con =100 //并发数
)

type HttpData struct {

    Msg string `json:"msg"`

}

var wg sync.WaitGroup //创建一个计数器



func dotest(num int) { //场景化请求方法，在里面可以自定义需要编辑的内容

    defer wg.Done() //进入到方法后计算器-1，标记创建了一个goroutine

    no := 0
    ok := 0
    url := "http://127.0.0.1:5000/apisetdata"
    url2:= "http://127.0.0.1:5000/apigetdata"
    contentType := "application/json;charset=utf-8"

    var httpdata HttpData
    httpdata.Msg = "terrychow"

    
    b ,err := json.Marshal(httpdata)
    if err != nil {
        fmt.Println("json format error:", err)
        return
    }

    body := bytes.NewBuffer(b)

    for i := 0; i < num; i++ {

        //修改内容部分
        resp, err := http.Post(url, contentType, body) //通过apisetdata接口修改内容

        if err != nil {
            no += 1
            fmt.Println("error failed:", err)
            continue 
        }

        defer resp.Body.Close()

        //读取内容部分
        resp2, err := http.Get(url2) //通过apigetdata接口获取内容
        if err != nil {
            no += 1
            fmt.Println("error failed:", err)
            continue 
        }

        defer resp2.Body.Close()
        body, err := ioutil.ReadAll(resp2.Body)
        res, err := simplejson.NewJson([]byte(string(body)))

        getmsg, err := res.Get("msg").String()


        if resp.StatusCode != 200 {
            no += 1
            continue
        }

        if getmsg!=httpdata.Msg{ //断言修改的内容
            no += 1
            continue        
        }

        ok += 1
        continue
    }

    success += ok
    failure += no

}       

// 主函数
func main() {
    startTime := time.Now().UnixNano()

    // 并发开始
    for i := 0; i < con; i++ {
        wg.Add(1)
        go dotest(num/con)
    }
    // fmt.Println("主程序开始wait")
    wg.Wait()
    endTime := time.Now().UnixNano()
    useTime = float64(endTime-startTime) / 1e9
    // 输出结果
    fmt.Println()
    fmt.Println("Complete requests:", success)
    fmt.Println("Failed requests:", failure)
    // fmt.Println("SuccessRate:", fmt.Sprintf("%.2f", ((success/total)*100.0)), "%")
    fmt.Println("UseTime:", fmt.Sprintf("%.4f", useTime), "s")
    fmt.Println("场景每秒处理数 sps:", fmt.Sprintf("%.4f", float64(num)/useTime))
    fmt.Println("请求每秒处理数 qps:", fmt.Sprintf("%.4f", float64(num*2)/useTime))

}

• 执行一下查看效果

go run pertestgo.go
Complete requests: 100
Failed requests: 0
UseTime: 0.1738 s
场景每秒处理数 sps: 575.4601
请求每秒处理数 qps: 1150.9202

• 这里的压测脚本主要强调场景，像ab等压测工具，很多时候都是只有单接口的并发，对于复杂接口和做一些自定义断言的时候，就相对比较复杂，类似python的locust就是按照场景化写压测脚本的方式实现，这里也是运用了同样的思想

小结

• 希望本文对于同学们在使用golang进行压测的时候能够起到作用，接下来的文章还会讲述几个golang的压测工具和其他测试工具等，敬请期待