golang中高并發的作用是什么

本篇文章給大家分享的是有關golang中高并發的作用是什么，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

什么是高并發？

高并發（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的功能。流程大概就是這樣的。

我們看下流程圖

以上就是golang中高并發的作用是什么，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。