type safeResource struct {
	mu       sync.RWMutex
	resource map[string]string
}

func (s *safeResource) Add(k, v string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.resource[k] = v
}

// SafeMap 可以看做是 map 的一个线程安全的封装。
type SafeMap[K comparable, V any] struct {
	mu sync.RWMutex
	m  map[K]V
}

// 正确版本
// LoadOrStore 检查 map 中是否存在 key 对应的值，
// 若存在，则取出。若不存在，则存入新值 newVal。
func (s *SafeMap[K, V]) LoadOrStore(key K, newVal V) (V, bool) {
	s.mu.RLock()
	oldVal, ok := s.m[key]
	s.mu.RUnlock()
	if ok {
		return oldVal, true
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	// goroutine1 先执行，key => 1
	// goroutine2 再执行，key => 2
	// 值会被覆盖，所以要 double check

	oldVal, ok = s.m[key]
	if ok {
		return oldVal, true
	}

	s.m[key] = newVal
	return newVal, false
}

// 错误版本1: 死锁
func (s *SafeMap[K, V]) LoadOrStoreV1(key K, newVal V) (V, bool) {
	s.mu.RLock()
	oldVal, ok := s.m[key]
	defer s.mu.RUnlock()
	if ok {
		return oldVal, true
	}
	// 读锁未释放，再加写锁会死锁
	s.mu.Lock()
	defer s.mu.Unlock()

	oldVal, ok = s.m[key]
	if ok {
		return oldVal, true
	}

	s.m[key] = newVal
	return newVal, false
}

// 错误版本2: 覆盖
func (s *SafeMap[K, V]) LoadOrStoreV2(key K, newVal V) (V, bool) {
	s.mu.RLock()
	oldVal, ok := s.m[key]
	s.mu.RUnlock()
	if ok {
		return oldVal, true
	}
	s.mu.Lock()
	defer s.mu.Unlock()

	// 无 double check，值可能被覆盖
	s.m[key] = newVal
	return newVal, false
}

func TestLoadOrStoreV1(t *testing.T) {
	m := SafeMap[string, string]{
		m: map[string]string{},
	}
	m.LoadOrStoreV1("k", "v")
}

func TestLoadOrStoreV2(t *testing.T) {
	m := SafeMap[string, string]{
		m: map[string]string{},
	}

	var wg sync.WaitGroup
	wg.Add(2)
	los := func(k, v string) {
		m.LoadOrStoreV2(k, v)
		wg.Done()
	}
	time.AfterFunc(time.Second, func() {
		go los("k", "v1")
		go los("k", "v2")
	})
	wg.Wait()

	fmt.Println(m.m["k"])
}

// 伪代码
type Lock struct {
	state int
}

func (l *Lock) Lock() {
	var (
		i      = 0
		locked = false
	)
	// 自旋
	for locked = CAS(UN_LOCK, LOCKED); !locked && i < 10; {
		i++
	}

	if locked {
		return
	}

	// 将自己的线程加入阻塞队列
	enqueue()
}

// A Mutex is a mutual exclusion lock.
// The zero value for a Mutex is an unlocked mutex.
//
// A Mutex must not be copied after first use.
type Mutex struct {
	state int32
	sema  uint32
}

// Lock locks m.
// If the lock is already in use, the calling goroutine
// blocks until the mutex is available.
func (m *Mutex) Lock() {
	// Fast path: grab unlocked mutex.
	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
		if race.Enabled {
			race.Acquire(unsafe.Pointer(m))
		}
		return
	}
	// Slow path (outlined so that the fast path can be inlined)
	m.lockSlow()
}

func (m *Mutex) lockSlow() {
	var waitStartTime int64
	starving := false
	awoke := false
	iter := 0
	old := m.state
	for {
		// Don't spin in starvation mode, ownership is handed off to waiters
		// so we won't be able to acquire the mutex anyway.
		if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
			// Active spinning makes sense.
			// Try to set mutexWoken flag to inform Unlock
			// to not wake other blocked goroutines.
			if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
				atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
				awoke = true
			}
			runtime_doSpin()
			iter++
			old = m.state
			continue
		}
		...
	}
	...
}

		if atomic.CompareAndSwapInt32(&m.state, old, new) {
			if old&(mutexLocked|mutexStarving) == 0 {
				break // locked the mutex with CAS
			}
			// If we were already waiting before, queue at the front of the queue.
			queueLifo := waitStartTime != 0
			if waitStartTime == 0 {
				waitStartTime = runtime_nanotime()
			}
			runtime_SemacquireMutex(&m.sema, queueLifo, 1)
			starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
			old = m.state
			if old&mutexStarving != 0 {
				// If this goroutine was woken and mutex is in starvation mode,
				// ownership was handed off to us but mutex is in somewhat
				// inconsistent state: mutexLocked is not set and we are still
				// accounted as waiter. Fix that.
				if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
					throw("sync: inconsistent mutex state")
				}

func (m *Mutex) Unlock() {
	if race.Enabled {
		_ = m.state
		race.Release(unsafe.Pointer(m))
	}

	// Fast path: drop lock bit.
	new := atomic.AddInt32(&m.state, -mutexLocked)
	if new != 0 {
		// Outlined slow path to allow inlining the fast path.
		// To hide unlockSlow during tracing we skip one extra frame when tracing GoUnblock.
		m.unlockSlow(new)
	}
}

			// since we did not observe mutexStarving when we unlocked the mutex above.
			// So get off the way.
			if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
				return
			}
			// Grab the right to wake someone.
			new = (old - 1<<mutexWaiterShift) | mutexWoken
			// 正常状态
			if atomic.CompareAndSwapInt32(&m.state, old, new) {
				runtime_Semrelease(&m.sema, false, 1)
				return
			}
			old = m.state
		}
	} else {
		// Starving mode: handoff mutex ownership to the next waiter, and yield
		// our time slice so that the next waiter can start to run immediately.
		// Note: mutexLocked is not set, the waiter will set it after wakeup.
		// But mutex is still considered locked if mutexStarving is set,
		// so new coming goroutines won't acquire it.
		// 饥饿状态	
		runtime_Semrelease(&m.sema, true, 1)
	}

// 写多读少
func (s *SafeMap[K, V]) CheckAndDoSomethingV1() {
	s.mu.Lock()
	// check and do something
	s.mu.Unlock()
}

func (s *SafeMap[K, V]) CheckAndDoSomethingV2() {
	s.mu.RLock()
	// check first time
	s.mu.RUnlock()

	s.mu.Lock()
	defer s.mu.Unlock()
	// check second time

	// check and do something
}

type valProvider func() any

func (s *SafeMap[K, V]) LoadOrStoreHeavy(key K, f valProvider) (V, bool) {
	s.mu.RLock()
	oldVal, ok := s.m[key]
	s.mu.RUnlock()
	if ok {
		return oldVal, true
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	oldVal, ok = s.m[key]
	if ok {
		return oldVal, true
	}

	// 延迟初始化
	newVal := f().(V)
	s.m[key] = newVal
	return newVal, false
}

// 递归非常容易错
func main() {
	RecursiveA()
}

var l sync.Mutex

func RecursiveA() {
	l.Lock()
	defer l.Unlock()
	RecursiveB()
}

func RecursiveB() {
	RecursiveC()
}

func RecursiveC() {
	l.Lock()
	defer l.Unlock()
	RecursiveA()
}

func (s *SafeListDecorator[T]) Set(index int, t T) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.l.Set(index, t)
}