深入理解golang高并发

GO语言在WEB开发领域中的使用越来越广泛，要学习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服务。

1. package main
   
2. 
   
3. import (
   
4. "fmt"
   
5. "log"
   
6. "net/http"
   
7. )
   
8. 
   
9. func response(w http.ResponseWriter, r *http.Request) {
   
10. fmt.Fprintf(w, "Hello world!") //这个写入到w的是输出到客户端的
    
11. }
    
12. 
    
13. func main() {
    
14. http.HandleFunc("/", response)
    
15. err := http.ListenAndServe(":9000", nil)
    
16. if err != nil {
    
17.   log.Fatal("ListenAndServe: ", err)
    
18. }
    
19. }

复制代码

然后编译

1. go build -o test_web.gobin
   
2. ./test_web.gobin

复制代码

然后访问
curl 127.0.0.1:9000
Hello world!

这样简单的一个WEB服务就搭建起来。接下来我们一步一步理解这个Web服务是怎么运行的，怎么做到高并发的。
我们顺着http.HandleFunc("/", response)方法顺着代码一直往上看。

1. func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
   
2. DefaultServeMux.HandleFunc(pattern, handler)
   
3. }
   
4. var DefaultServeMux = &defaultServeMux
   
5. var defaultServeMux ServeMux
   
6. 
   
7. type ServeMux struct {
   
8. mu sync.RWMutex//读写锁。并发处理需要的锁
   
9. m  map[string]muxEntry//路由规则map。一个规则一个muxEntry
   
10. hosts bool //规则中是否带有host信息
    
11. }
    
12. 一个路由规则字符串，对应一个handler处理方法。
    
13. type muxEntry struct {
    
14. h  Handler
    
15. pattern string
    
16. }

复制代码

上面是DefaultServeMux的定义和说明。我们看到ServeMux结构体，里面有个读写锁，处理并发使用。muxEntry结构体，里面有handler处理方法和路由字符串。

接下来我们看下，http.HandleFunc函数，也就是DefaultServeMux.HandleFunc做了什么事。我们先看mux.Handle第二个参数HandlerFunc(handler)

1. func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
   
2. mux.Handle(pattern, HandlerFunc(handler))
   
3. }
   
4. type Handler interface {
   
5. ServeHTTP(ResponseWriter, *Request) // 路由实现器
   
6. }
   
7. type HandlerFunc func(ResponseWriter, *Request)
   
8. func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
   
9. f(w, r)
   
10. }

复制代码

我们看到，我们传递的自定义的response方法被强制转化成了HandlerFunc类型，所以我们传递的response方法就默认实现了ServeHTTP方法的。
我们接着看mux.Handle第一个参数。

1. func (mux *ServeMux) Handle(pattern string, handler Handler) {
   
2. mux.mu.Lock()
   
3. defer mux.mu.Unlock()
   
4. 
   
5. if pattern == "" {
   
6.   panic("http: invalid pattern")
   
7. }
   
8. if handler == nil {
   
9.   panic("http: nil handler")
   
10. }
    
11. if _, exist := mux.m[pattern]; exist {
    
12.   panic("http: multiple registrations for " + pattern)
    
13. }
    
14. 
    
15. if mux.m == nil {
    
16.   mux.m = make(map[string]muxEntry)
    
17. }
    
18. mux.m[pattern] = muxEntry{h: handler, pattern: pattern}
    
19. 
    
20. if pattern[0] != '/' {
    
21.   mux.hosts = true
    
22. }
    
23. }

复制代码

将路由字符串和处理的handler函数存储到ServeMux.m 的map表里面，map里面的muxEntry结构体，上面介绍了，一个路由对应一个handler处理方法。

接下来我们看看，http.ListenAndServe(":9000", nil)做了什么

1. func ListenAndServe(addr string, handler Handler) error {
   
2. server := &Server{Addr: addr, Handler: handler}
   
3. return server.ListenAndServe()
   
4. }
   
5. 
   
6. func (srv *Server) ListenAndServe() error {
   
7. addr := srv.Addr
   
8. if addr == "" {
   
9.   addr = ":http"
   
10. }
    
11. ln, err := net.Listen("tcp", addr)
    
12. if err != nil {
    
13.   return err
    
14. }
    
15. return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
    
16. }

复制代码

net.Listen("tcp", addr) ，就是使用端口addr用TCP协议搭建了一个服务。tcpKeepAliveListener就是监控addr这个端口。

接下来就是关键代码，HTTP的处理过程

1. func (srv *Server) Serve(l net.Listener) error {
   
2. defer l.Close()
   
3. if fn := testHookServerServe; fn != nil {
   
4.   fn(srv, l)
   
5. }
   
6. var tempDelay time.Duration // how long to sleep on accept failure
   
7. 
   
8. if err := srv.setupHTTP2_Serve(); err != nil {
   
9.   return err
   
10. }
    
11. 
    
12. srv.trackListener(l, true)
    
13. defer srv.trackListener(l, false)
    
14. 
    
15. baseCtx := context.Background() // base is always background, per Issue 16220
    
16. ctx := context.WithValue(baseCtx, ServerContextKey, srv)
    
17. for {
    
18.   rw, e := l.Accept()
    
19.   if e != nil {
    
20.    select {
    
21.    case <-srv.getDoneChan():
    
22.     return ErrServerClosed
    
23.    default:
    
24.    }
    
25.    if ne, ok := e.(net.Error); ok && ne.Temporary() {
    
26.     if tempDelay == 0 {
    
27.      tempDelay = 5 * time.Millisecond
    
28.     } else {
    
29.      tempDelay *= 2
    
30.     }
    
31.     if max := 1 * time.Second; tempDelay > max {
    
32.      tempDelay = max
    
33.     }
    
34.     srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
    
35.     time.Sleep(tempDelay)
    
36.     continue
    
37.    }
    
38.    return e
    
39.   }
    
40.   tempDelay = 0
    
41.   c := srv.newConn(rw)
    
42.   c.setState(c.rwc, StateNew) // before Serve can return
    
43.   go c.serve(ctx)
    
44. }
    
45. }

复制代码

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)做的。看下代码

1. func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
   
2. handler := sh.srv.Handler
   
3. if handler == nil {
   
4.   handler = DefaultServeMux
   
5. }
   
6. if req.RequestURI == "*" && req.Method == "OPTIONS" {
   
7.   handler = globalOptionsHandler{}
   
8. }
   
9. handler.ServeHTTP(rw, req)
   
10. }

复制代码

handler为空，就我们刚开始项目中的ListenAndServe第二个参数。我们是nil，所以就走DefaultServeMux，我们知道开始路由我们就设置的是DefaultServeMux，所以在DefaultServeMux里面我一定可以找到请求的路由对应的handler，然后执行ServeHTTP。前边已经介绍过，我们的reponse方法为什么具有ServeHTTP的功能。流程大概就是这样的。
我们看下流程图

结语

我们基本已经学习忘了GO 的HTTP的整个工作原理，了解到了它为什么在WEB开发中可以做到高并发，这些也只是GO的冰山一角，还有Redis MySQL的连接池。要熟悉这门语言还是多写多看，才能掌握好它。灵活熟练的使用。