网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go web压测工具实现

2020-06-10 04:08:14 admin 4147

这篇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，欢迎修改完善

转载文章，原文链接： go web压测工具实现

关键字词go web

分享到：

上一篇：我编了一个go语言双向 RPC 调用的库：rpc2d

下一篇：RabbitMQ报错：failed to open a channel:Exception (406) Reason: "PRECONDITION_FAILED - inequivalent a...

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go web压测工具实现

zhou 3年前

zhou 3年前

zhou 3年前

zhou 3年前

武云 3年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go web压测工具实现

zhou 3年前

zhou 3年前

zhou 3年前

zhou 3年前

武云 3年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。