Golang中Mutex的使用 - 为什么代码会锁住

在Go语言中，sync.Mutex 是不可重入锁（non-reentrant mutex）。这意味着同一个goroutine不能多次获取同一个互斥锁而不释放它。在你的代码中，get 方法获取锁后，在锁仍然持有的情况下调用了 count 方法，而 count 方法也尝试获取同一个锁，这就导致了死锁。

具体机制如下：

1. get 方法调用 ds.Lock() 获取锁
2. 在锁仍然持有的情况下，get 方法调用 count 方法
3. count 方法尝试调用 ds.Lock() 再次获取同一个锁
4. 由于锁已经被当前goroutine持有，count 方法会一直阻塞等待锁释放
5. 但 get 方法只有在 count 方法返回后才能释放锁
6. 这就形成了循环等待，导致死锁

示例代码展示问题所在：

package main

import (
	"fmt"
	"sync"
)

type DataStore struct {
	sync.Mutex
	cache map[string]string
}

func New() *DataStore {
	return &DataStore{
		cache: make(map[string]string),
	}
}

func (ds *DataStore) set(key string, value string) {
	ds.Lock()
	defer ds.Unlock()
	ds.cache[key] = value
}

// 有问题的get方法 - 会导致死锁
func (ds *DataStore) get(key string) string {
	ds.Lock()
	defer ds.Unlock()
	
	// 问题：在锁持有的情况下调用另一个需要锁的方法
	if ds.count() > 0 { // 这里会死锁
		item := ds.cache[key]
		return item
	}
	return ""
}

func (ds *DataStore) count() int {
	ds.Lock()         // 这里会阻塞，因为锁已经被get方法持有
	defer ds.Unlock()
	return len(ds.cache)
}

// 修复后的get方法
func (ds *DataStore) getFixed(key string) string {
	ds.Lock()
	defer ds.Unlock()
	
	// 直接访问缓存，不调用需要锁的方法
	if len(ds.cache) > 0 {
		item := ds.cache[key]
		return item
	}
	return ""
}

// 或者将count方法改为不需要锁的版本
func (ds *DataStore) countFixed() int {
	// 不获取锁，由调用方保证线程安全
	return len(ds.cache)
}

func main() {
	store := New()
	store.set("Go", "Lang")
	
	// 使用修复后的方法
	result := store.getFixed("Go")
	fmt.Println(result)
	
	// 或者这样使用count方法（在锁保护下）
	store.Lock()
	count := store.countFixed()
	store.Unlock()
	fmt.Println("Count:", count)
}

修复方案：

1. 在持有锁的方法中不要调用其他需要相同锁的方法
2. 将不需要锁保护的逻辑提取到独立的方法中
3. 使用 sync.RWMutex 来区分读锁和写锁，允许多个读操作并发执行

使用 sync.RWMutex 的改进版本：

package main

import (
	"fmt"
	"sync"
)

type DataStore struct {
	sync.RWMutex
	cache map[string]string
}

func New() *DataStore {
	return &DataStore{
		cache: make(map[string]string),
	}
}

func (ds *DataStore) set(key string, value string) {
	ds.Lock()
	defer ds.Unlock()
	ds.cache[key] = value
}

func (ds *DataStore) get(key string) string {
	ds.RLock()
	defer ds.RUnlock()
	
	if ds.count() > 0 {
		item := ds.cache[key]
		return item
	}
	return ""
}

func (ds *DataStore) count() int {
	ds.RLock()  // 使用读锁，可以多个goroutine同时获取
	defer ds.RUnlock()
	return len(ds.cache)
}

func main() {
	store := New()
	store.set("Go", "Lang")
	result := store.get("Go")
	fmt.Println(result)
}