前言：

测试环境：

windows10虚拟机vmware安装的centos6.9

内存2g，处理器数量2个，每个处理器核心数量2个

Go版本  go1.7.3 linux/amd64

说明：

本次测试目的：本次测试Go语言的网络服务端在处理大量并发请求时的耗用时间。

测试程序：

服务端程序：

package main

import (
    "fmt"
    "log"
    "net"
)

//开启服务程序
func startServer() {

    var i int = 0
    //服务端监听ip和端口号
    listener, err := net.Listen("tcp", "localhost:8888")
    checkError(err)
    defer listener.Close()

    fmt.Println("监听成功")
    for {
        i++
        fmt.Println("before accept")
        conn, err := listener.Accept()
        if err != nil {
            continue
        }

        //开辟一个协程处理客户端请求
        go doServerStuff(conn, i)
    }
}

//处理客户端信息
func doServerStuff(conn net.Conn, num int) {

    fmt.Println("accept num:", num)

    clientInfo := make([]byte, 2048)
    //读取客户端发来消息
    _, err := conn.Read(clientInfo)
    if err != nil {
        fmt.Println(" connection error: ", err)
        return
    }

    fmt.Println(string(clientInfo))
    sInfo := "I am server, hello"
    clientInfo = []byte(sInfo)
    //向客户端发送消息
    _, err = conn.Write(clientInfo)
    if err != nil {
        fmt.Println(" connection error: ", err)
        return
    }
}

//检查错误
func checkError(err error) {
    if err != nil {
        log.Fatal("an error!", err.Error())
    }
}

//主函数
func main() {
    //开启服务程序
    startServer()
}

客户端程序：

package main

import (
    "flag"
    "fmt"
    "log"
    "net"
    "time"
)

//连接服务器
func connectServer() {
    //接通
    conn, err := net.Dial("tcp", "localhost:8888")
    checkError(err)
    fmt.Println("连接成功！\n")

    cInfo := "Hello.I am client     "
    buffer := make([]byte, 2048)
    buffer = []byte(cInfo)

    conn.Write(buffer)
    //向服务器发送消息
    _, err = conn.Write(buffer)
    if err != nil {
        fmt.Println(" connection error: ", err)
        return
    }
    //接收服务器发送消息
    _, err = conn.Read(buffer)
    if err != nil {
        fmt.Println(" connection error: ", err)
        return
    }

    fmt.Println(string(buffer))
}

//检查错误
func checkError(err error) {
    if err != nil {
        log.Fatal("an error!", err.Error())
    }
}

//主函数
func main() {

    var goCount *int
    goCount = flag.Int("goCount", 0, "goroutine number")

    //解析输入的参数
    flag.Parse()
    fmt.Println("go count = ", *goCount)

    //get current time
    tInsert := time.Now()
    fmt.Println("tStart time: ", tInsert)

    for i := 0; i < *goCount; i++ {

        fmt.Println("goroutine number: ", i)
        //连接servser
        connectServer()
    }
    //获取时间差
    elapsed := time.Since(tInsert)
    fmt.Println("Insert elapsed: ", elapsed)
    fmt.Println("/n")
}

shell脚本：

#!/bin/bash

for i in {1..5};do
    ./client -goCount=5 &
done

说明：以下操作默认设置每个用户请求次数为20次

测试1 5条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为5	47.798ms	64.333ms	56.066ms	0.5607ms

测试2 10条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为10	119.037ms	88.307ms	103.672ms	0.5184ms

测试3 20条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为20	200.559ms	190.877ms	195.718ms	0.4890ms

测试4 50条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为50	458.408ms	448.862ms	454.135ms	0.4541ms

测试5 80条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为80	673.473ms	667.245ms	670.359ms	0.4190ms

测试6 100条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为100	1.2148s	0.8109s	1.0129s	0.5065ms

测试7 150条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为150	1.6721s	1.3690s	1.5206s	0.5069ms

测试8 200条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为200	2.2316s	2.1661s	2.1989s	0.5497ms

测试9 250条并发

操作方式	测试1（用时）	测试2（用时）	平均总用时	平均一条请求耗时
用户数为250	3.2498s	3.2113s	3.2306s	0.6416ms