import "sync"
var mutex sync.Mutex
func main() {
  mutex.Lock()    // 獲取鎖
  // 執(zhí)行需要同步的操作
  mutex.Unlock()  // 釋放鎖
}

package main
import (
    "fmt"
    "time"
)
var count int
func main() {
    for i := 0; i < 1000; i++ {
        go add()
    }
    time.Sleep(1 * time.Second)
    fmt.Println("count:", count)
}
func add() {
    count++
}

package main
import (
    "fmt"
    "sync"
    "time"
)
var (
    count int
    mutex sync.Mutex
)
func main() {
    for i := 0; i < 1000; i++ {
        go add()
    }
    time.Sleep(1 * time.Second)
    fmt.Println("count:", count)
}
func add() {
    mutex.Lock()
    count++
    mutex.Unlock()
}

package main
import (
    "fmt"
    "sync"
)
func main() {
    var mutex sync.Mutex
    go func() {
        mutex.Lock()
        fmt.Println("goroutine1 locked the mutex")
    }()
    go func() {
        fmt.Println("goroutine2 trying to lock the mutex")
        mutex.Lock()
        fmt.Println("goroutine2 locked the mutex")
    }()
}

type Counter struct {
    sync.Mutex
    Count int
}
func main(){
    var c Counter
    c.Lock()
    defer c.Unlock()
    c.Count++
    foo(c)
    fmt.println("done")
}
func foo(c Counter) {
    c.Lock()
    defer c.Unlock()
    fmt.println("foo done")
}

package main
import (
    "fmt"
    "sync"
)
func main() {
    var mu sync.Mutex
    mu.Lock()
    fmt.Println("First Lock")
    // 重復加鎖
    mu.Lock()
    fmt.Println("Second Lock")
    mu.Unlock()
    mu.Unlock()
}

// net/http transport.go
type Transport struct {
   lk       sync.Mutex
   idleConn map[string][]*persistConn
   altProto map[string]RoundTripper // nil or map of URI scheme => RoundTripper
}
func (t *Transport) CloseIdleConnections() {
   t.lk.Lock()
   defer t.lk.Unlock()
   if t.idleConn == nil {
      return
   }
   for _, conns := range t.idleConn {
      for _, pconn := range conns {
         pconn.close()
      }
   }
   t.idleConn = nil
}
func (t *Transport) RegisterProtocol(scheme string, rt RoundTripper) {
   if scheme == "http" || scheme == "https" {
      panic("protocol " + scheme + " already registered")
   }
   t.lk.Lock()
   defer t.lk.Unlock()
   if t.altProto == nil {
      t.altProto = make(map[string]RoundTripper)
   }
   if _, exists := t.altProto[scheme]; exists {
      panic("protocol " + scheme + " already registered")
   }
   t.altProto[scheme] = rt
}

type Transport struct {
   idleMu       sync.Mutex
   idleConn     map[connectMethodKey][]*persistConn // most recently used at end
   altMu    sync.Mutex   // guards changing altProto only
   altProto atomic.Value // of nil or map[string]RoundTripper, key is URI scheme   
}

//net/rpc server.go
type Server struct {
   serviceMap sync.Map   // map[string]*service
   reqLock    sync.Mutex // protects freeReq
   freeReq    *Request
   respLock   sync.Mutex // protects freeResp
   freeResp   *Response
}

// net/http transport.go
type Transport struct {
   idleMu       sync.Mutex
   closeIdle    bool                                // user has requested to close all idle conns
   idleConn     map[connectMethodKey][]*persistConn // most recently used at end
   idleConnWait map[connectMethodKey]wantConnQueue  // waiting getConns
   idleLRU      connLRU
   reqMu       sync.Mutex
   reqCanceler map[cancelKey]func(error)
   altMu    sync.Mutex   // guards changing altProto only
   altProto atomic.Value // of nil or map[string]RoundTripper, key is URI scheme
   connsPerHostMu   sync.Mutex
   connsPerHost     map[connectMethodKey]int
   connsPerHostWait map[connectMethodKey]wantConnQueue // waiting getConns
}

func (t *Transport) CloseIdleConnections() {
   t.lk.Lock()
   defer t.lk.Unlock()
   if t.idleConn == nil {
      return
   }
   for _, conns := range t.idleConn {
      for _, pconn := range conns {
         pconn.close()
      }
   }
   t.idleConn = nil
}

// net/http/httputil persist.go
func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error) {
   // Retrieve the pipeline ID of this request/response pair
   cc.mu.Lock()
   id, ok := cc.pipereq[req]
   delete(cc.pipereq, req)
   if !ok {
      cc.mu.Unlock()
      return nil, ErrPipeline
   }
   cc.mu.Unlock()
    // xxx 省略掉一些中間邏輯
   // 從http連接中讀取http響應數據, 這個IO操作,先解鎖
   resp, err = http.ReadResponse(r, req)
   // 網絡IO操作結束,再繼續(xù)讀取
   cc.mu.Lock()
   defer cc.mu.Unlock()
   if err != nil {
      cc.re = err
      return resp, err
   }
   cc.lastbody = resp.Body
   cc.nread++
   if resp.Close {
      cc.re = ErrPersistEOF // don't send any more requests
      return resp, cc.re
   }
   return resp, err
}