1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// server.go

/*
	golang中使用的是http1.1协议，默认为长链接。仅第一次发送请求时进行握手。
*/

package main

import (
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"sync"

	"github.com/gorilla/websocket"
)

var ws_addr = flag.String("ws_addr", "localhost:9080", "websocket http service address")
var http_addr = flag.String("http_addr", "localhost:9090", "http address address")

var upgrader = websocket.Upgrader{} // use default options

func ws_echo(w http.ResponseWriter, r *http.Request) {
	c, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Print("upgrade:", err)
		return
	}
	defer c.Close()
	for {
		mt, message, err := c.ReadMessage()
		if err != nil {
			log.Println("read:", err)
			break
		}
		log.Printf("recv: %s", message)
		err = c.WriteMessage(mt, message)
		if err != nil {
			log.Println("write:", err)
			break
		}
	}
}

func http_echo(w http.ResponseWriter, req *http.Request) {
	req.ParseForm()
	echo_data := req.Form.Get("echo")
	fmt.Println(echo_data)
	io.WriteString(w, echo_data)
	return

}

func start_websocket() {
	http.HandleFunc("/ws_echo", ws_echo)
	log.Fatal(http.ListenAndServe(*ws_addr, nil))
}

func start_http() {
	http.HandleFunc("/http_echo", http_echo)
	log.Fatal(http.ListenAndServe(*http_addr, nil))
}

func main() {
	flag.Parse()
	log.SetFlags(0)
	wg := sync.WaitGroup{}
	wg.Add(2)
	go start_websocket()
	go start_http()
	wg.Wait()

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

// web_test.go
package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
	"testing"

	"github.com/gorilla/websocket"
)

func BenchmarkHttp(b *testing.B) {
	client := &http.Client{}
	for i := 0; i < b.N; i++ {
		i_str := strconv.Itoa(i)
		req, err := http.NewRequest(http.MethodGet, "http://localhost:9090/http_echo?echo="+i_str, nil)
		if err != nil {
			fmt.Println("create new request failed", err.Error())
			return
		}
		//b.ResetTimer()
		resp, err := client.Do(req)
		if err != nil {
			fmt.Println("got http request error", err.Error())
			return
		}
		_, _ = ioutil.ReadAll(resp.Body)
		//fmt.Println(string(body))
	}
}

func BenchmarkWs(b *testing.B) {
	addr := "localhost:9080"
	u := url.URL{Scheme: "ws", Host: addr, Path: "/ws_echo"}
	c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
	if err != nil {
		fmt.Println("Error, create websocket connect failed")
		return
	}
	for i := 0; i < b.N; i++ {
		err = c.WriteMessage(websocket.TextMessage, []byte(strconv.Itoa(i)))
		if err != nil {
			fmt.Println("write ws message failed, ", err.Error())
			continue
		}
		_, message, err := c.ReadMessage()
		if err != nil {
			fmt.Println("Error, recv message failed")
			fmt.Println(string(message))
			continue
		}
		//fmt.Println(string(message))
	}
	err = c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
	c.Close()
}

1
2
3
4
5

go test -bench=. -benchtime=3s -run=none
BenchmarkHttp-8   	   57764	     62737 ns/op
BenchmarkWs-8     	  101538	     36740 ns/op
PASS
ok  	web_perf	8.850s