Go语言sync.Once和sync.Cond的实现

package main
 
import (
	"fmt"
	"sync"
)
 
var (
	config map[string]string
	once   sync.Once
	wg     sync.WaitGroup
)
 
func loadConfig() {
	once.Do(func() {
		fmt.Println("Loading config...")
		config = map[string]string{"key": "value"}
	})
}
 
func main() {
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done() // 确保 goroutine 结束时减少计数器
			loadConfig()
		}()
	}
	wg.Wait() // 等待所有 goroutine 完成
}

type Cond struct {
    // 不可以对其进行值拷贝
    noCopy noCopy
    // 一个自旋锁
    L Locker
    // 一个队列，存放阻塞的goroutine
    notify  notifyList
    checker copyChecker
}
 
// NewCond returns a new Cond with Locker l.
func NewCond(l Locker) *Cond {
    return &Cond{L:l}
}

type notifyList struct {
    wait   uint32
    notify uint32
    lock   uintptr // key field of the mutex
    head   unsafe.Pointer
    tail   unsafe.Pointer
}

func (c *Cond) Wait() {
    c.checker.check()
    t := runtime_notifyListAdd(&c.notify)
    c.L.Unlock()
    runtime_notifyListWait(&c.notify, t)
    c.L.Lock()
}

func (c *Cond) Signal() {
    c.checker.check()
    runtime_notifyListNotifyOne(&c.notify)
}

func (c *Cond) Broadcast() {
    c.checker.check()
    runtime_notifyListNotifyAll(&c.notify)
}

package main
 
import (
	"fmt"
	"sync"
	"time"
)
 
func main() {
	var mu sync.Mutex
	cond := sync.NewCond(&mu)
	
	// 共享状态
	isReady := false
 
	// 等待条件的goroutine
	go func() {
		fmt.Println("等待者: 等待条件满足...")
		cond.L.Lock()
		defer cond.L.Unlock()
		
		// 使用循环防止虚假唤醒
		for !isReady {
			cond.Wait() // 释放锁并阻塞，唤醒时会重新获得锁
			fmt.Println("等待者: 被唤醒，检查条件")
		}
		fmt.Println("等待者: 条件已满足！")
	}()
 
	// 改变条件的goroutine
	go func() {
		time.Sleep(2 * time.Second) // 模拟耗时操作
		fmt.Println("触发者: 准备改变条件...")
		
		cond.L.Lock()
		isReady = true
		cond.L.Unlock()
		
		fmt.Println("触发者: 发送通知")
		cond.Signal() // 唤醒一个等待的goroutine
	}()
 
	time.Sleep(3 * time.Second) // 等待所有goroutine完成
}