go web压测工具实现

这篇Go实现单机压测工具博客分以下几个模块进行讲解，为了更加清楚的知道一个分布式Web压测实现，我们从单机单用户 -> 单机多用户 -> 分布式逐步实现。
（1）什么是web压力测试？
（2）压力测试中几个重要指标
（3）Go语言实现单机单用户压测
（4）GO语言实现单机多用户压测
（5）Go语言实现分布式压测
（6）相关参考资料

一、什么是web压力测试？
简单的说是测试一个web网站能够支撑多大的请求（也就是web网站的最大并发）
二、压力测试的几个重要指标
1）指标有哪些？
2）指标含义详解
https://blog.csdn.net/adparking/article/details/45673315

三、单机单用户压测Go实现
1）要知道的几个概念
并发连接数：
理解：并发连接数不等于并发数，真实的并发数只能在服务器中计算出来，这边的并发数等于处在从请求发出去，到收到服务器信息的这状态的个数总和。
总请求次数
响应时间
平均响应时间
成功次数
失败次数

2）代码实现

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "strconv"
    "sync"
    "time"
)

var (
    SBCNum     int           // 并发连接数
    QPSNum     int           // 总请求次数
    RTNum      time.Duration // 响应时间
    RTTNum     time.Duration // 平均响应时间
    SuccessNum int           // 成功次数
    FailNum    int           // 失败次数

    BeginTime time.Time // 开始时间
    SecNum    int       // 秒数

    RQNum int    // 最大并发数，由命令行传入
    Url   string // url，由命令行传入

    controlNum chan int // 控制并发数量
)

var mu sync.Mutex // 必须加锁

func init() {
    if len(os.Args) != 3 {
        log.Fatal("请求次数 url")
    }
    RQNum, _ = strconv.Atoi(os.Args[1])
    controlNum = make(chan int, RQNum)
    Url = os.Args[2]
}

func main() {
    go func() {
        for range time.Tick(1 * time.Second) {
            SecNum++
            fmt.Printf("并发数：%d,请求次数：%d,平均响应时间：%s,成功次数：%d,失败次数：%d\n",
                len(controlNum), SuccessNum+FailNum, RTNum/(time.Duration(SecNum)*time.Second), SuccessNum, FailNum)
        }
    }()
    requite()
}

func requite() {
    for {
        controlNum <- 1
        go func(c chan int) {
            var tb time.Time
            var el time.Duration
            for {
                tb = time.Now()
                _, err := http.Get(Url)
                if err == nil {
                    el = time.Since(tb)
                    mu.Lock() // 上锁
                    SuccessNum++
                    RTNum += el
                    mu.Unlock() // 解锁
                } else {
                    mu.Lock() // 上锁
                    FailNum++
                    mu.Unlock() // 解锁
                }
                time.Sleep(1 * time.Second)
            }
            <- c
        }(controlNum)
        time.Sleep(45 * time.Millisecond)
    }
}

四、单机多用户压测Go实现

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "strconv"
    "sync"
    "time"
)

var (
    BeginTime time.Time // 开始时间
    SecNum    int       // 秒数

    RQNum int    // 最大并发数，由命令行传入
    Url   string // url，由命令行传入

    userNum    int      // 用户数
)

var users []User

type User struct {
    UserId         int             // 用户id
    SBCNum     int           // 并发连接数
    QPSNum     int           // 总请求次数
    RTNum      time.Duration // 响应时间
    RTTNum     time.Duration // 平均响应时间
    SuccessNum int           // 成功次数
    FailNum    int           // 失败次数
    mu         sync.Mutex
}

func (u *User) request(url string) {
    var tb time.Time
    var el time.Duration
    for i := 0;i < u.QPSNum;i++ {
        u.SBCNum++
        go func(u *User) {
            for {
                tb = time.Now()
                _, err := http.Get(Url)
                if err == nil {
                    el = time.Since(tb)
                    u.mu.Lock() // 上锁
                    u.SuccessNum++
                    u.RTNum += el
                    u.mu.Unlock() // 解锁
                } else {
                    u.mu.Lock() // 上锁
                    u.FailNum++
                    u.mu.Unlock() // 解锁
                }
                time.Sleep(1 * time.Second)
            }
        }(u)
    }
}

func (u *User) show() {
    fmt.Printf("用户id：%d,并发数：%d,请求次数：%d,平均响应时间：%s,成功次数：%d,失败次数：%d\n",
        u.UserId,
        u.SBCNum,
        u.SuccessNum + u.FailNum,
        u.RTNum/(time.Duration(SecNum)*time.Second),
        u.SuccessNum,
        u.FailNum)
}

func showAll(us []User) {
    uLen := len(us)

    var SBCNum     int           // 并发连接数
    var RTNum      time.Duration // 响应时间
    var SuccessNum int           // 成功次数
    var FailNum    int           // 失败次数

    for i := 0;i < uLen;i++ {
        SBCNum += us[i].SBCNum
        SuccessNum += us[i].SuccessNum
        FailNum += us[i].FailNum
        RTNum += us[i].RTNum
        us[i].show()
    }
    fmt.Printf("并发数：%d,请求次数：%d,平均响应时间：%s,成功次数：%d,失败次数：%d\n",
        SBCNum,
        SuccessNum+FailNum,
        RTNum/(time.Duration(SecNum)*time.Second),
        SuccessNum,
        FailNum)
    fmt.Println()
}

func init() {
    if len(os.Args) != 4 {
        log.Fatal("用户数 请求次数 url")
    }
    userNum, _ = strconv.Atoi(os.Args[1])
    RQNum, _ = strconv.Atoi(os.Args[2])
    Url = os.Args[3]
    users = make([]User, userNum)
}

func main() {
    go func() {
        for range time.Tick(2 * time.Second) {
            SecNum += 2
            showAll(users)
        }
    }()
    for range time.Tick(1 * time.Second) {
        requite()
    }
}

func requite() {
    c := make(chan int)
    temp := 0
    for i := 0;i < userNum;i++ {
        if RQNum % userNum != 0 && i < RQNum % userNum {
            temp = 1
        } else {
            temp = 0
        }
        users[i].UserId = i
        users[i].QPSNum = RQNum / userNum + temp
        go users[i].request(Url)
        time.Sleep(45 * time.Millisecond)
    }
    <- c    // 阻塞
}

五、分布式压测Go
分主节点和从节点，现在分别实现以下功能
1）主节点功能
收集从节点的压测信息
显示压测信息
2）从节点功能
将压测信息发送给主节点
3）整个工作原理
一个主节点启动，设置监听端口，使用TCP方式，启动若干个从节点，每个从节点通过IP+端口连接到这个主节点，之后主节点记录连接上来的从节点信息。从节点将相关信息发往主节点，主节点在设定的时间里显示信息。
代码实现：
主节点代码实现

package main

import (
    "log"
    "net"
    "time"
    "os"
    "encoding/json"
    "fmt"
)

var ip string
var port string
var slaves []*slave

type slave struct {
    UserId string
    SBCNum     int           // 并发连接数
    QPSNum     int           // 总请求次数
    RTNum      time.Duration // 响应时间
    RTTNum     time.Duration // 响应时间
    SecNum       int             // 时间
    SuccessNum int           // 成功次数
    FailNum    int           // 失败次数
    Url string
    conn net.Conn
}

func (s *slave) Run() {
    var v interface{}
    buf := make([]byte, 1024)
    for {
        n, err := s.conn.Read(buf)
        if err != nil {
            log.Println(err)
            break
        }
        err = json.Unmarshal(buf[:n], &v)
        if err != nil {
            log.Println(err)
            continue
        }
        s.SBCNum = int(v.(map[string]interface{})["SBCNum"].(float64))    // 并发连接数
        s.RTNum = time.Duration(v.(map[string]interface{})["RTNum"].(float64))    // 响应时间
        s.SuccessNum = int(v.(map[string]interface{})["SuccessNum"].(float64))    //SuccessNum int           // 成功次数
        s.FailNum = int(v.(map[string]interface{})["FailNum"].(float64))            //FailNum    int           // 失败次数
        s.SecNum = int(v.(map[string]interface{})["SecNum"].(float64))
    }
}

func init() {
    if len(os.Args) != 3 {
        log.Fatal(os.Args[0] + " ip port")
    }
    ip = os.Args[1]
    port = os.Args[2]
}

func main() {
    s, err := net.Listen("tcp", ip + ":" + port)
    if err != nil {
        log.Fatal(err)
    }
    defer s.Close()
    buf := make([]byte, 128)
    fmt.Println("Run...")
    go func() {
        for range time.Tick(2 * time.Second) {
            show(slaves)
        }
    }()
    for {
        conn, err := s.Accept()
        if err != nil {
            log.Println(err)
            continue
        }
        n, err := conn.Read(buf)
        tempC := slave{conn:conn,UserId:conn.RemoteAddr().String(), Url:string(buf[:n])}
        go tempC.Run()
        slaves = append(slaves, &tempC)
    }
}

func show(clients []*slave) {
    if len(clients) == 0 {
        return
    }
    temp := slave{}
    num := 0
    for _, client := range clients {
        if client.SecNum == 0 {
            continue
        }
        num++
        fmt.Printf("用户id：%s,url: %s,并发数：%d,请求次数：%d,平均响应时间：%s,成功次数：%d,失败次数：%d\n",
            client.UserId,
            client.Url,
            client.SBCNum,
            client.SuccessNum + client.FailNum,
            client.RTNum / (time.Duration(client.SecNum) * time.Second),
            client.SuccessNum,
            client.FailNum)
        temp.SBCNum += client.SBCNum
        temp.RTNum += client.RTNum / (time.Duration(client.SecNum) * time.Second)
        temp.SecNum += client.SecNum
        temp.SuccessNum += client.SuccessNum
        temp.FailNum += client.FailNum
    }
    if num == 0 {
        return
    }
    fmt.Printf("并发数：%d,请求次数：%d,平均响应时间：%s,成功次数：%d,失败次数：%d\n",
        temp.SBCNum,
        temp.SuccessNum + temp.FailNum,
        temp.RTNum / time.Duration(num),
        temp.SuccessNum,
        temp.FailNum)
    fmt.Println()
}

func heartbeat(clients []slave) []slave {    // 标记耦合
    tempC := []slave{}
    for _, client := range clients {
        _, err := client.conn.Write([]byte(""))
        if err == nil {    // 删除
            tempC = append(tempC, client)
        }
    }
    return tempC
}

从节点

package main

import (
    "net"
    "github.com/lunny/log"
    "encoding/json"
    "time"
    "os"
    "net/http"
    "sync"
    "strconv"
    "fmt"
)

type master struct {
    ip string
    port string
    conn net.Conn
}

var (
    SBCNum     int           // 并发连接数
    QPSNum     int           // 总请求次数
    RTNum      time.Duration // 响应时间
    RTTNum     time.Duration // 平均响应时间
    SuccessNum int           // 成功次数
    FailNum    int           // 失败次数
    SecNum       int

    mt master
    err error
    mu sync.Mutex // 必须加锁
    RQNum int    // 最大并发数，由命令行传入
    Url   string // url，由命令行传入
)

func init() {
    if len(os.Args) != 5 {
        log.Fatalf("%s 并发数 url ip port", os.Args[0])
    }
    RQNum, err = strconv.Atoi(os.Args[1])
    if err != nil {
        log.Println(err)
    }
    Url = os.Args[2]
    mt.ip = os.Args[3]
    mt.port = os.Args[4]
}

func main() {
    mt.conn, err = net.Dial("tcp", mt.ip + ":" + mt.port)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("连接服务器成功。。。")
    _, err = mt.conn.Write([]byte(Url))
    if err != nil {
        log.Println(err)
    }
    go func() {
        for range time.Tick(1 * time.Second) {
            sendToMaster(mt, map[string]interface{}{
                "SBCNum": SBCNum,            // 并发连接数
                "RTNum": RTNum,                // 响应时间
                "SecNum": SecNum,            // 时间
                "SuccessNum": SuccessNum,    // 成功次数
                "FailNum": FailNum,            // 失败次数
            })
        }
    }()
    go func() {
        for range time.Tick(1 * time.Second) {
            SecNum++
        }
    }()
    requite(RQNum, Url)
}

func requite(RQNum int, url string) {
    c := make(chan int)
    for i := 0;i < RQNum;i++ {
        SBCNum = i + 1
        go func(url string) {
            var tb time.Time
            var el time.Duration
            for {
                tb = time.Now()
                _, err := http.Get(url)
                if err == nil {
                    el = time.Since(tb)
                    mu.Lock() // 上锁
                    SuccessNum++
                    RTNum += el
                    mu.Unlock() // 解锁
                } else {
                    mu.Lock() // 上锁
                    FailNum++
                    mu.Unlock() // 解锁
                }
                time.Sleep(1 * time.Second)
            }
        }(url)
        time.Sleep(45 * time.Millisecond)
    }
    <- c    // 阻塞
}

func sendToMaster(mt master, data map[string]interface{}) {
    r, err := json.Marshal(data)
    if err != nil {
        log.Println(err)
    }
    _, err = mt.conn.Write(r)
    if err != nil {
        log.Println(err)
        os.Exit(1)
    }
}

参考链接：
压测指标概念
（1）https://www.cnblogs.com/shijingjing07/p/6507317.html
（2）https://blog.csdn.net/adparking/article/details/45673315

github链接：https://github.com/laijinhang/WebRequest

有出错的地方，请指出，代码已上传到github，欢迎修改完善