golang高並發

golang 為什么能做到高並發

  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)
    }
}

 

然后啟動

這樣簡單的一個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的連接池。要熟悉這門語言還是多寫多看，才能掌握好它。靈活熟練的使用。

原文地址：www.cnblogs.com/feixiangmanon/p/10504081.html