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