// CAS操作，当时还没有抽象出atomic包
    func cas(val *int32, old, new int32) bool
    func semacquire(*int32)
    func semrelease(*int32)
    // 互斥锁的结构，包含两个字段
    type Mutex struct {
        key  int32 // 锁是否被持有的标识
        sema int32 // 信号量专用，用以阻塞/唤醒goroutine
    }
    
    // 保证成功在val上增加delta的值
    func xadd(val *int32, delta int32) (new int32) {
        for {
            v := *val
            if cas(val, v, v+delta) {
                return v + delta
            }
        }
        panic("unreached")
    }
    
    // 请求锁
    func (m *Mutex) Lock() {
        if xadd(&m.key, 1) == 1 { //标识加1，如果等于1，成功获取到锁
            return
        }
        semacquire(&m.sema) // 否则阻塞等待
    }
    
    func (m *Mutex) Unlock() {
        if xadd(&m.key, -1) == 0 { // 将标识减去1，如果等于0，则没有其它等待者
            return
        }
        semrelease(&m.sema) // 唤醒其它阻塞的goroutine
    }

type Mutex struct {
	state int32  //表示当前互斥锁的状态
	sema  uint32 //用于控制锁状态的信号量
}

atomic.CompareAndSwapInt32(&m.state, old, new)
//更新m.state字段之前先比较m.state和old是否相等，如果相等，new写入m.state,函数返回true；如果不相等，返回函数false。
//CAS机制中的这些步骤是原子性的（从指令层面提供的原子操作），所以CAS机制可以解决多线程并发编程对共享变量读写的原子性问题

func sync_runtime_doSpin() {
	procyield(active_spin_cnt)
}

TEXT runtime·procyield(SB),NOSPLIT,$0-0
	MOVL	cycles+0(FP), AX
again:
	PAUSE
	SUBL	$1, AX
	JNZ	again
	RET

type RWMutex struct {
	w           Mutex //为 writer 的竞争锁而设计；
	writerSem   uint32 //都是为了阻塞设计的信号量。
	readerSem   uint32 //都是为了阻塞设计的信号量。
	readerCount int32 //记录当前 reader 的数量（以及是否有 writer 竞争锁）；
	readerWait  int32 //记录 writer 请求锁时需要等待 read 完成的 reader 的数量；
}

func (rw *RWMutex) RLock() {
	if atomic.AddInt32(&rw.readerCount, 1) < 0 {
    // rw.readerCount是负值的时候，意味着此时有writer等待请求锁，因为writer优先级高，所以把后来的reader阻塞休眠
		runtime_SemacquireMutex(&rw.readerSem, false, 0)
	}
}

func (rw *RWMutex) RUnlock() {
	if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {
    // 有等待的writer
		rw.rUnlockSlow(r)
	}
}
func (rw *RWMutex) rUnlockSlow(r int32) {
  if atomic.AddInt32(&rw.readerWait, -1) == 0 { 
    // 最后一个reader了，writer终于有机会获得锁了
    runtime_Semrelease(&rw.writerSem, false, 1) 
  }
}

func (rw *RWMutex) Lock() {
	// 首先解决其他writer竞争问题
	rw.w.Lock()
	// 反转readerCount，告诉reader有writer竞争锁
	r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
	if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
    // 如果当前有reader持有锁，那么需要等待
		runtime_SemacquireMutex(&rw.writerSem, false, 0)
	}
}

func (rw *RWMutex) Unlock() {
	// 告诉reader没有活跃的writer了
	r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
	if r >= rwmutexMaxReaders {
		throw("sync: Unlock of unlocked RWMutex")
	}
	for i := 0; i < int(r); i++ {
    // 唤醒阻塞的reader们
		runtime_Semrelease(&rw.readerSem, false, 0)
	}
  	rw.w.Unlock()
}

type WaitGroup struct {
	noCopy noCopy
	state1 [3]uint32
}

type WaitGroup struct {
    // 避免复制使用的一个技巧，可以告诉vet工具违反了复制使用的规则
    noCopy noCopy
    // 64bit(8bytes)的值分成两段，高32bit是计数值，低32bit是waiter的计数
    // 另外32bit是用作信号量的
    // 因为64bit值的原子操作需要64bit对齐，但是32bit编译器不支持，所以数组中的元素在不同的架构中不一样，具体处理看下面的方法
    // 总之，会找到对齐的那64bit作为state，其余的32bit做信号量
    state1 [3]uint32
}


// 得到state的地址和信号量的地址
func (wg *WaitGroup) state() (statep *uint64, semap *uint32) {
    if uintptr(unsafe.Pointer(&wg.state1))%8 == 0 {
        // 如果地址是64bit对齐的，数组前两个元素做state，后一个元素做信号量
        return (*uint64)(unsafe.Pointer(&wg.state1)), &wg.state1[2]
    } else {
        // 如果地址是32bit对齐的，数组后两个元素用来做state，它可以用来做64bit的原子操作，第一个元素32bit用来做信号量
       //&wg.state1[0]是32位对齐的，&wg.state1[0]+4也就是&wg.state1[1]是64位对齐的
        return (*uint64)(unsafe.Pointer(&wg.state1[1])), &wg.state1[0]
    }
}

func (wg *WaitGroup) Add(delta int) {
    statep, semap := wg.state()
    // 高32bit是计数值v，所以把delta左移32，增加到计数上
    state := atomic.AddUint64(statep, uint64(delta)<<32)
    v := int32(state >> 32) // 当前计数值
    w := uint32(state) // waiter count

  	if v < 0 {
		   panic("sync: negative WaitGroup counter")
	  }
    if v > 0 || w == 0 {
        return
    }
    // 执行到这里v = 0 && w >0。v = 0说明所有goroutine都完成了，w > 0说明有等待被唤醒的goroutine
    if *statep != state {
       //此刻别再调Add增加counter或者调Wait增加waiter了，防止滥用wg
		   panic("sync: WaitGroup misuse: Add called concurrently with Wait")
	  }
    *statep = 0 // 将waiter的数量设置为0，因为计数值v也是0,所以它们俩的组合*statep直接设置为0即可
    for ; w != 0; w-- { //唤醒所有的waiter
        runtime_Semrelease(semap, false, 0)
    }
}

// Done方法实际就是计数器减1
func (wg *WaitGroup) Done() {
    wg.Add(-1)
}

func (wg *WaitGroup) Wait() {
    statep, semap := wg.state()
    
    for {
        state := atomic.LoadUint64(statep)
        v := int32(state >> 32) // 当前计数值
        w := uint32(state) // waiter的数量
        if v == 0 {
            // 如果计数值为0, 调用这个方法的goroutine不必再等待，继续执行它后面的逻辑即可
            return
        }
        // 否则把waiter数量加1。期间可能有并发调用Wait的情况，所以最外层使用了一个for循环
        if atomic.CompareAndSwapUint64(statep, state, state+1) {
            // 阻塞休眠等待
            runtime_Semacquire(semap)
          	if *statep != 0 {
               //这轮wait还没完成，就开始重用wg。例如调用Wait后，接着又调用了Add
				       panic("sync: WaitGroup is reused before previous Wait has returned")
			      }
            // 被唤醒，不再阻塞，返回
            return
        }
    }
}

runtime_Semacquire(semap)
//semap为state中的信号量。该方法阻塞等待直到semap>0，然后执行semap-1

runtime_Semrelease(semap, false, 0)
//semap为state中的信号量。该方法执行semap+1

type Once struct {
	done uint32
	m    Mutex
}

func (o *Once) Do(f func()) {
	if atomic.LoadUint32(&o.done) == 0 { //第一次检查，f已经调用过之后的检查
		o.doSlow(f) //f没被调用过，多个Goroutine可能争夺调用权
	}
}

func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()
  if o.done == 0 {
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

func main() {
    var once sync.Once
    once.Do(func() {
        once.Do(func() {
            fmt.Println("初始化")
        })
    })
}

// 一个功能更加强大的Once
type Once struct {
    m    sync.Mutex
    done uint32
}
// 传入的函数f有返回值error，如果初始化失败，需要返回失败的error
// Do方法会把这个error返回给调用者
func (o *Once) Do(f func() error) error {
    if atomic.LoadUint32(&o.done) == 1 { //fast path
        return nil
    }
    return o.slowDo(f)
}
// 如果还没有初始化
func (o *Once) slowDo(f func() error) error {
    o.m.Lock()
    defer o.m.Unlock()
    var err error
    if o.done == 0 { // 双检查，还没有初始化
        err = f()
        if err == nil { // 初始化成功才将标记置为已初始化
            atomic.StoreUint32(&o.done, 1)
        }
    }
    return err
}

//    c.L.Lock()
//    for !condition() {
//        c.Wait()
//    }
//    ... make use of condition ...
//    c.L.Unlock()
//
func (c *Cond) Wait() {
	c.checker.check()
	t := runtime_notifyListAdd(&c.notify)
	c.L.Unlock()
	runtime_notifyListWait(&c.notify, t)
	c.L.Lock()
}

type Pool struct {
	noCopy noCopy

	local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
  //存放poolLocal
  
	localSize uintptr        // size of the local array ，localSize == runtime.GOMAXPROCS(0)

	victim     unsafe.Pointer // local from previous cycle
	victimSize uintptr        // size of victims array

	// New optionally specifies a function to generate
	// a value when Get would otherwise return nil.
	// It may not be changed concurrently with calls to Get.
	New func() any
}

	// Local per-P Pool appendix.
type poolLocalInternal struct {
	private any       // Can be used only by the respective P.private，代表一个缓存的元素，而且只能由相应的一个 P 存取。因为一个 P 同时只能执行一个 goroutine，所以不会有并发的问题。
	shared  poolChain // Local P can pushHead/popHead; any P can popTail.shared，可以由任意的 P 访问，但是只有本地的 P 才能 pushHead/popHead，其它 P 可以 popTail，相当于只有一个本地的 P 作为生产者（Producer），多个 P 作为消费者（Consumer），它是使用一个 local-free 的 queue 列表实现的。
}

func (p *Pool) Get() interface{} {
  // 把当前goroutine固定在当前的P上
  //pin 方法会将此 goroutine 固定在当前的 P 上，避免查找元素期间被其它的 P 执行。固定的好处就是查找元素期间直接得到跟这个 P 相关的 local。直接得到P相关的local又如何？
    l, pid := p.pin()
    x := l.private // 优先从local的private字段取，快速
    l.private = nil
    if x == nil {
        // 从当前的local.shared弹出一个，注意是从head读取并移除
        x, _ = l.shared.popHead()
        if x == nil { // 如果没有，则去偷一个
            x = p.getSlow(pid) 
        }
    }
    runtime_procUnpin()
    // 如果没有获取到，尝试使用New函数生成一个新的
    if x == nil && p.New != nil {
        x = p.New()
    }
    return x
}

func (p *Pool) getSlow(pid int) any {
	size := runtime_LoadAcquintptr(&p.localSize) // load-acquire
	locals := p.local                            // load-consume
	// Try to steal one element from other procs.
	for i := 0; i < int(size); i++ {
		l := indexLocal(locals, (pid+i+1)%int(size))
		if x, _ := l.shared.popTail(); x != nil {
			return x
		}
	}

	// Try the victim cache. We do this after attempting to steal
	// from all primary caches because we want objects in the
	// victim cache to age out if at all possible.
	size = atomic.LoadUintptr(&p.victimSize)
	if uintptr(pid) >= size {
		return nil
	}
	locals = p.victim
	l := indexLocal(locals, pid)
	if x := l.private; x != nil {
		l.private = nil
		return x
	}
	for i := 0; i < int(size); i++ {
		l := indexLocal(locals, (pid+i)%int(size))
		if x, _ := l.shared.popTail(); x != nil {
			return x
		}
	}

	return nil
}

func (p *Pool) Put(x interface{}) {
    if x == nil { // nil值直接丢弃
        return
    }
    l, _ := p.pin() // 把当前goroutine固定在当前的P上
    if l.private == nil { // 如果本地private没有值，直接设置这个值即可
        l.private = x
        x = nil
    }
    if x != nil { // 否则加入到本地队列中
        l.shared.pushHead(x)
    }
    runtime_procUnpin()
}

//将当前g绑定在P上
func (p *Pool) pin() (*poolLocal, int) {
	pid := runtime_procPin()
	s := runtime_LoadAcquintptr(&p.localSize) // load-acquire
	l := p.local                          
	if uintptr(pid) < s {
		return indexLocal(l, pid), pid     // 通过pid获取当前g所在P对应的poolLocal
	}
	return p.pinSlow()
}
func (p *Pool) pinSlow() (*poolLocal, int) {
	// Retry under the mutex.
	// Can not lock the mutex while pinned.
	runtime_procUnpin()
	allPoolsMu.Lock()
	defer allPoolsMu.Unlock()
	pid := runtime_procPin()
	// poolCleanup won't be called while we are pinned.
	s := p.localSize
	l := p.local
	if uintptr(pid) < s {
		return indexLocal(l, pid), pid
	}
	if p.local == nil {
		allPools = append(allPools, p)
	}
	// If GOMAXPROCS changes between GCs, we re-allocate the array and lose the old one.
	size := runtime.GOMAXPROCS(0)
	local := make([]poolLocal, size)   //创建poolLocal切片，len=P数量
	atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
	runtime_StoreReluintptr(&p.localSize, uintptr(size))     // store-release
	return &local[pid], pid
}

func poolCleanup() {
    // 丢弃当前victim, STW所以不用加锁
    for _, p := range oldPools {
        p.victim = nil
        p.victimSize = 0
    }

    // 将local复制给victim, 并将原local置为nil
    for _, p := range allPools {
        p.victim = p.local
        p.victimSize = p.localSize
        p.local = nil
        p.localSize = 0
    }

    oldPools, allPools = allPools, nil
}

//标准库http
var (
	http2dataChunkSizeClasses = []int{
		1 << 10,
		2 << 10,
		4 << 10,
		8 << 10,
		16 << 10,
	}
	http2dataChunkPools = [...]sync.Pool{
		{New: func() interface{} { return make([]byte, 1<<10) }},
		{New: func() interface{} { return make([]byte, 2<<10) }},
		{New: func() interface{} { return make([]byte, 4<<10) }},
		{New: func() interface{} { return make([]byte, 8<<10) }},
		{New: func() interface{} { return make([]byte, 16<<10) }},
	}
)

func http2getDataBufferChunk(size int64) []byte {
	i := 0
	for ; i < len(http2dataChunkSizeClasses)-1; i++ {
		if size <= int64(http2dataChunkSizeClasses[i]) {
			break
		}
	}
	return http2dataChunkPools[i].Get().([]byte)
}

func http2putDataBufferChunk(p []byte) {
	for i, n := range http2dataChunkSizeClasses {
		if len(p) == n {
			http2dataChunkPools[i].Put(p)
			return
		}
	}
	panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
}

//fmt包
func (p *pp) free() {
	// Proper usage of a sync.Pool requires each entry to have approximately
	// the same memory cost. To obtain this property when the stored type
	// contains a variably-sized buffer, we add a hard limit on the maximum buffer
	// to place back in the pool.
	//
	// See https://golang.org/issue/23199
  //限制放回的大小
	if cap(p.buf) > 64<<10 {
		return
	}

	p.buf = p.buf[:0]
	p.arg = nil
	p.value = reflect.Value{}
	p.wrappedErr = nil
	ppFree.Put(p)
}

type workerPool struct {
	// Function for serving server connections.
	// It must leave c unclosed.
	WorkerFunc ServeHandler

	MaxWorkersCount int

	LogAllErrors bool

	MaxIdleWorkerDuration time.Duration

	Logger Logger

	lock         sync.Mutex
	workersCount int

	ready []*workerChan //就绪的worker

	stopCh chan struct{}

	workerChanPool sync.Pool
}

type workerChan struct {
	lastUseTime time.Time
	ch          chan net.Conn

func (s *Server) Serve(ln net.Listener) error {
  ...
  //初始化workpool
  	wp := &workerPool{
		WorkerFunc:            s.serveConn,
		MaxWorkersCount:       maxWorkersCount,
		LogAllErrors:          s.LogAllErrors,
		MaxIdleWorkerDuration: s.MaxIdleWorkerDuration,
		Logger:                s.logger(),
		connState:             s.setState,
	}
	wp.Start()
  for {
    //Accept拿到net.conn
		if c, err = acceptConn(s, ln, &lastPerIPErrorTime); err != nil {
			wp.Stop()
			if err == io.EOF {
				return nil
			}
			return err
		}
    //将Accept到的net.conn放入channel中,无缓冲或缓冲为1
    if !wp.Serve(c) {
      ...
    }
  }
}
func (wp *workerPool) Serve(c net.Conn) bool {
  //获取ready worker的ch，没有则创建
	ch := wp.getCh()
	if ch == nil {
		return false
	}
  //将net.conn放入channel
	ch.ch <- c
	return true
}

func (wp *workerPool) getCh() *workerChan {
   var ch *workerChan
   createWorker := false

   wp.lock.Lock()
   ready := wp.ready
   n := len(ready) - 1
   if n < 0 {
      if wp.workersCount < wp.MaxWorkersCount { //默认最多256 * 1024个worker
         createWorker = true
         wp.workersCount++
      }
   } else {
      ch = ready[n]
      ready[n] = nil
      wp.ready = ready[:n]
   }
   wp.lock.Unlock()

   if ch == nil {
      if !createWorker {
         return nil
      }
      //没有可用worker，创建
      vch := wp.workerChanPool.Get()
      ch = vch.(*workerChan)
      go func() {
         wp.workerFunc(ch) //从channel中拿取net.conn,并处理
         wp.workerChanPool.Put(vch)
      }()
   }
   return ch
}

/ 无休止的进餐和冥想.
// 吃完睡(冥想、打坐), 睡完吃.
// 可以调整吃睡的时间来增加或者减少抢夺叉子的机会.
func (p *Philosopher) dine() {
    for {
        mark(p, "冥想")
        randomPause(10)

        mark(p, "饿了")
        if p.ID == 5 { //
            p.rightChopstick.Lock() // 先尝试拿起第1只筷子
            mark(p, "拿起左手筷子")
            p.leftChopstick.Lock() // 再尝试拿起第5只筷子

            mark(p, "用膳")
            randomPause(10)

            p.leftChopstick.Unlock()  // 先尝试放下第5只的筷子
            p.rightChopstick.Unlock() // 再尝试放下第1只的筷子
        } else {
            p.leftChopstick.Lock() // 先尝试拿起左手边的筷子(第n只)
            mark(p, "拿起右手筷子")
            p.rightChopstick.Lock() // 再尝试拿起右手边的筷子(第n+1只)

            mark(p, "用膳")
            randomPause(10)

            p.rightChopstick.Unlock() // 先尝试放下右手边的筷子
            p.leftChopstick.Unlock()  // 再尝试拿起左手边的筷子
        }

    }
}

type Philosopher struct {
    // 哲学家的名字
    name string
    // 左手一只和右手一只筷子
    leftChopstick, rightChopstick *Chopstick
    status                        string

    mu *sync.Mutex
}

// 无休止的进餐和冥想.
// 吃完睡(冥想、打坐), 睡完吃.
// 可以调整吃睡的时间来增加或者减少抢夺叉子的机会.
func (p *Philosopher) dine() {
    for {
        mark(p, "冥想")
        randomPause(10)

        mark(p, "饿了")
        p.mu.Lock() // 服务生控制
        p.leftChopstick.Lock() // 先尝试拿起左手边的筷子
        mark(p, "拿起左手筷子")
        p.rightChopstick.Lock() // 再尝试拿起右手边的筷子
        p.mu.Unlock() 

        mark(p, "用膳")
        randomPause(10)

        p.rightChopstick.Unlock() // 先尝试放下右手边的筷子
        p.leftChopstick.Unlock()  // 再尝试拿起左手边的筷子
    }
}

type semaRoot struct {
	lock  mutex
	treap *sudog // root of balanced tree of unique waiters.
	nwait uint32 // Number of waiters. Read w/o the lock.
}

const semTabSize = 251
var semtable [semTabSize]struct {
   root semaRoot //树
   pad  [cpu.CacheLinePadSize - unsafe.Sizeof(semaRoot{})]byte
}

func semroot(addr *uint32) *semaRoot {
  //通过计算(信号量地址>>3%251),选择251棵树中其中一颗
	return &semtable[(uintptr(unsafe.Pointer(addr))>>3)%semTabSize].root
}