queue_channel.go

package main

import (
	"sync"
)

type node[T any] struct {
	prev *node[T]
	item T
	next *node[T]
}

type QueueChannel[T any] struct {
	lock sync.Mutex
	cond *sync.Cond
	head *node[T]
	tail *node[T]
}

func NewQueueChannel[T any]() *QueueChannel[T] {
	this := &QueueChannel[T]{}
	this.cond = sync.NewCond(&this.lock)
	return this
}

func (qc *QueueChannel[T]) Push(item T) {
	// Synchronization
	qc.lock.Lock()
	defer qc.lock.Unlock()

	// Add new item to the head of the list
	new_node := &node[T]{prev: nil, item: item, next: nil}
	if qc.head == nil {
		// Edge case where queue is empty
		qc.head = new_node
		qc.tail = new_node
	} else {
		// General Case
		new_node.next = qc.head
		qc.head.prev = new_node
		qc.head = new_node
	}

	// Wake a go routine trying to call Pop()
	qc.cond.Signal()
}

func (qc *QueueChannel[T]) Pop() T {
	// Synchronization
	qc.lock.Lock()
	defer qc.lock.Unlock()

	// Edge case where queue is empty: release lock and wait for new items
	for qc.head == nil {
		qc.cond.Wait()
	}

	// Edge case where queue is only one element
	if qc.tail == qc.head {
		item := qc.tail.item
		qc.head, qc.tail = nil, nil
		return item
	}

	// General Case
	item := qc.tail.item
	qc.tail = qc.tail.prev
	qc.tail.next = nil
	return item
}