然后 writeLoop 会进行请求数据 writeRequest ：
func (pc *persistConn) writeLoop() { defer close(pc.writeLoopDone) for { select { case wr := <-pc.writech: startBytesWritten := pc.nwrite // 向 TCP 连接中写入数据，并发送至目标服务器 err := wr.req.Request.write(pc.bw, pc.isProxy, wr.req.extra, pc.waitForContinue(wr.continueCh)) ... case <-pc.closech: return } }}这里会将从 writech 管道中获取到的数据写入到 TCP 连接中，并发送至目标服务器。
readLoop
func (pc *persistConn) readLoop() { closeErr := errReadLoopExiting // default value, if not changed below defer func() { pc.close(closeErr) pc.t.removeIdleConn(pc) }() ... alive := true for alive { pc.readLimit = pc.maxHeaderResponseSize() // 获取 roundTrip 发送的结构体 rc := <-pc.reqch trace := httptrace.ContextClientTrace(rc.req.Context()) var resp *Response if err == nil { // 读取数据 resp, err = pc.readResponse(rc, trace) } else { err = transportReadFromServerError{err} closeErr = err } ... // 将响应数据写回到管道中 select { case rc.ch <- responseAndError{res: resp}: case <-rc.callerGone: return } ... }}这里是从 TCP 连接中读取到对应的请求响应数据，通过 roundTrip 传入的管道再回写，然后 roundTrip 就会接受到数据并获取的响应数据返回。
http server我这里继续以一个简单的例子作为开头：
func HelloHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello World")}func main () { http.HandleFunc("http://www.likecs.com/", HelloHandler) http.ListenAndServe(":8000", nil)}在实现上面我先用一张图进行简要的介绍一下：
其实我们从上面例子的方法名就可以知道一些大致的步骤：
注册处理器到一个 hash 表中，可以通过键值路由匹配；
注册完之后就是开启循环监听，每监听到一个连接就会创建一个 Goroutine；
在创建好的 Goroutine 里面会循环的等待接收请求数据，然后根据请求的地址去处理器路由表中匹配对应的处理器，然后将请求交给处理器处理；
注册处理器处理器的注册如上面的例子所示，是通过调用 HandleFunc 函数来实现的。
HandleFunc 函数会一直调用到 ServeMux 的 Handle 方法中。
func (mux *ServeMux) Handle(pattern string, handler Handler) { mux.mu.Lock() defer mux.mu.Unlock() ... e := muxEntry{h: handler, pattern: pattern} mux.m[pattern] = e if pattern[len(pattern)-1] == 'http://www.likecs.com/' { mux.es = appendSorted(mux.es, e) } if pattern[0] != 'http://www.likecs.com/' { mux.hosts = true }}Handle 会根据路由作为 hash 表的键来保存 muxEntry 对象，muxEntry封装了 pattern 和 handler。如果路由表达式以'http://www.likecs.com/'结尾，则将对应的muxEntry对象加入到[]muxEntry中。
hash 表是用于路由精确匹配，[]muxEntry用于部分匹配。
监听监听是通过调用 ListenAndServe 函数，里面会调用 server 的 ListenAndServe 方法：
func (srv *Server) ListenAndServe() error { if srv.shuttingDown() { return ErrServerClosed } addr := srv.Addr if addr == "" { addr = ":http" } // 监听端口 ln, err := net.Listen("tcp", addr) if err != nil { return err } // 循环接收监听到的网络请求 return srv.Serve(ln)}Serve
func (srv *Server) Serve(l net.Listener) error { ... baseCtx := context.Background() ctx := context.WithValue(baseCtx, ServerContextKey, srv) for { // 接收 listener 过来的网络连接 rw, err := l.Accept() ... tempDelay = 0 c := srv.newConn(rw) c.setState(c.rwc, StateNew) // 创建协程处理连接 go c.serve(connCtx) }}Serve 这个方法里面会用一个循环去接收监听到的网络连接，然后创建协程处理连接。所以难免就会有一个问题，如果并发很高的话，可能会一次性创建太多协程，导致处理不过来的情况。
处理请求