前言
GO語言在WEB開發領域中的使用越來越廣泛，Hired 發布的《2019 軟件工程師狀態》報告中指出，具有 Go 經驗的候選人是迄今為止最具吸引力的。平均每位求職者會收到9 份面試邀請。
想學習go，最基礎的就要理解go是怎么做到高并發的。
那么什么是高并發？
高并發（High Concurrency）是互聯網分布式系統架構設計中必須考慮的因素之一，它通常是指，通過設計保證系統能夠同時并行處理很多請求。
嚴格意義上說，單核的CPU是沒法做到并行的，只有多核的CPU才能做到嚴格意義上的并行，因為一個CPU同時只能做一件事。那為什么是單核的CPU也能做到高并發。這就是操作系統進程線程調度切換執行，感覺上是并行處理了。所以只要進程線程足夠多，就能處理C1K C10K的請求，但是進程線程的數量又受到操作系統內存等資源的限制。每個線程必須分配8M大小的棧內存，不管是否使用。每個php-fpm需要占用大約20M的內存。所以目前有線程的Java就比只有進程的PHP的并發處理能力高。當然了，軟件的處理能力不僅僅跟內存有關，還有是否阻塞，是否異步處理，CPU等等。Nginx作為單線程的模型卻可以承擔幾萬甚至幾十萬的并發請求，Nginx的話題說起來也就更多了。
我們繼續聊我們的Go，那么是不是可以有一種語言使用更小的處理單元，占用內存比線程更小，那么它的并發處理能力就可以更高。所以Google就做了這件事，就有了golang語言,golang從語言層面就支持了高并發。
go為什么能做到高并發
goroutine是Go并行設計的核心。goroutine說到底其實就是協程，但是它比線程更小，幾十個goroutine可能體現在底層就是五六個線程，Go語言內部幫你實現了這些goroutine之間的內存共享。執行goroutine只需極少的棧內存(大概是4~5KB)，當然會根據相應的數據伸縮。也正因為如此，可同時運行成千上萬個并發任務。goroutine比thread更易用、更高效、更輕便。
一些高并發的處理方案基本都是使用協程，openresty也是利用lua語言的協程做到了高并發的處理能力，PHP的高性能框架Swoole目前也在使用PHP的協程。
協程更輕量，占用內存更小，這是它能做到高并發的前提。
go web開發中怎么做到高并發的能力
學習go的HTTP代碼。先創建一個簡單的web服務。
package main
import (
"fmt"
"log"
"net/http"
)
func response(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello world!") //這個寫入到w的是輸出到客戶端的
}
func main() {
http.HandleFunc("/", response)
err := http.ListenAndServe(":9000", nil)
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
}
然后編譯
go build -o test_web.gobin
./test_web.gobin
然后訪問
curl 127.0.0.1:9000
Hello world!
這樣簡單的一個WEB服務就搭建起來。接下來我們一步一步理解這個Web服務是怎么運行的，怎么做到高并發的。
我們順著http.HandleFunc("/", response)方法順著代碼一直往上看。
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
var DefaultServeMux = defaultServeMux
var defaultServeMux ServeMux
type ServeMux struct {
mu sync.RWMutex//讀寫鎖。并發處理需要的鎖
m map[string]muxEntry//路由規則map。一個規則一個muxEntry
hosts bool //規則中是否帶有host信息
}
一個路由規則字符串，對應一個handler處理方法。
type muxEntry struct {
h Handler
pattern string
}
上面是DefaultServeMux的定義和說明。我們看到ServeMux結構體，里面有個讀寫鎖，處理并發使用。muxEntry結構體，里面有handler處理方法和路由字符串。
接下來我們看下，http.HandleFunc函數，也就是DefaultServeMux.HandleFunc做了什么事。我們先看mux.Handle第二個參數HandlerFunc(handler)
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
mux.Handle(pattern, HandlerFunc(handler))
}
type Handler interface {
ServeHTTP(ResponseWriter, *Request) // 路由實現器
}
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
我們看到，我們傳遞的自定義的response方法被強制轉化成了HandlerFunc類型，所以我們傳遞的response方法就默認實現了ServeHTTP方法的。
我們接著看mux.Handle第一個參數。
func (mux *ServeMux) Handle(pattern string, handler Handler) {
mux.mu.Lock()
defer mux.mu.Unlock()
if pattern == "" {
panic("http: invalid pattern")
}
if handler == nil {
panic("http: nil handler")
}
if _, exist := mux.m[pattern]; exist {
panic("http: multiple registrations for " + pattern)
}
if mux.m == nil {
mux.m = make(map[string]muxEntry)
}
mux.m[pattern] = muxEntry{h: handler, pattern: pattern}
if pattern[0] != '/' {
mux.hosts = true
}
}
將路由字符串和處理的handler函數存儲到ServeMux.m 的map表里面，map里面的muxEntry結構體，上面介紹了，一個路由對應一個handler處理方法。
接下來我們看看，http.ListenAndServe(":9000", nil)做了什么
func ListenAndServe(addr string, handler Handler) error {
server := Server{Addr: addr, Handler: handler}
return server.ListenAndServe()
}
func (srv *Server) ListenAndServe() error {
addr := srv.Addr
if addr == "" {
addr = ":http"
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return err
}
return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}
net.Listen("tcp", addr) ，就是使用端口addr用TCP協議搭建了一個服務。tcpKeepAliveListener就是監控addr這個端口。
接下來就是關鍵代碼，HTTP的處理過程
func (srv *Server) Serve(l net.Listener) error {
defer l.Close()
if fn := testHookServerServe; fn != nil {
fn(srv, l)
}
var tempDelay time.Duration // how long to sleep on accept failure
if err := srv.setupHTTP2_Serve(); err != nil {
return err
}
srv.trackListener(l, true)
defer srv.trackListener(l, false)
baseCtx := context.Background() // base is always background, per Issue 16220
ctx := context.WithValue(baseCtx, ServerContextKey, srv)
for {
rw, e := l.Accept()
if e != nil {
select {
case -srv.getDoneChan():
return ErrServerClosed
default:
}
if ne, ok := e.(net.Error); ok ne.Temporary() {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
time.Sleep(tempDelay)
continue
}
return e
}
tempDelay = 0
c := srv.newConn(rw)
c.setState(c.rwc, StateNew) // before Serve can return
go c.serve(ctx)
}
}
for里面l.Accept()接受TCP的連接請求，c := srv.newConn(rw)創建一個Conn，Conn里面保存了該次請求的信息(srv,rw)。啟動goroutine，把請求的參數傳遞給c.serve，讓goroutine去執行。
這個就是GO高并發最關鍵的點。每一個請求都是一個單獨的goroutine去執行。
那么前面設置的路由是在哪里匹配的？是在c.serverde的c.readRequest(ctx)里面分析出URI METHOD等，執行serverHandler{c.server}.ServeHTTP(w, w.req)做的。看下代碼
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
handler := sh.srv.Handler
if handler == nil {
handler = DefaultServeMux
}
if req.RequestURI == "*" req.Method == "OPTIONS" {
handler = globalOptionsHandler{}
}
handler.ServeHTTP(rw, req)
}
handler為空，就我們剛開始項目中的ListenAndServe第二個參數。我們是nil，所以就走DefaultServeMux，我們知道開始路由我們就設置的是DefaultServeMux，所以在DefaultServeMux里面我一定可以找到請求的路由對應的handler，然后執行ServeHTTP。前邊已經介紹過，我們的reponse方法為什么具有ServeHTTP的功能。流程大概就是這樣的。
我們看下流程圖
結語
我們基本已經學習忘了GO 的HTTP的整個工作原理，了解到了它為什么在WEB開發中可以做到高并發，這些也只是GO的冰山一角，還有Redis MySQL的連接池。要熟悉這門語言還是多寫多看，才能掌握好它。靈活熟練的使用。
好了，以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，謝謝大家對腳本之家的支持。
您可能感興趣的文章:- 基于Golang 高并發問題的解決方案
- golang高并發限流操作 ping / telnet
- golang-gin-mgo高并發服務器搭建教程
- 如何利用Golang寫出高并發代碼詳解
- 關于golang高并發的實現與注意事項說明
