l, _ := p.pin()
if l.private == nil {
	l.private = x
} else {
	l.shared.pushHead(x)
}
runtime_procUnpin()

type poolDequeue struct {
	headTail atomic.Uint64
	vals []eface
}

func (d *poolDequeue) pushHead(val any) bool {
	ptrs := d.headTail.Load()
	head, tail := d.unpack(ptrs)
	if (tail+uint32(len(d.vals)))&(1<<dequeueBits-1) == head {
		// 队列满
		return false
	}
	slot := &d.vals[head&uint32(len(d.vals)-1)]
    // 检查 head slot 是否被 popTail 释放
	typ := atomic.LoadPointer(&slot.typ)
	if typ != nil {
        // 另一个 goroutine 正在清理 tail，所以队列还是满的
		return false
	}
    // 如果值为空，那么设置一个特殊值
	if val == nil {
		val = dequeueNil(nil)
	}
    // 队列头是空的，将数据写入 slot
	*(*any)(unsafe.Pointer(slot)) = val // ①
    // 增加 head，这样 popTail 就可以消费这个 slot 了
    // 同时也是一个 store barrier，保证了 slot 的写入
	d.headTail.Add(1 << dequeueBits)
	return true
}

func (d *poolDequeue) popTail() (any, bool) {
	var slot *eface
	for { // ②
		ptrs := d.headTail.Load()
		head, tail := d.unpack(ptrs)
		if tail == head {
			// 队列为空
			return nil, false
		}
        // 确认头部和尾部（用于我们之前的推测性检查），并递增尾部。如果成功，那么我们就拥有了尾部的插槽。
		ptrs2 := d.pack(head, tail+1)
		if d.headTail.CompareAndSwap(ptrs, ptrs2) {
			// 成功读取了一个 slot
			slot = &d.vals[tail&uint32(len(d.vals)-1)]
			break
		}
	}
	// 剩下来就是读取槽位的值
	val := *(*any)(unsafe.Pointer(slot))
	if val == dequeueNil(nil) { // 如果本身就存储的nil
		val = nil
	}
    // 释放 slot，这样 pushHead 就可以继续写入这个 slot 了
	slot.val = nil // ③
	atomic.StorePointer(&slot.typ, nil) // ④
	
	return val, true
}

func (d *poolDequeue) popHead() (any, bool) {
	var slot *eface
	for {
		ptrs := d.headTail.Load()
		head, tail := d.unpack(ptrs)
		if tail == head {
			// 队列为空
			return nil, false
		}
        // 确认头部和尾部（用于我们之前的推测性检查），并递减头部。如果成功，那么我们就拥有了头部的插槽。
		head--
		ptrs2 := d.pack(head, tail)
		if d.headTail.CompareAndSwap(ptrs, ptrs2) {
            // 成功取回了一个 slot
			slot = &d.vals[head&uint32(len(d.vals)-1)]
			break
		}
	}
	val := *(*any)(unsafe.Pointer(slot))
	if val == dequeueNil(nil) {
		val = nil
	}
	
    // 释放 slot，这样 pushHead 就可以继续写入这个 slot 了
	*slot = eface{}
	return val, true
}

type poolChain struct {
    // head 是生产者用来push的 poolDequeue。只有生产者访问，所以不需要同步
	head *poolChainElt
    // tail 是消费者用来pop的 poolDequeue。消费者访问，所以需要原子操作
	tail atomic.Pointer[poolChainElt]
}
type poolChainElt struct {
	poolDequeue
    // next由生产者原子写入，消费者原子读取。它只能从nil转换为非nil。
    // prev由消费者原子写入，生产者原子读取。它只能从非nil转换为nil。
	next, prev atomic.Pointer[poolChainElt]
}

package gods
import (
	"sync"
	"testing"
)
func BenchmarkPoolDequeue(b *testing.B) {
	const size = 1024
	pd := NewPoolDequeue(size)
	var wg sync.WaitGroup
	// Producer
	go func() {
		for i := 0; i < b.N; i++ {
			pd.PushHead(i)
		}
		wg.Done()
	}()
	// Consumers
	numConsumers := 10
	wg.Add(numConsumers + 1)
	for i := 0; i < numConsumers; i++ {
		go func() {
			for {
				if _, ok := pd.PopTail(); !ok {
					break
				}
			}
			wg.Done()
		}()
	}
	wg.Wait()
}
func BenchmarkPoolChain(b *testing.B) {
	pc := NewPoolChain()
	var wg sync.WaitGroup
	// Producer
	go func() {
		for i := 0; i < b.N; i++ {
			pc.PushHead(i)
		}
		wg.Done()
	}()
	// Consumers
	numConsumers := 10
	wg.Add(numConsumers + 1)
	for i := 0; i < numConsumers; i++ {
		go func() {
			for {
				if _, ok := pc.PopTail(); !ok {
					break
				}
			}
			wg.Done()
		}()
	}
	wg.Wait()
}
func BenchmarkChannel(b *testing.B) {
	ch := make(chan interface{}, 1024)
	var wg sync.WaitGroup
	// Producer
	go func() {
		for i := 0; i < b.N; i++ {
			ch <- i
		}
		close(ch)
		wg.Done()
	}()
	// Consumers
	numConsumers := 10
	wg.Add(numConsumers + 1)
	for i := 0; i < numConsumers; i++ {
		go func() {
			for range ch {
			}
			wg.Done()
		}()
	}
	wg.Wait()
}