import "github.com/user/project.git"

module github.com/two/a

go 1.13

require (
        github.com/two/b v1.1.0
        github.com/two/c v1.1.0
        github.com/two/d v1.2.0 // indirect
        github.com/two/e v1.2.0 // indirect
)

package main

import (
        "context"
)

func main() {
        ctx1 := context.Background()

        ctx2, _ := context.WithCancel(ctx1)
        ctx3, _ := context.WithCancel(ctx1)

        ctx4, _ := context.WithCancel(ctx2)
        ctx5, _ := context.WithCancel(ctx2)

        ctx6, _ := context.WithCancel(ctx3)
        ctx7, _ := context.WithCancel(ctx3)

        ctx8, _ := context.WithCancel(ctx4)
        ctx9, _ := context.WithCancel(ctx4)

        ctx10, _ := context.WithCancel(ctx5)
        ctx11, _ := context.WithCancel(ctx5)

        ctx12, _ := context.WithCancel(ctx6)
        ctx13, _ := context.WithCancel(ctx6)

        ctx14, _ := context.WithCancel(ctx7)
        ctx15, _ := context.WithCancel(ctx7)

        println(ctx8)
        println(ctx9)
        println(ctx10)
        println(ctx11)
        println(ctx12)
        println(ctx13)
        println(ctx14)
        println(ctx15)
}

var (
        background = new(emptyCtx)
        todo       = new(emptyCtx)
)

func Background() Context {
        return background
}

type Context interface {
 Deadline() (deadline time.Time, ok bool)
 Done() <-chan struct{}
 Err() error
 Value(key interface{}) interface{}
}

type emptyCtx int

func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
        return
}

func (*emptyCtx) Done() <-chan struct{} {
        return nil
}

func (*emptyCtx) Err() error {
        return nil
}

func (*emptyCtx) Value(key interface{}) interface{} {
        return nil
}

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
        c := newCancelCtx(parent) // 新建一个 cancelCtx
        propagateCancel(parent, &c) // 把当前新节点放到 parent 的子节点中
        return &c, func() { c.cancel(true, Canceled) } // 返回 cancel 函数
}

// newCancelCtx returns an initialized cancelCtx.
func newCancelCtx(parent Context) cancelCtx {
        return cancelCtx{Context: parent}
}

// propagateCancel arranges for child to be canceled when parent is.
func propagateCancel(parent Context, child canceler) {
        if parent.Done() == nil { // 对于 parent.Done() == nil 直接返回，
                                  // 因为这个节点是空节点, 没有 children 字段
                return // parent is never canceled
        }
        if p, ok := parentCancelCtx(parent); ok {
                p.mu.Lock()
                if p.err != nil {
                        // parent has already been canceled
                        child.cancel(false, p.err) // 如果父节点存在错误信息，
                                                   // 证明父节点已经被取消，那么子节点也应该取消
                } else {
                        if p.children == nil {
                                p.children = make(map[canceler]struct{})
                        }
                        p.children[child] = struct{}{} // 放入子节点
                }
                p.mu.Unlock()
        } else {
                go func() {
                        select {
                        case <-parent.Done():
                                child.cancel(false, parent.Err())
                        case <-child.Done():
                        }
                }()
        }
}

if parent.Done() == nil {
        return // parent is never canceled
}

if p, ok := parentCancelCtx(parent); ok {
        p.mu.Lock()
        if p.err != nil {
                // parent has already been canceled
                child.cancel(false, p.err)
        } else {
                if p.children == nil {
                        p.children = make(map[canceler]struct{})
                }
                p.children[child] = struct{}{}
        }
        p.mu.Unlock()
} else {
    ...
}

func parentCancelCtx(parent Context) (*cancelCtx, bool) {
        for {
                switch c := parent.(type) {
                case *cancelCtx:
                        return c, true
                case *timerCtx:
                        return &c.cancelCtx, true
                case *valueCtx:
                        parent = c.Context
                default:
                        return nil, false
                }
        }
}

go func() {
        select {
        case <-parent.Done():
                child.cancel(false, parent.Err())
        case <-child.Done():
        }
}()

...
ctx4, cancel4 := context.WithCancel(ctx2)
cancel4()
...

func (c *cancelCtx) cancel(removeFromParent bool, err error) {
        if err == nil {
                panic("context: internal error: missing cancel error")
        }
        c.mu.Lock()
        if c.err != nil {
                c.mu.Unlock()
                return // already canceled
        }
        c.err = err
        // 通过 chan 传递给所有监听的程序
        if c.done == nil {
                c.done = closedchan
        } else {
                close(c.done)
        }
        // 递归传递消息给所有子节点
        for child := range c.children {
                // NOTE: acquiring the child's lock while holding parent's lock.
                child.cancel(false, err)
        }
        c.children = nil
        c.mu.Unlock()

        // 从树中删除子节点
        if removeFromParent {
                removeChild(c.Context, c)
        }
}

type timerCtx struct {
        cancelCtx
        timer *time.Timer // Under cancelCtx.mu.

        deadline time.Time
}

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
       // 由于父节点的过期时间比子节点的早，不需要单独设置过期,可以直接返回
        if cur, ok := parent.Deadline(); ok && cur.Before(d) {
                // The current deadline is already sooner than the new one.
                return WithCancel(parent) 
        }
        c := &timerCtx{
                cancelCtx: newCancelCtx(parent),
                deadline:  d,
        }
        // 构建context 树
        propagateCancel(parent, c)
        dur := time.Until(d)
       // 已经过了过期时间，直接返回, 不需要设置过期时间
        if dur <= 0 {
            
                c.cancel(true, DeadlineExceeded) // deadline has already passed
                return c, func() { c.cancel(false, Canceled) }
        }
        c.mu.Lock()
        defer c.mu.Unlock()
        // 设置过期时间，在过期时间会调用 cancel 函数
        if c.err == nil {
                c.timer = time.AfterFunc(dur, func() {
                        c.cancel(true, DeadlineExceeded)
                })
        }
        // 返回取消函数
        return c, func() { c.cancel(true, Canceled) }
}

func (c *timerCtx) cancel(removeFromParent bool, err error) {
        c.cancelCtx.cancel(false, err)
        if removeFromParent {
                // Remove this timerCtx from its parent cancelCtx's children.
                removeChild(c.cancelCtx.Context, c)
        }
        c.mu.Lock()
        if c.timer != nil {
                c.timer.Stop()
                c.timer = nil
        }
        c.mu.Unlock()
}

type valueCtx struct {
        Context
        key, val interface{}
}

func WithValue(parent Context, key, val interface{}) Context {
        if key == nil {
                panic("nil key")
        }
        // 判断类型是否可以使用 ==  比较
        if !reflectlite.TypeOf(key).Comparable() {
                panic("key is not comparable")
        }
        return &valueCtx{parent, key, val}
}

func (c *valueCtx) Value(key interface{}) interface{} {
        if c.key == key {
                return c.val
        }
        return c.Context.Value(key)
}

var basicTypeKinds = map[types.BasicKind]string{
    types.UntypedBool:    "bool",
    types.UntypedInt:     "int",
    types.UntypedRune:    "rune",
    types.UntypedFloat:   "float64",
    types.UntypedComplex: "complex128",
    types.UntypedString:  "string",
}

package main

import (
        "context"
        "fmt"
        "math/rand"
)

type traceType string

func main() {
        ctx := context.Background()
        ctx = context.WithValue(ctx, traceType("traceId"), rand.Int())
        process(ctx)
}

func process(ctx context.Context) {
        traceID, ok := ctx.Value(traceType("traceId")).(int)
        if ok {
                fmt.Printf("traceType traceID=%d\n", traceID)
        } else {
                fmt.Println("no traceType tranceID")
        }

        traceID, ok = ctx.Value("traceId").(int)
        if ok {
                fmt.Printf("string type traceID=%d\n", traceID)
        } else {
                fmt.Println("no string type tranceID")
        }
}

import (
        "context"
        "fmt"
        "net/http"
)

type requestType string

var traceID = requestType("traceID")

func main() {

        h := hand{}
        http.HandleFunc("/hi", hi)
        http.ListenAndServe(":8000", h)
}

type hand struct{}

func (h hand) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
        v := req.Header.Get("X-TRACE-ID")
        ctx := context.WithValue(req.Context(), traceID, v)
        reqCtx := req.WithContext(ctx)

        http.DefaultServeMux.ServeHTTP(rw, reqCtx)
}

func hi(rw http.ResponseWriter, req *http.Request) {
        v := req.Context().Value(traceID).(string)
        resp := fmt.Sprintf("traceID = %s\n", v)
        fmt.Fprintf(rw, resp)
}

// gen is a broken generator that will leak a goroutine.
func gen() <-chan int {
    ch := make(chan int)
    go func() {
        var n int
        for {
            ch <- n
            n++
        }
    }()
    return ch
}

// The call site of gen doesn't have a 
for n := range gen() {
    fmt.Println(n)
    if n == 5 {
        break
    }
}

// gen is a generator that can be cancellable by cancelling the ctx.
func gen(ctx context.Context) <-chan int {
    ch := make(chan int)
    go func() {
        var n int
        for {
            select {
            case <-ctx.Done():
                return // avoid leaking of this goroutine when ctx is done.
            case ch <- n:
                n++
            }
        }
    }()
    return ch
}

ctx, cancel := context.WithCancel(context.Background())
defer cancel() // make sure all paths cancel the context to avoid context leak

for n := range gen(ctx) {
    fmt.Println(n)
    if n == 5 {
        cancel()
        break
    }
}

// ...

import (
        "context"
        "fmt"
        "net/http"
        "time"
)

func main() {

        http.HandleFunc("/hi", hi)
        http.ListenAndServe(":8000", nil)
}

func hi(rw http.ResponseWriter, req *http.Request) {
        ctx, cancel := context.WithTimeout(req.Context(), time.Millisecond*100)
        defer cancel()
        reqCtx := req.WithContext(ctx)

        for {
                select {
                case <-reqCtx.Context().Done():
                        return
                case <-time.After(time.Second):
                        // do something
                }
        }
        //...
}

// main.go

package main

import "go.etcd.io/etcd/etcdmain"

func main() {
    etcdmain.Main()
}

// etcdmain/main.go

func Main() {
    // 检查支持的平台
    checkSupportArch()

    // 参数解析
    if len(os.Args) > 1 {
        cmd := os.Args[1]
        if covArgs := os.Getenv("ETCDCOV_ARGS"); len(covArgs) > 0 {
            args := strings.Split(os.Getenv("ETCDCOV_ARGS"), "\xe7\xcd")[1:]
            rootCmd.SetArgs(args)
            cmd = "grpc-proxy" // 如果设置了 ETCDCOV_ARGS 环境变量，就是以 grpc-proxy 方式启动
        }
        switch cmd {
        case "gateway", "grpc-proxy": // 如果设置了 cmd变量，就以变量的形式启动,包括 gateway, grpc-proxy 两种方式
            if err := rootCmd.Execute(); err != nil { // rootCmd.Execute 就等于调用 `etcd gateway` 或者 `etcd grpc-proxy`, 其它的参数不支持，调用的是 `etcd`
                fmt.Fprint(os.Stderr, err)
                os.Exit(1)
            }
            return
        }
    }

    startEtcdOrProxyV2()
}

// etcdmain/etcd.go

func startEtcdOrProxyV2() {
    grpc.EnableTracing = false

    cfg := newConfig()                             // 默认配置项
    defaultInitialCluster := cfg.ec.InitialCluster // 对应配置文件中的 ETCD_INITIAL_CLUSTER 变量，默认的集群节点配置

    ...

    defer func() {
        logger := cfg.ec.GetLogger()
        if logger != nil {
            logger.Sync()
        }
    }()

    // 重新修改一下 cluster 配置中的 cluster 相关的信息，比如获取当前计算机的 hostname 代替 0.0.0.0 或 localhost
    defaultHost, dhErr := (&cfg.ec).UpdateDefaultClusterFromName(defaultInitialCluster)
    ...

    var stopped <-chan struct{}
    var errc <-chan error

    which := identifyDataDirOrDie(cfg.ec.GetLogger(), cfg.ec.Dir) // 检查存储数据的目录, 返回数据存储的类型是成员还是 proxy 等
    if which != dirEmpty {                                        // 节点目录不为空，证明不是第一次使用，恢复之前的配置
        ...
        switch which {
        case dirMember: // 如果是成员类型，需要开启一个 etcd 服务
            stopped, errc, err = startEtcd(&cfg.ec)
        case dirProxy: // 如果是proxy, 则开启一个 proxy 服务
            err = startProxy(cfg)
        default:
            ...
        }
    } else { // 如果为空，则根据参数启动服务
        shouldProxy := cfg.isProxy()
        if !shouldProxy { // 如果不是 proxy, 则启动一个正常的 server
            stopped, errc, err = startEtcd(&cfg.ec)
            if derr, ok := err.(*etcdserver.DiscoveryError); ok && derr.Err == v2discovery.ErrFullCluster {
                if cfg.shouldFallbackToProxy() {
                    ...
                    shouldProxy = true
                }
            } 
        ...
        if shouldProxy { // 如果是 proxy ,则启动一个 proxy 服务
            err = startProxy(cfg)
        }
    }
    ...
    osutil.HandleInterrupts(lg) // 接收外界信号

    // At this point, the initialization of etcd is done.
    // The listeners are listening on the TCP ports and ready
    // for accepting connections. The etcd instance should be
    // joined with the cluster and ready to serve incoming
    // connections.
    notifySystemd(lg) // 把型号发送给正在运行的 etcd 守护进程

    select { // 进入阻塞状态，除非出现错误或者服务关闭
    case lerr := <-errc:
        // fatal out on listener errors
        if lg != nil {
            lg.Fatal("listener failed", zap.Error(lerr))
        } else {
            plog.Fatal(lerr)
        }
    case <-stopped:
    }
    osutil.Exit(0)
}

// startEtcd runs StartEtcd in addition to hooks needed for standalone etcd.
func startEtcd(cfg *embed.Config) (<-chan struct{}, <-chan error, error) {
    e, err := embed.StartEtcd(cfg) // 根据配置开启一个 etcd server
    if err != nil {
        return nil, nil, err
    }
    osutil.RegisterInterruptHandler(e.Close) // 注册通过信号关闭时的回调函数
    select {                                 // 进入阻塞,除非接收到下面的信号
    case <-e.Server.ReadyNotify(): // wait for e.Server to join the cluster  阻塞，直到当前 server 注册到了集群中
    case <-e.Server.StopNotify(): // publish aborted from 'ErrStopped' 注册失败
    }
    return e.Server.StopNotify(), e.Err(), nil
}

// embed/etcd.go

// StartEtcd 回开启一个 etcd server, 并且接收 HTTP 请求，但是这个函数并不会保证加入到了集群中
// 加入集群是由  Etcd.Server.ReadyNotify() 来实现的
// StartEtcd launches the etcd server and HTTP handlers for client/server communication.
// The returned Etcd.Server is not guaranteed to have joined the cluster. Wait
// on the Etcd.Server.ReadyNotify() channel to know when it completes and is ready for use.
func StartEtcd(inCfg *Config) (e *Etcd, err error) {
    if err = inCfg.Validate(); err != nil { // 检查一些参数是否合法
        return nil, err
    }
    serving := false
    e = &Etcd{cfg: *inCfg, stopc: make(chan struct{})}
    cfg := &e.cfg
    defer func() {
        if e == nil || err == nil {
            return
        }
        if !serving {
            // errored before starting gRPC server for serveCtx.serversC
            for _, sctx := range e.sctxs {
                close(sctx.serversC)
            }
        }
        e.Close()
        e = nil
    }()
    // 开启 peer server, 默认端口 2380
    if e.Peers, err = configurePeerListeners(cfg); err != nil { // 节点数据赋值
        return e, err
    }
    // 开启 client server,  默认端口 2379，并且支持多协议(grpc,http, https)
    if e.sctxs, err = configureClientListeners(cfg); err != nil { // client 数据赋值
        return e, err
    }

    for _, sctx := range e.sctxs { // 当前 server ctx 记录
        e.Clients = append(e.Clients, sctx.l)
    }

    // 注册 token
    memberInitialized := true
    if !isMemberInitialized(cfg) {
        memberInitialized = false
        urlsmap, token, err = cfg.PeerURLsMapAndToken("etcd")
        if err != nil {
            return e, fmt.Errorf("error setting up initial cluster: %v", err)
        }
    }

    // AutoCompactionRetention defaults to "0" if not set.
    if len(cfg.AutoCompactionRetention) == 0 {
        cfg.AutoCompactionRetention = "0"
    }
    autoCompactionRetention, err := parseCompactionRetention(cfg.AutoCompactionMode, cfg.AutoCompactionRetention)
    if err != nil {
        return e, err
    }

    backendFreelistType := parseBackendFreelistType(cfg.ExperimentalBackendFreelistType)
    // 根据配置新建一个 server 对象
    if e.Server, err = etcdserver.NewServer(srvcfg); err != nil {
        return e, err
    }

    // buffer channel 保证服务关闭的时候不会阻塞
    // buffer channel so goroutines on closed connections won't wait forever
    e.errc = make(chan error, len(e.Peers)+len(e.Clients)+2*len(e.sctxs))

    // newly started member ("memberInitialized==false")
    // does not need corruption check
    if memberInitialized {
        if err = e.Server.CheckInitialHashKV(); err != nil {
            // set "EtcdServer" to nil, so that it does not block on "EtcdServer.Close()"
            // (nothing to close since rafthttp transports have not been started)
            e.Server = nil
            return e, err
        }
    }
    e.Server.Start() // 开启一个 etcd server

    // 与每个 peer 保持通信
    if err = e.servePeers(); err != nil {
        return e, err
    }
    //  开启 server 与每个 client 保持通信, 可以同时支持多重协议
    if err = e.serveClients(); err != nil {
        return e, err
    }
    // 与每个 metrics 保持通信
    if err = e.serveMetrics(); err != nil {
        return e, err
    }
    ...
    serving = true
    return e, nil
}

// Start performs any initialization of the Server necessary for it to
// begin serving requests. It must be called before Do or Process.
// Start must be non-blocking; any long-running server functionality
// should be implemented in goroutines.
func (s *EtcdServer) Start() {
    s.start()
    // 下面的函数将在 server 关闭后等执行完成
    s.goAttach(func() { s.adjustTicks() })
    s.goAttach(func() { s.publish(s.Cfg.ReqTimeout()) })
    s.goAttach(s.purgeFile)
    s.goAttach(func() { monitorFileDescriptor(s.getLogger(), s.stopping) })
    s.goAttach(s.monitorVersions)
    s.goAttach(s.linearizableReadLoop)
    s.goAttach(s.monitorKVHash)
}

// start prepares and starts server in a new goroutine. It is no longer safe to
// modify a server's fields after it has been sent to Start.
// This function is just used for testing.
func (s *EtcdServer) start() {
    ...
    // 通过一个 goroutine 开启服务
    // TODO: if this is an empty log, writes all peer infos
    // into the first entry
    go s.run()
}

func (s *EtcdServer) run() {
    lg := s.getLogger()
    sn, err := s.r.raftStorage.Snapshot()

    // asynchronously accept apply packets, dispatch progress in-order
    sched := schedule.NewFIFOScheduler()
    ...
    s.r.start(rh)

    defer func() {
        s.wgMu.Lock() // block concurrent waitgroup adds in goAttach while stopping
        close(s.stopping)
        s.wgMu.Unlock()
        s.cancel()

        sched.Stop()

        // wait for gouroutines before closing raft so wal stays open
        s.wg.Wait()

        s.SyncTicker.Stop()

        // must stop raft after scheduler-- etcdserver can leak rafthttp pipelines
        // by adding a peer after raft stops the transport
        s.r.stop()

        // kv, lessor and backend can be nil if running without v3 enabled
        // or running unit tests.
        if s.lessor != nil {
            s.lessor.Stop()
        }
        if s.kv != nil {
            s.kv.Close()
        }
        if s.authStore != nil {
            s.authStore.Close()
        }
        if s.be != nil {
            s.be.Close()
        }
        if s.compactor != nil {
            s.compactor.Stop()
        }
        close(s.done)
    }()
    var expiredLeaseC <-chan []*lease.Lease
    if s.lessor != nil {
        expiredLeaseC = s.lessor.ExpiredLeasesC()
    }
    for {
        select {
        case ap := <-s.r.apply(): // 数据更新
            f := func(context.Context) { s.applyAll(&ep, &ap) }
            sched.Schedule(f)
        case leases := <-expiredLeaseC: // 租期过期处理
            s.goAttach(func() {
            ...
             })
        case err := <-s.errorc: // 出现错误，退出 server
            ...
            return
        case <-getSyncC(): // 定期同步数据
            if s.v2store.HasTTLKeys() {
                s.sync(s.Cfg.ReqTimeout())
            }
        case <-s.stop: // 停止信号，停止 server
            return
        }
    }
}

// etcdserver/raft.go.start
// raft node 启动，保持心跳
// start prepares and starts raftNode in a new goroutine. It is no longer safe
// to modify the fields after it has been started.
func (r *raftNode) start(rh *raftReadyHandler) {
}

func (e *Etcd) serveClients() (err error) {
    if !e.cfg.ClientTLSInfo.Empty() {
        if e.cfg.logger != nil {
            e.cfg.logger.Info(
                "starting with client TLS",
                zap.String("tls-info", fmt.Sprintf("%+v", e.cfg.ClientTLSInfo)),
                zap.Strings("cipher-suites", e.cfg.CipherSuites),
            )
        } else {
            plog.Infof("ClientTLS: %s", e.cfg.ClientTLSInfo)
        }
    }

    // Start a client server goroutine for each listen address
    var h http.Handler
    if e.Config().EnableV2 {
        if len(e.Config().ExperimentalEnableV2V3) > 0 {
            srv := v2v3.NewServer(e.cfg.logger, v3client.New(e.Server), e.cfg.ExperimentalEnableV2V3)
            h = v2http.NewClientHandler(e.GetLogger(), srv, e.Server.Cfg.ReqTimeout())
        } else {
            h = v2http.NewClientHandler(e.GetLogger(), e.Server, e.Server.Cfg.ReqTimeout())
        }
    } else {
        mux := http.NewServeMux()
        etcdhttp.HandleBasic(mux, e.Server)
        h = mux
    }

    gopts := []grpc.ServerOption{}
    if e.cfg.GRPCKeepAliveMinTime > time.Duration(0) {
        gopts = append(gopts, grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
            MinTime:             e.cfg.GRPCKeepAliveMinTime,
            PermitWithoutStream: false,
        }))
    }
    if e.cfg.GRPCKeepAliveInterval > time.Duration(0) &&
        e.cfg.GRPCKeepAliveTimeout > time.Duration(0) {
        gopts = append(gopts, grpc.KeepaliveParams(keepalive.ServerParameters{
            Time:    e.cfg.GRPCKeepAliveInterval,
            Timeout: e.cfg.GRPCKeepAliveTimeout,
        }))
    }
    // start client servers in each goroutine
    for _, sctx := range e.sctxs {
        go func(s *serveCtx) { // 这里正式启动多个 client server， 包括不同的协议
            e.errHandler(s.serve(e.Server, &e.cfg.ClientTLSInfo, h, e.errHandler, gopts...))
        }(sctx)
    }
    return nil
}

// 上面函数中 s.serve 函数的实现
// serve accepts incoming connections on the listener l,
// creating a new service goroutine for each. The service goroutines
// read requests and then call handler to reply to them.
// 这里使用了 github.com/soheilhy/cmux 来实现链接复用器
// 同一个链接可以根据其协议分发到不同的 server 协议处理
// 支持 grpc, ssh, http, https等
// 同一个链接依次只能是一个协议
// 根据协议头的前几个字段来判断协议
func (sctx *serveCtx) serve(
    s *etcdserver.EtcdServer,
    tlsinfo *transport.TLSInfo,
    handler http.Handler,
    errHandler func(error),
    gopts ...grpc.ServerOption) (err error) {
    logger := defaultLog.New(ioutil.Discard, "etcdhttp", 0)
    <-s.ReadyNotify()

    if sctx.lg == nil {
        plog.Info("ready to serve client requests")
    }

    m := cmux.New(sctx.l)
    v3c := v3client.New(s)
    servElection := v3election.NewElectionServer(v3c)
    servLock := v3lock.NewLockServer(v3c)

    var gs *grpc.Server
    defer func() {
        if err != nil && gs != nil {
            gs.Stop()
        }
    }()
    // http 请求
    if sctx.insecure {
        gs = v3rpc.Server(s, nil, gopts...)
        v3electionpb.RegisterElectionServer(gs, servElection)
        v3lockpb.RegisterLockServer(gs, servLock)
        if sctx.serviceRegister != nil {
            sctx.serviceRegister(gs)
        }
        // 匹配 HTTP2 协议
        grpcl := m.Match(cmux.HTTP2())
        // 启动 grpc server
        go func() { errHandler(gs.Serve(grpcl)) }()

        var gwmux *gw.ServeMux
        if s.Cfg.EnableGRPCGateway {
            gwmux, err = sctx.registerGateway([]grpc.DialOption{grpc.WithInsecure()})
            if err != nil {
                return err
            }
        }

        httpmux := sctx.createMux(gwmux, handler)

        srvhttp := &http.Server{
            Handler:  createAccessController(sctx.lg, s, httpmux),
            ErrorLog: logger, // do not log user error
        }
        // 匹配 HTTP1 协议
        httpl := m.Match(cmux.HTTP1())
        // 启动 client HTTP Server
        go func() { errHandler(srvhttp.Serve(httpl)) }()
        sctx.serversC <- &servers{grpc: gs, http: srvhttp}
        ...
    }
    // https 请求
    if sctx.secure {
    ...
    }
    close(sctx.serversC)
    return m.Serve()
}

const (
    mutexLocked = 1 << iota     // 1 = 0b001
    mutexWoken                  // 2 = 0b010
    mutexStarving               // 4 = 0b100
    mutexWaiterShift = iota     // 3  用来屏蔽低三位，取数量
    starvationThresholdNs = 1e6 // 10^6 ns = 1 ms
)

type Mutex struct {
    state int32
    sema  uint32
}

func (m *Mutex) lockSlow() {
    var waitStartTime int64 // 开始等待锁的时间点
    starving := false // 当前 goroutine 是否处于饥饿状态
    awoke := false    // 当前 goroutine 是否被唤醒
    iter := 0         //
    old := m.state    // 当前锁的状态
    for {
        // Don't spin in starvation mode, ownership is handed off to waiters
        // so we won't be able to acquire the mutex anyway.
        // 饥饿模式不要自旋， 因为锁的所有权回直接交给 waiters, 所以我们不会获取到锁
        // 条件翻译为伪代码: isLocked() && isNotStarving() && canSpin() 
        if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
            // Active spinning makes sense.
            // Try to set mutexWoken flag to inform Unlock
            // to not wake other blocked goroutines.
            //  尝试设置 mutexWoken  标志来通知 Unlock 不唤醒其它被阻塞的 goroutine
            //  条件可以转换为: 当前 goroutine 没有被唤醒     && 
                                锁状态没有被唤醒              && 
                                等待获取锁的 goroutine 不为 0 && 
                                锁的状态改从未唤醒更新为 被唤醒
            if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
                atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
                awoke = true // 设置当前 goroutine 为唤醒状态
            }
            runtime_doSpin() // 进入自旋
            iter++
            old = m.state // 更新锁状态
            continue
        }

        // 经过上一步后，锁和状态的组合有下面几个:
        // 获取锁   + 正常模式
        // 获取锁   + 饥饿模式
        // 未获取锁 + 正常模式
        // 未获取锁 + 饥饿模式
        new := old
        // Don't try to acquire starving mutex, new arriving goroutines must queue.
        // 正常模式: 期望设置为获取锁
        // 如果是饥饿模式, 新来的 goroutine 必须放到锁队列尾部排队
        if old&mutexStarving == 0 {
            new |= mutexLocked
        }
        // (锁被获取 || 饥饿模式): 等待锁的 goroutine 数量 +1
        if old&(mutexLocked|mutexStarving) != 0 {
            new += 1 << mutexWaiterShift
        }
        // The current goroutine switches mutex to starvation mode.
        // But if the mutex is currently unlocked, don't do the switch.
        // Unlock expects that starving mutex has waiters, which will not
        // be true in this case.
        // 当前 gorutine 是（饥饿状态 && 锁被获取): 期望设置锁状态为饥饿模式
        if starving && old&mutexLocked != 0 {
            new |= mutexStarving
        }
        // 当前 goroutine 处于被唤醒状态
        if awoke {
            // The goroutine has been woken from sleep,
            // so we need to reset the flag in either case.
            // 如果锁状态为被唤醒状态，证明存在冲突
            if new&mutexWoken == 0 {
                throw("sync: inconsistent mutex state")
            }
            //  new 期望设置为非被唤醒状态
            new &^= mutexWoken
        }
        // 更新锁状态为  从 old 变为 new
        if atomic.CompareAndSwapInt32(&m.state, old, new) {
            // old 原来锁状态不是被获取 && 锁状态不是饥饿状态
            // 根据前面的条件 new 现在是获取锁状态
            // old 和 new 交换成功，所以当前 goroutine 获取到了锁, 直接返回
            if old&(mutexLocked|mutexStarving) == 0 {
                break // locked the mutex with CAS
            }
            // 走到这里: old 是被获取 || old 是饥饿状态
            // waitStartTime != 0 证明等待过, 否则未等待过
            // If we were already waiting before, queue at the front of the queue.
            queueLifo := waitStartTime != 0 // true or false
            if waitStartTime == 0 {
                waitStartTime = runtime_nanotime()
            }
            // 如果等待过则放到锁队列头
            // 否则放到锁队列尾部
            runtime_SemacquireMutex(&m.sema, queueLifo, 1)
            // 如果等待时间超过了 starvationThresholdNs (1ms), 则设置当前 goroutine 为饥饿模式
            starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
            old = m.state
            // 如果原来处于饥饿模式
            if old&mutexStarving != 0 {
                // If this goroutine was woken and mutex is in starvation mode,
                // ownership was handed off to us but mutex is in somewhat
                // inconsistent state: mutexLocked is not set and we are still
                // accounted as waiter. Fix that.
                // 如果当前 goroutine 处于饥饿模式, 但是 mutex出一些冲突的状态: mutexLocked 状态没有设置，当前 goroutine 仍处于 waiter 中
                if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
                    throw("sync: inconsistent mutex state")
                }
                delta := int32(mutexLocked - 1<<mutexWaiterShift)
                // 当前 goroutine 不是饥饿状态 || 等待的 gorouine == 1, 退出饥饿模式
                if !starving || old>>mutexWaiterShift == 1 {
                    // 退出饥饿模式
                    // Exit starvation mode.
                    // Critical to do it here and consider wait time.
                    // Starvation mode is so inefficient, that two goroutines
                    // can go lock-step infinitely once they switch mutex
                    // to starvation mode.
                    delta -= mutexStarving
                }
                //  等待队列数量 -1 &&  获取锁
                atomic.AddInt32(&m.state, delta)
                break
            }
            awoke = true
            iter = 0
        } else {
            old = m.state // 更新 state
        }
    }

    if race.Enabled {
        race.Acquire(unsafe.Pointer(m))
    }
}

package main

type Mather interface {
    Sub(a, b int64) int64
    Add(a, b int32) int32
}

type Caller interface {
    Name() string
}

type Adder struct{ id int32 }

func main() {
    adder := Adder{id: 6754}
    CallAdd(adder)
    CallSub(adder)
    CallName(adder)
}

//go:noinline
func (adder Adder) Add(a, b int32) int32 { return a + b }

//go:noinline
func (adder Adder) Sub(a, b int64) int64 { return a - b }

//go:noinline
func (adder Adder) Name() string { return "Adder" }

func CallAdd(m Mather) {
    m.Add(12, 2)
}

func CallSub(m Mather) {
    m.Sub(19, 4)
}

func CallName(c Caller) {
    c.Name()
}