搭建一个后台服务器， 有很种方法与模式，c/c++使用epoll, nodejs的V8等都能实现。

今天我们来看看go server的模式。

同以往其他语言底层采用epoll模式略有不同，golang采用了goroutine(协程）+channel的模式。

routine: 在线程之上封装的协程，每个都有自己的堆栈。

channel:协程间通信使用的。

创建routine的命令是

go func()

我们来举个例子。

比如创建一个http服务：

func Index(w http.ResponseWriter, r *http.Request){
    log.Println("static:index_request,  ip:", r.RemoteAddr)
    io.WriteString(w, r.URL.Path)
     
}
func GetData(w http.ResponseWriter, r *http.Request){
    log.Println("static:index_request,  ip:", r.RemoteAddr)
    vars := mux.Vars(r)
    id := vars["id"]
    log.Println("get data, id:", id)
    io.WriteString(w, r.URL.Path)
}
 
func createServer() error{
    router := mux.NewRouter().StrictSlash(true)
    router.HandleFunc("/getData/{id}", GetData)
    router.HandleFunc("/", Index)
    http.ListenAndServe(":12345", router)
    return nil
}

router专门负责请求路由。

/请求只是负责打印请求链接。

/getData/{id}是一条查询数据请求。

看看内部对每条新请求的处理逻辑：

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
    }
    // TODO: allow changing base context? can't imagine concrete
    // use cases yet.
    baseCtx := context.Background()
    ctx := context.WithValue(baseCtx, ServerContextKey, srv)
    ctx = context.WithValue(ctx, LocalAddrContextKey, l.Addr())
    for {
        rw, e := l.Accept()
        if e != nil {
            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)
    }
}

可以看到最后一条语句为 go c.serve(ctx) ，意味着每条新链接都会被放进一条新routine里去执行，这样避免了各请求间的阻塞关系。

假设同一条请求有多个阻塞子请求，比如

getData调用2个请求以获得数据：

func GetDataA() (*A, error){
    time.Sleep(time.Second * 1)
    return &A{string("a")}, nil
}
func GetDataB() (*B, error){
    time.Sleep(time.Second * 0.5)
    return &B{string("b")}, nil
}
 
 
 
func GetData(w http.ResponseWriter, r *http.Request){
    log.Println("static:index_request,  ip:", r.RemoteAddr)
    vars := mux.Vars(r)
    id := vars["id"]
    log.Println("get data, id:", id)
    io.WriteString(w, r.URL.Path)
    a, _ := GetDataA()
    b, _ := GetDataB()
    log.Println("a:", a.a, ",b:", b.b)
}

一般情况下，会将GetDataA/GetDataB顺序执行,假设A函数占用1s， B函数占用0.5秒，则GetData调用时间将超过1.5秒。

在go routine下可以很好的解决问题。

func GetDataA(ca *chan A) error{
    time.Sleep(time.Second * 1)
    ca <- A{string("a")}
    return nil
}
func GetDataB(cb *chan B) error{
    time.Sleep(time.Second * 0.5)
    cb <- &B{string("b")}
    return nil
}
func GetData(w http.ResponseWriter, r *http.Request){
    log.Println("static:index_request,  ip:", r.RemoteAddr)
    vars := mux.Vars(r)
    id := vars["id"]
    log.Println("get data, id:", id)
    io.WriteString(w, r.URL.Path)
    var ca chan A
    var cb chan B
    go GetDataA(&ca)
    go GetDataB(&cb)
    a := <- ca
    b := <- cb
    log.Println("a:", a.a, ",b:", b.b)
}

这样GetDataA/GetDataB即可以并行执行，总共时间约1秒即可完成。

上面的 a := <- ca即表示a是接受channel的请求。

整条链路的流程：

现实工作中可能会有很多类似串行转并行的过程。

比如前端界现在流行的服务端渲染， 对于多个model数据的请求，采用routine获取，可以将时间长度最大缩短。

备注：

c++与golang高并发模式不同，之前我写过c/c++的高性能服务器文章：http://blog.csdn.net/xiaofei_hah0000/article/details/8743627