AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

go web压测工具实现

2018-10-19 2985
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
文档翻译，文档翻译 1千页
文本翻译，文本翻译 100万字符
性能测试 PTS，5000VUM额度
简介： 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，欢迎修改完善

文章标签：
性能测试
机器翻译
Go
测试技术
网络协议
数据格式
JSON
关键词：
web工具
Go Web
Go工具
web go
web压测
相关实践学习
通过性能测试PTS对云服务器ECS进行规格选择与性能压测
本文为您介绍如何利用性能测试PTS对云服务器ECS进行规格选择与性能压测。
laijh_go
目录
相关文章
修己xj
|
3天前
|
人工智能 前端开发 计算机视觉
Inpaint-Web：纯浏览器端实现的开源图像处理工具
在刷短视频时，常看到情侣在景区拍照被路人“抢镜”，男朋友用手机将路人“P”掉，既贴心又有趣。最近我发现了一个纯前端实现的开源项目——inpaint-web，可在浏览器端删除照片中的部分内容，非常酷。该项目基于 WebGPU 和 WASM 技术，支持图像修复与放大，已在 GitHub 上获得 5.1k Star。项目地址：[GitHub](https://github.com/lxfater/inpaint-web)。
修己xj
40 3
Inpaint-Web：纯浏览器端实现的开源图像处理工具
听风de歌
|
10天前
|
缓存 前端开发 中间件
go语言中Web框架
【10月更文挑战第22天】
听风de歌
18 4
爱的不是纯牛奶-47754
|
17天前
|
前端开发 JavaScript 开发者
构建响应式设计的现代Web应用：实用技巧与工具
【10月更文挑战第24天】本文介绍了构建响应式Web应用的实用技巧和工具，涵盖流体网格布局、弹性图片、CSS媒体查询、CSS Grid和Flexbox、响应式导航菜单、图片和字体的响应式处理，以及测试和调试工具。掌握这些技能将帮助开发者提升用户体验和项目适应性。
爱的不是纯牛奶-47754
32 2
听风de歌
|
17天前
|
JSON 监控 安全
go语言选择合适的工具和库
【10月更文挑战第17天】
听风de歌
11 2
二二*一一
|
17天前
|
移动开发 数据可视化 前端开发
可视化设计web界面的工具
有什么可视化设计web界面的工具
二二*一一
30 0
有路有乔-六月
|
1月前
|
缓存 前端开发 JavaScript
深入了解Webpack：现代Web开发的核心工具
【10月更文挑战第11天】深入了解Webpack：现代Web开发的核心工具
有路有乔-六月
15 0
跃@sir
|
1月前
|
JavaScript 前端开发 API
深入了解jQuery：简化Web开发的强大工具
【10月更文挑战第11天】深入了解jQuery：简化Web开发的强大工具
跃@sir
11 0
sunrr
|
2月前
|
机器学习/深度学习 算法 开发工具
Python Web开发工具
Python Web开发工具
sunrr
34 3
Codelinghu
|
1月前
|
开发框架 .NET 开发工具
visualstudio如何加入工作插件---Web developer工具
visualstudio如何加入工作插件---Web developer工具
Codelinghu
21 0
GG2020gg
|
2月前
|
安全 前端开发 JavaScript
Web安全-网页开发者工具
Web安全-网页开发者工具
GG2020gg
45 7

热门文章

最新文章

  • 1
    golang开发:类库篇(四)配置文件解析器goconfig的使用
  • 2
    基于类型系统的面向对象编程语言Go
  • 3
    go8---函数function
  • 4
    Swoole与Go系列教程之TCP服务的应用
  • 5
    Go学习笔记-代码调试工具 dlv
  • 6
    Grumpy：Google 用 Go 开发的 Python 运行时
  • 7
    Go——小白学习之接口
  • 8
    Go语言之函数详解
  • 9
    Serverless时代Rust即将称王，详解C、Java、Go、Rust高并发背后的技术？
  • 10
    Go语言之反射
  • 1
    从零到精通，AJAX与Fetch API让你的Python Web前后端交互无所不能！
    39
  • 2
    颠覆传统！AJAX、Fetch API与Python后端，开启Web开发新篇章！
    37
  • 3
    从零到一，Django/Flask带你走进Web开发的梦幻世界！
    51
  • 4
    Django/Flask不只是框架，它们是你Web开发路上的超级英雄！
    33
  • 5
    `roslibpy`是一个Python库，它允许非ROS（Robot Operating System）环境（如Web浏览器、移动应用等）与ROS环境进行交互。通过使用`roslibpy`，开发者可以编写Python代码来远程控制ROS节点，发布和订阅话题，以及调用服务。
    305
  • 6
    我们将使用Python的内置库`http.server`来创建一个简单的Web服务器。虽然这个示例相对简单，但我们可以围绕它展开许多讨论，包括HTTP协议、网络编程、异常处理、多线程等。
    80
  • 7
    Python Web开发者必看！AJAX、Fetch API实战技巧，让前后端交互如丝般顺滑！
    61
  • 8
    惊艳全场的秘诀！AJAX、Fetch API与Python后端，打造令人惊叹的Web应用！
    69
  • 9
    深度剖析Django/Flask：解锁Web开发新姿势，让创意无限延伸！
    39
  • 10
    逆袭之路！Django/Flask助你成为Web开发界的璀璨新星！
    50

    • 相关课程

    更多
  • Java Web开发系列课程 - Spring框架入门
  • Go语言完全自学手册图文教程
  • 企业Web常用架构LAMP-LNMP实战
  • 高校精品课-西安交通大学-Web 编程技术
  • Java Web项目实战 - 图书商城
  • Java面试疑难点解析 - Java Web开发

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 搭建Java Web开发环境
  • Internet Information Services（IIS）部署Web项目
  • 云上Web及FTP
  • WEB网页编程实战
  • 网站用户流量分析—适用于电商网站、资讯网站、游戏主站等各类Web站点场景
    • 下一篇
    阿里云OSS设置跨域访问