a lock-free fixed-size single-producer multi-consumer queue 无锁 单生产者多消费者

Go\src\sync\poolqueue.go

// poolDequeue is a lock-free fixed-size single-producer,

// multi-consumer queue. The single producer can both push and pop

// from the head, and consumers can pop from the tail.

//

// It has the added feature that it nils out unused slots to avoid

// unnecessary retention of objects. This is important for sync.Pool,

// but not typically a property considered in the literature.

type poolDequeue struct {

    // headTail packs together a 32-bit head index and a 32-bit

    // tail index. Both are indexes into vals modulo len(vals)-1.

    //

    // tail = index of oldest data in queue

    // head = index of next slot to fill

    //

    // Slots in the range [tail, head) are owned by consumers.

    // A consumer continues to own a slot outside this range until

    // it nils the slot, at which point ownership passes to the

    // producer.

    //

    // The head index is stored in the most-significant bits so

    // that we can atomically add to it and the overflow is

    // harmless.

    headTail uint64

    // vals is a ring buffer of interface{} values stored in this

    // dequeue. The size of this must be a power of 2.

    //

    // vals[i].typ is nil if the slot is empty and non-nil

    // otherwise. A slot is still in use until *both* the tail

    // index has moved beyond it and typ has been set to nil. This

    // is set to nil atomically by the consumer and read

    // atomically by the producer.

    vals []eface

}