func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	DefaultServeMux.HandleFunc(pattern, handler)
}

// HandleFunc registers the handler function for the given pattern.
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
   mux.Handle(pattern, HandlerFunc(handler))
}

// Handle registers the handler for the given pattern.
// If a handler already exists for pattern, Handle panics.
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)
	}
	//pattern   url 匹配正则  
	mux.m[pattern] = muxEntry{h: handler, pattern: pattern}

	if pattern[0] != '/' {
		mux.hosts = true
	}
}

// ListenAndServe always returns a non-nil error.
func ListenAndServe(addr string, handler Handler) error {
   server := &Server{Addr: addr, Handler: handler}
   return server.ListenAndServe()
}

// ListenAndServe listens on the TCP network address srv.Addr and then
// calls Serve to handle requests on incoming connections.
// Accepted connections are configured to enable TCP keep-alives.
// If srv.Addr is blank, ":http" is used.
// ListenAndServe always returns a non-nil error.
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)})
}

// Serve always returns a non-nil error. After Shutdown or Close, the
// returned error is ErrServerClosed.
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)  创建 *conn
      c.setState(c.rwc, StateNew) // before Serve can return
      go c.serve(ctx)   //新启一个goroutine，将请求数据做为参数传给 conn，由这个新的goroutine 来处理这次请求
   }
}

// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
   c.remoteAddr = c.rwc.RemoteAddr().String()
   ctx = context.WithValue(ctx, LocalAddrContextKey, c.rwc.LocalAddr())
   defer func() {
      if err := recover(); err != nil && err != ErrAbortHandler {
         const size = 64 << 10
         buf := make([]byte, size)
         buf = buf[:runtime.Stack(buf, false)]
         c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)
      }
      if !c.hijacked() {
         c.close()
         c.setState(c.rwc, StateClosed)
      }
   }()

   if tlsConn, ok := c.rwc.(*tls.Conn); ok {
      if d := c.server.ReadTimeout; d != 0 {
         c.rwc.SetReadDeadline(time.Now().Add(d))
      }
      if d := c.server.WriteTimeout; d != 0 {
         c.rwc.SetWriteDeadline(time.Now().Add(d))
      }
      if err := tlsConn.Handshake(); err != nil {
         c.server.logf("http: TLS handshake error from %s: %v", c.rwc.RemoteAddr(), err)
         return
      }
      c.tlsState = new(tls.ConnectionState)
      *c.tlsState = tlsConn.ConnectionState()
      if proto := c.tlsState.NegotiatedProtocol; validNPN(proto) {
         if fn := c.server.TLSNextProto[proto]; fn != nil {
            h := initNPNRequest{tlsConn, serverHandler{c.server}}
            fn(c.server, tlsConn, h)
         }
         return
      }
   }

   // HTTP/1.x from here on.

   ctx, cancelCtx := context.WithCancel(ctx)
   c.cancelCtx = cancelCtx
   defer cancelCtx()

   c.r = &connReader{conn: c}
   c.bufr = newBufioReader(c.r)
   c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)

   for {
      w, err := c.readRequest(ctx)
      if c.r.remain != c.server.initialReadLimitSize() {
         // If we read any bytes off the wire, we're active.
         c.setState(c.rwc, StateActive)
      }
      if err != nil {
         const errorHeaders = "\r\nContent-Type: text/plain; charset=utf-8\r\nConnection: close\r\n\r\n"

         if err == errTooLarge {
            // Their HTTP client may or may not be
            // able to read this if we're
            // responding to them and hanging up
            // while they're still writing their
            // request. Undefined behavior.
            const publicErr = "431 Request Header Fields Too Large"
            fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
            c.closeWriteAndWait()
            return
         }
         if isCommonNetReadError(err) {
            return // don't reply
         }

         publicErr := "400 Bad Request"
         if v, ok := err.(badRequestError); ok {
            publicErr = publicErr + ": " + string(v)
         }

         fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
         return
      }

      // Expect 100 Continue support
      req := w.req
      if req.expectsContinue() {
         if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
            // Wrap the Body reader with one that replies on the connection
            req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
         }
      } else if req.Header.get("Expect") != "" {
         w.sendExpectationFailed()
         return
      }

      c.curReq.Store(w)

      if requestBodyRemains(req.Body) {
         registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead)
      } else {
         if w.conn.bufr.Buffered() > 0 {
            w.conn.r.closeNotifyFromPipelinedRequest()
         }
         w.conn.r.startBackgroundRead()
      }

      // HTTP cannot have multiple simultaneous active requests.[*]
      // Until the server replies to this request, it can't read another,
      // so we might as well run the handler in this goroutine.
      // [*] Not strictly true: HTTP pipelining. We could let them all process
      // in parallel even if their responses need to be serialized.
      // But we're not going to implement HTTP pipelining because it
      // was never deployed in the wild and the answer is HTTP/2.
      serverHandler{c.server}.ServeHTTP(w, w.req)    //处理请求
      w.cancelCtx()
      if c.hijacked() {
         return
      }
      w.finishRequest()
      if !w.shouldReuseConnection() {
         if w.requestBodyLimitHit || w.closedRequestBodyEarly() {
            c.closeWriteAndWait()
         }
         return
      }
      c.setState(c.rwc, StateIdle)
      c.curReq.Store((*response)(nil))

      if !w.conn.server.doKeepAlives() {
         // We're in shutdown mode. We might've replied
         // to the user without "Connection: close" and
         // they might think they can send another
         // request, but such is life with HTTP/1.1.
         return
      }

      if d := c.server.idleTimeout(); d != 0 {
         c.rwc.SetReadDeadline(time.Now().Add(d))
         if _, err := c.bufr.Peek(4); err != nil {
            return
         }
      }
      c.rwc.SetReadDeadline(time.Time{})
   }
}

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

// ServeHTTP dispatches the request to the handler whose
// pattern most closely matches the request URL.
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
   if r.RequestURI == "*" {
      if r.ProtoAtLeast(1, 1) {
         w.Header().Set("Connection", "close")
      }
      w.WriteHeader(StatusBadRequest)
      return
   }
   h, _ := mux.Handler(r)
   h.ServeHTTP(w, r)
}

// The HandlerFunc type is an adapter to allow the use of
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler that calls f.
type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
   f(w, r)
}

// A ResponseWriter interface is used by an HTTP handler to
// construct an HTTP response.
//
// A ResponseWriter may not be used after the Handler.ServeHTTP method
// has returned.
type ResponseWriter interface {
   // Header returns the header map that will be sent by
   // WriteHeader. The Header map also is the mechanism with which
   // Handlers can set HTTP trailers.
   //
   // Changing the header map after a call to WriteHeader (or
   // Write) has no effect unless the modified headers are
   // trailers.
   //
   // There are two ways to set Trailers. The preferred way is to
   // predeclare in the headers which trailers you will later
   // send by setting the "Trailer" header to the names of the
   // trailer keys which will come later. In this case, those
   // keys of the Header map are treated as if they were
   // trailers. See the example. The second way, for trailer
   // keys not known to the Handler until after the first Write,
   // is to prefix the Header map keys with the TrailerPrefix
   // constant value. See TrailerPrefix.
   //
   // To suppress implicit response headers (such as "Date"), set
   // their value to nil.
   Header() Header

   // Write writes the data to the connection as part of an HTTP reply.
   //
   // If WriteHeader has not yet been called, Write calls
   // WriteHeader(http.StatusOK) before writing the data. If the Header
   // does not contain a Content-Type line, Write adds a Content-Type set
   // to the result of passing the initial 512 bytes of written data to
   // DetectContentType.
   //
   // Depending on the HTTP protocol version and the client, calling
   // Write or WriteHeader may prevent future reads on the
   // Request.Body. For HTTP/1.x requests, handlers should read any
   // needed request body data before writing the response. Once the
   // headers have been flushed (due to either an explicit Flusher.Flush
   // call or writing enough data to trigger a flush), the request body
   // may be unavailable. For HTTP/2 requests, the Go HTTP server permits
   // handlers to continue to read the request body while concurrently
   // writing the response. However, such behavior may not be supported
   // by all HTTP/2 clients. Handlers should read before writing if
   // possible to maximize compatibility.
   Write([]byte) (int, error)

   // WriteHeader sends an HTTP response header with the provided
   // status code.
   //
   // If WriteHeader is not called explicitly, the first call to Write
   // will trigger an implicit WriteHeader(http.StatusOK).
   // Thus explicit calls to WriteHeader are mainly used to
   // send error codes.
   //
   // The provided code must be a valid HTTP 1xx-5xx status code.
   // Only one header may be written. Go does not currently
   // support sending user-defined 1xx informational headers,
   // with the exception of 100-continue response header that the
   // Server sends automatically when the Request.Body is read.
   WriteHeader(statusCode int)
}

func (w *response) Header() Header
func (w *response) WriteHeader(code ``int``)
func (w *response) Write(data []``byte``) (n ``int``, err error)

// The field semantics differ slightly between client and server
// usage. In addition to the notes on the fields below, see the
// documentation for Request.Write and RoundTripper.
type Request struct {
   // Method specifies the HTTP method (GET, POST, PUT, etc.).
   // For client requests an empty string means GET.
   //
   // Go's HTTP client does not support sending a request with
   // the CONNECT method. See the documentation on Transport for
   // details.
   Method string

   // URL specifies either the URI being requested (for server
   // requests) or the URL to access (for client requests).
   //
   // For server requests the URL is parsed from the URI
   // supplied on the Request-Line as stored in RequestURI.  For
   // most requests, fields other than Path and RawQuery will be
   // empty. (See RFC 2616, Section 5.1.2)
   //
   // For client requests, the URL's Host specifies the server to
   // connect to, while the Request's Host field optionally
   // specifies the Host header value to send in the HTTP
   // request.
   URL *url.URL

   // The protocol version for incoming server requests.
   //
   // For client requests these fields are ignored. The HTTP
   // client code always uses either HTTP/1.1 or HTTP/2.
   // See the docs on Transport for details.
   Proto      string // "HTTP/1.0"
   ProtoMajor int    // 1
   ProtoMinor int    // 0

   // Header contains the request header fields either received
   // by the server or to be sent by the client.
   //
   // If a server received a request with header lines,
   //
   // Host: example.com
   // accept-encoding: gzip, deflate
   // Accept-Language: en-us
   // fOO: Bar
   // foo: two
   //
   // then
   //
   // Header = map[string][]string{
   //    "Accept-Encoding": {"gzip, deflate"},
   //    "Accept-Language": {"en-us"},
   //    "Foo": {"Bar", "two"},
   // }
   //
   // For incoming requests, the Host header is promoted to the
   // Request.Host field and removed from the Header map.
   //
   // HTTP defines that header names are case-insensitive. The
   // request parser implements this by using CanonicalHeaderKey,
   // making the first character and any characters following a
   // hyphen uppercase and the rest lowercase.
   //
   // For client requests, certain headers such as Content-Length
   // and Connection are automatically written when needed and
   // values in Header may be ignored. See the documentation
   // for the Request.Write method.
   Header Header

   // Body is the request's body.
   //
   // For client requests a nil body means the request has no
   // body, such as a GET request. The HTTP Client's Transport
   // is responsible for calling the Close method.
   //
   // For server requests the Request Body is always non-nil
   // but will return EOF immediately when no body is present.
   // The Server will close the request body. The ServeHTTP
   // Handler does not need to.
   Body io.ReadCloser

   // GetBody defines an optional func to return a new copy of
   // Body. It is used for client requests when a redirect requires
   // reading the body more than once. Use of GetBody still
   // requires setting Body.
   //
   // For server requests it is unused.
   GetBody func() (io.ReadCloser, error)

   // ContentLength records the length of the associated content.
   // The value -1 indicates that the length is unknown.
   // Values >= 0 indicate that the given number of bytes may
   // be read from Body.
   // For client requests, a value of 0 with a non-nil Body is
   // also treated as unknown.
   ContentLength int64

   // TransferEncoding lists the transfer encodings from outermost to
   // innermost. An empty list denotes the "identity" encoding.
   // TransferEncoding can usually be ignored; chunked encoding is
   // automatically added and removed as necessary when sending and
   // receiving requests.
   TransferEncoding []string

   // Close indicates whether to close the connection after
   // replying to this request (for servers) or after sending this
   // request and reading its response (for clients).
   //
   // For server requests, the HTTP server handles this automatically
   // and this field is not needed by Handlers.
   //
   // For client requests, setting this field prevents re-use of
   // TCP connections between requests to the same hosts, as if
   // Transport.DisableKeepAlives were set.
   Close bool

   // For server requests Host specifies the host on which the
   // URL is sought. Per RFC 2616, this is either the value of
   // the "Host" header or the host name given in the URL itself.
   // It may be of the form "host:port". For international domain
   // names, Host may be in Punycode or Unicode form. Use
   // golang.org/x/net/idna to convert it to either format if
   // needed.
   //
   // For client requests Host optionally overrides the Host
   // header to send. If empty, the Request.Write method uses
   // the value of URL.Host. Host may contain an international
   // domain name.
   Host string

   // Form contains the parsed form data, including both the URL
   // field's query parameters and the POST or PUT form data.
   // This field is only available after ParseForm is called.
   // The HTTP client ignores Form and uses Body instead.
   Form url.Values

   // PostForm contains the parsed form data from POST, PATCH,
   // or PUT body parameters.
   //
   // This field is only available after ParseForm is called.
   // The HTTP client ignores PostForm and uses Body instead.
   PostForm url.Values

   // MultipartForm is the parsed multipart form, including file uploads.
   // This field is only available after ParseMultipartForm is called.
   // The HTTP client ignores MultipartForm and uses Body instead.
   MultipartForm *multipart.Form

   // Trailer specifies additional headers that are sent after the request
   // body.
   //
   // For server requests the Trailer map initially contains only the
   // trailer keys, with nil values. (The client declares which trailers it
   // will later send.)  While the handler is reading from Body, it must
   // not reference Trailer. After reading from Body returns EOF, Trailer
   // can be read again and will contain non-nil values, if they were sent
   // by the client.
   //
   // For client requests Trailer must be initialized to a map containing
   // the trailer keys to later send. The values may be nil or their final
   // values. The ContentLength must be 0 or -1, to send a chunked request.
   // After the HTTP request is sent the map values can be updated while
   // the request body is read. Once the body returns EOF, the caller must
   // not mutate Trailer.
   //
   // Few HTTP clients, servers, or proxies support HTTP trailers.
   Trailer Header

   // RemoteAddr allows HTTP servers and other software to record
   // the network address that sent the request, usually for
   // logging. This field is not filled in by ReadRequest and
   // has no defined format. The HTTP server in this package
   // sets RemoteAddr to an "IP:port" address before invoking a
   // handler.
   // This field is ignored by the HTTP client.
   RemoteAddr string

   // RequestURI is the unmodified Request-URI of the
   // Request-Line (RFC 2616, Section 5.1) as sent by the client
   // to a server. Usually the URL field should be used instead.
   // It is an error to set this field in an HTTP client request.
   RequestURI string

   // TLS allows HTTP servers and other software to record
   // information about the TLS connection on which the request
   // was received. This field is not filled in by ReadRequest.
   // The HTTP server in this package sets the field for
   // TLS-enabled connections before invoking a handler;
   // otherwise it leaves the field nil.
   // This field is ignored by the HTTP client.
   TLS *tls.ConnectionState

   // Cancel is an optional channel whose closure indicates that the client
   // request should be regarded as canceled. Not all implementations of
   // RoundTripper may support Cancel.
   //
   // For server requests, this field is not applicable.
   //
   // Deprecated: Use the Context and WithContext methods
   // instead. If a Request's Cancel field and context are both
   // set, it is undefined whether Cancel is respected.
   Cancel <-chan struct{}

   // Response is the redirect response which caused this request
   // to be created. This field is only populated during client
   // redirects.
   Response *Response

   // ctx is either the client or server context. It should only
   // be modified via copying the whole Request using WithContext.
   // It is unexported to prevent people from using Context wrong
   // and mutating the contexts held by callers of the same request.
   ctx context.Context
}