Lock-Free Stack Implementation via Atomic Pointers

package main
 
import (
	"fmt"
	"sync/atomic"
)
 
type Node[T any] struct {
	value T
	next  *Node[T]
}
 
type LockFreeStack[T any] struct {
	head atomic.Pointer[Node[T]]
}
 
func (s *LockFreeStack[T]) Push(val T) {
	n := &Node[T]{value: val}
	for {
		currHead := s.head.Load()
		n.next = currHead
		if s.head.CompareAndSwap(currHead, n) {
			return
		}
	}
}
 
func (s *LockFreeStack[T]) Pop() (T, bool) {
	var zero T
	for {
		currHead := s.head.Load()
		if currHead == nil {
			return zero, false
		}
		nextHead := currHead.next
		if s.head.CompareAndSwap(currHead, nextHead) {
			return currHead.value, true
		}
	}
}
 
func main() {
	stack := &LockFreeStack[int]{}
	stack.Push(42)
	val, _ := stack.Pop()
	fmt.Println(val)
}