这个库是一个把结构体转换为map的库，不支持标签

```go
// KeyCase 表示输出键的大小写规范
type KeyCase int



const (
	NotSet     KeyCase = iota // 不设置规范
	CamelCase                // 驼峰命名法
	PascalCase               // 帕斯卡命名法
	SnakeCase                // 蛇形命名法
)

var defaultCase = NotSet // 默认规范为不设置

// SetDefaultCase 用于设置默认的键规范
func SetDefaultCase(caseType KeyCase) {
	defaultCase = caseType
}

type mapModifier func(jsonMap) jsonMap

type jsonMap map[string]interface{}

// Predicate 是 func(interface{}) bool 的别名，用于测试是否包含某个字段
type Predicate func(interface{}) bool

// KeyConverter 是 func(string) string 的别名，用于转换键的名称
type KeyConverter func(string) string

// ValueConverter 是 func(interface{}) interface{} 的别名，用于转换值
type ValueConverter func(interface{}) interface{}

// Serializer 是所有序列化方法的基础接口
type Serializer interface {
	Transform(entity interface{}) map[string]interface{}
	TransformArray(entities interface{}) ([]map[string]interface{}, error)
	MustTransformArray(entities interface{}) []map[string]interface{}
	ConvertKeys(keyConverter KeyConverter) Serializer
	UseSnakeCase() Serializer
	UseCamelCase() Serializer
	UsePascalCase() Serializer
	PickAll() Serializer
	Pick(keys ...string) Serializer
	PickIf(predicate Predicate, keys ...string) Serializer
	PickFunc(converter ValueConverter, keys ...string) Serializer
	PickFuncIf(predicate Predicate, converter ValueConverter, keys ...string) Serializer
	Omit(keys ...string) Serializer
	OmitIf(predicate Predicate, keys ...string) Serializer
	Add(key string, value interface{}) Serializer
	AddIf(predicate Predicate, key string, value interface{}) Serializer
	AddFunc(key string, converter ValueConverter) Serializer
	AddFuncIf(predicate Predicate, key string, converter ValueConverter) Serializer
}
```

这里定义了一系列类型，包括 `KeyCase` 枚举类型、`mapModifier` 函数类型和别名类型 `jsonMap`、`Predicate`、`KeyConverter`、`ValueConverter` 以及 `Serializer` 接口。

```go
func alwaysTrue(u interface{}) bool {
	return true
}

func alwaysFalse(u interface{}) bool {
	return false
}

func identity(u interface{}) interface{} {
	return u
}
```

这里定义了三个用于作为默认参数的函数，`alwaysTrue` 总是返回 `true`，`alwaysFalse` 总是返回 `false`，`identity` 返回输入参数本身。

```go
type Base struct {
	raw          interface{}
	modifiers    []mapModifier
	reflected    reflect.Value
	keyConverter KeyConverter
}

func New() *Base {
	b := &Base{}
	b.addDefaultKeyConverter()
	return b
}
```

`Base` 结构体是 `Serializer` 接口的基础实现，包含了原始数据 `raw`、一系列修改器函数 `modifiers`、反射得到的值 `reflected` 和键转换函数 `keyConverter`。

`New` 函数返回一个新的 `Base` 实例，并调用 `addDefaultKeyConverter` 设置默认键转换函数。

```go
func (b *Base) Transform(entity interface{}) map[string]interface{} {
	b.raw = entity
	b.reflected = reflect.Indirect(reflect.ValueOf(entity))
	return b.result()
}
```

`Transform` 方法将实体转换为 `map[string]interface{}`，并设置 `raw` 和 `reflected` 属性。

```go
func (b *Base) TransformArray(entities interface{}) ([]map[string]interface{}, error) {
	s := reflect.ValueOf(entities)
	if s.Kind() != reflect.Slice && s.Kind() != reflect.Array {
		return nil, fmt.Errorf("TransformArray() given a non-slice type")
	}
	result := []map[string]interface{}{}
	for i := 0; i < s.Len(); i++ {
		result = append(result, b.Transform(s.Index(i).Interface()))
	}
	return result, nil
}

func (b *Base) MustTransformArray(entities interface{}) []map[string]interface{} {
	res, err := b.TransformArray(entities)
	if err != nil {
		panic(err)
	}
	return res
}
```

`TransformArray` 方法将实体数组转换为 `[]map[string]interface{}`，并对输入类型进行检查。`MustTransformArray` 方法在 `TransformArray` 的基础上增加了 panic 处理。

```go
func (

b *Base) addDefaultKeyConverter() {
	switch defaultCase {
	case PascalCase:
		b.UsePascalCase()
	case SnakeCase:
		b.UseSnakeCase()
	case CamelCase:
		b.UseCamelCase()
	default:
		break
	}
}

func (b *Base) transformedResult(result jsonMap) jsonMap {
	newResult := make(map[string]interface{})
	for key, value := range result {
		newResult[b.keyConverter(key)] = value
	}
	return newResult
}

func (b *Base) result() map[string]interface{} {
	result := make(map[string]interface{})
	for _, modifier := range b.modifiers {
		result = modifier(result)
	}
	if b.keyConverter != nil {
		return b.transformedResult(result)
	}
	return result
}
```

`addDefaultKeyConverter` 方法根据默认键规范设置键转换函数。

`transformedResult` 方法使用键转换函数对结果进行转换。

`result` 方法应用所有修改器函数，并根据键转换函数进行最终结果的转换。

```go
func (b *Base) ConvertKeys(keyConverter KeyConverter) Serializer {
	b.keyConverter = keyConverter
	return b
}

func (b *Base) UsePascalCase() Serializer {
	return b.ConvertKeys(func(k string) string {
		return xstrings.ToCamelCase(xstrings.ToSnakeCase(k))
	})
}

func (b *Base) UseCamelCase() Serializer {
	return b.ConvertKeys(func(k string) string {
		return xstrings.FirstRuneToLower(xstrings.ToCamelCase(xstrings.ToSnakeCase(k)))
	})
}

func (b *Base) UseSnakeCase() Serializer {
	return b.ConvertKeys(xstrings.ToSnakeCase)
}
```

`ConvertKeys` 方法用于设置键转换函数，`UsePascalCase`、`UseCamelCase`、`UseSnakeCase` 方法分别设置不同的键规范。

```go
func (b *Base) PickAll() Serializer {
	b.modifiers = append(b.modifiers, func(m jsonMap) jsonMap {
		return structs.Map(b.raw)
	})
	return b
}

func (b *Base) Pick(keys ...string) Serializer {
	return b.PickFunc(identity, keys...)
}

func (b *Base) PickIf(p Predicate, keys ...string) Serializer {
	return b.PickFuncIf(p, identity, keys...)
}

func (b *Base) PickFunc(converter ValueConverter, keys ...string) Serializer {
	return b.PickFuncIf(alwaysTrue, converter, keys...)
}

func (b *Base) PickFuncIf(p Predicate, converter ValueConverter, keys ...string) Serializer {
	b.modifiers = append(b.modifiers, func(m jsonMap) jsonMap {
		if p(b.raw) {
			for _, key := range keys {
				m[key] = converter(b.reflected.FieldByName(key).Interface())
			}
		}
		return m
	})
	return b
}
```

`PickAll` 方法将所有公开字段添加到结果中。

`Pick` 方法添加指定字段到结果。

`PickIf` 方法添加指定字段到结果，仅当 Predicate 返回 `true` 时。

`PickFunc` 方法添加通过 ValueConverter 转换后的指定字段到结果。

`PickFuncIf` 方法添加通过 ValueConverter 转换后的指定字段到结果，仅当 Predicate 返回 `true` 时。

```go
func (b *Base) Omit(keys ...string) Serializer {
	return b.OmitIf(alwaysTrue, keys...)
}

func (b *Base) OmitIf(p Predicate, keys ...string) Serializer {
	b.modifiers = append(b.modifiers, func(m jsonMap) jsonMap {
		if p(b.raw) {
			for _, key := range keys {
				delete(m, key)
			}
		}
		return m
	})
	return b
}
```

`Omit` 方法从结果中排除指定字段。

`OmitIf` 方法从结果中排除指定字段，仅当 Predicate 返回 `true` 时。

```go
func (b *Base) Add(key string, value interface{}) Serializer {
	return b.AddIf(alwaysTrue, key, value)
}

func (b *Base) AddIf(p Predicate, key string, value interface{}) Serializer {
	return b.AddFuncIf(p, key, func(m interface{}) interface{} { return value })
}

func (b *Base) AddFunc(key string, f ValueConverter) Serializer {
	return b.AddFuncIf(alwaysTrue, key, f)
}

func (b *Base) AddFuncIf(p Predicate, key string, f ValueConverter) Serializer {
	b.modifiers = append(b.modifiers, func(m jsonMap) jsonMap {
		if p(b.raw) {
			m[key] = f(b.raw)
		}
		return m
	})
	return b
}
```

`Add` 方法向结果中添加指定的自定义字段。

`AddIf` 方法向结果中添加指定的自定义字段，仅当 Predicate 返回 `true` 时。

`AddFunc` 方法向结果中添加通过 ValueConverter 转换后的自定义字段。

`AddFuncIf` 方法向结果中添加通过 ValueConverter 转换后的自定义字段，仅当 Predicate 返回 `true` 时。

这些方法允许用户添加自定义字段到结果中。



### 主要概念和类型

1. **KeyCase 枚举类型：** 定义了表示键的命名规则的枚举类型，包括 NotSet（未设置）、CamelCase（驼峰命名法）、PascalCase（帕斯卡命名法）、SnakeCase（蛇形命名法）。

2. **mapModifier 函数类型：** 用于修改输出的 `map` 的函数类型。

3. **jsonMap 类型：** `map[string]interface{}` 的别名，用于表示 JSON 对象。

4. **Predicate、KeyConverter、ValueConverter 函数类型：** 分别用于测试字段是否包含、转换键的名称、转换字段的值。

5. **Serializer 接口：** 定义了所有序列化方法的接口。

6. **Base 结构体：** 实现了 Serializer 接口的基础结构，包括对键的默认转换和一些常见的转换操作。

### 主要方法和功能

1. **New 函数：** 创建一个新的 Serializer 实例。

2. **Transform 方法：** 将实体（结构体）转换为 `map[string]interface{}`。

3. **TransformArray 方法：** 将实体数组（切片）转换为 `[]map[string]interface{}`。

4. **MustTransformArray 方法：** 与 TransformArray 相同，但如果发生错误则引发 panic。

5. **ConvertKeys 方法：** 设置键的命名规则。

6. **UsePascalCase、UseCamelCase、UseSnakeCase 方法：** 设置键的命名规则为帕斯卡命名法、驼峰命名法、蛇形命名法。

7. **PickAll 方法：** 添加所有导出字段到结果。

8. **Pick 方法：** 添加指定的字段到结果。

9. **PickIf 方法：** 如果满足条件，则添加指定的字段到结果。

10. **PickFunc 方法：** 使用转换函数，添加指定的字段到结果。

11. **PickFuncIf 方法：** 如果满足条件，则使用转换函数，添加指定的字段到结果。

12. **Omit 方法：** 从结果中省略指定的字段。

13. **OmitIf 方法：** 如果满足条件，则从结果中省略指定的字段。

14. **Add 方法：** 添加自定义字段到结果。

15. **AddIf 方法：** 如果满足条件，则添加自定义字段到结果。

16. **AddFunc 方法：** 使用转换函数，添加计算的自定义字段到结果。

17. **AddFuncIf 方法：** 如果满足条件，则使用转换函数，添加计算的自定义字段到结果。

### 使用示例

```go
serializer := structomap.New().UseSnakeCase().Pick("FieldName").Add("CustomField", "some value")
result := serializer.Transform(someStruct)
```

在上述示例中，创建了一个新的 `structomap` 实例，设置了键的命名规则为蛇形命名法，然后选择了结构体中名为 "FieldName" 的字段，添加了一个自定义字段 "CustomField" 到结果中，最后进行了转换。

这个库的设计允许用户根据需要选择转换的方式，非常适用于将结构体数据转换为 JSON 对象的场景。

struct map

如下
```go
package colour

type Colour int
const (
   Red Colour = iota
   Green
   Blue
)

func (c Colour) String() string
{
switch c {
case Red:
     return "Red"
case Green:
     return "Green"
case Blue:
     return "Blue"
default:
     panic("unknown colour")
}
}

// 其他包导入

import "example/colour"

var c Colour= colour.Red
fmt.Println(c)
```

---
参考：

https://mp.weixin.qq.com/s/m2N6YSEqseRfrqLjDWZIZQ

https://mp.weixin.qq.com/s/f4U4VVYBifi78JQC6D8KuA

go枚举正确用法

Linux的futex是一种快速用户空间互斥体（Fast Userspace mutexes）机制，用于实现进程间和线程间的同步操作。它在Linux内核中存在已经很长时间了，从Linux 2.5.7版本开始引入。

Futex的优势
---------
相比于传统的同步机制，futex具有以下优势：
1. 快速：futex利用用户态和内核态混合的方式实现同步，避免了频繁的用户态和内核态切换，因此具有较低的开销和较高的性能。
2. 灵活：futex支持进程内的线程同步和进程间的同步锁操作，可以满足不同场景下的同步需求。
3. 轻量级：futex的实现相对简单，占用的系统资源较少。

Futex的功能
---------
futex提供了以下几个基本功能：
1. futex_wait：当一个任务需要陷入等待状态时，可以调用futex_wait函数。该函数会检查指定的futex变量的值是否满足特定条件，如果不满足，则任务会被阻塞在该futex变量上，直到满足条件才会被唤醒。
2. futex_wake：当需要唤醒其他任务时，可以调用futex_wake函数。该函数会唤醒指定数量的在某个futex变量上等待的任务。

数据结构
---------
在内核中，futex变量通过struct futex_q结构与挂起的进程（线程）关联起来。该结构包含了链表节点、挂起的进程（线程）、自旋锁、futex变量地址标识等成员。
```c
/*
 * Hash buckets are shared by all the futex_keys that hash to the same
 * location. Each key may have multiple futex_q structures, one for each task
 * waiting on a futex.
 */
struct futex_hash_bucket {
    atomic_t waiters;                // 等待者计数，原子变量
    spinlock_t lock;                 // 散列桶的锁
    struct plist_head chain;         // 等待在同一位置的 futex_keys 的链表
} ____cacheline_aligned_in_smp;

/*
 * Priority Inheritance state:
 */
struct futex_pi_state {
    /*
     * list of 'owned' pi_state instances - these have to be
     * cleaned up in do_exit() if the task exits prematurely:
     */
    struct list_head list;            // 拥有的 pi_state 实例的链表，用于在任务提前退出时清理

    /*
     * The PI object:
     */
    struct rt_mutex_base pi_mutex;    // 优先级继承对象的基本互斥体

    struct task_struct *owner;        // 拥有此 pi_state 的任务指针
    refcount_t refcount;              // 引用计数

    union futex_key key;              // futex 的键值
} __randomize_layout;


/**
 * struct futex_q - The hashed futex queue entry, one per waiting task
 * @list:           priority-sorted list of tasks waiting on this futex
 * @task:           the task waiting on the futex
 * @lock_ptr:       the hash bucket lock
 * @key:            the key the futex is hashed on
 * @pi_state:       optional priority inheritance state
 * @rt_waiter:      rt_waiter storage for use with requeue_pi
 * @requeue_pi_key: the requeue_pi target futex key
 * @bitset:         bitset for the optional bitmasked wakeup
 * @requeue_state:  State field for futex_requeue_pi()
 * @requeue_wait:   RCU wait for futex_requeue_pi() (RT only)
 *
 * We use this hashed waitqueue, instead of a normal wait_queue_entry_t,
 * so we can wake only the relevant ones (hashed queues may be shared).
 *
 * A futex_q has a woken state, just like tasks have TASK_RUNNING.
 * It is considered woken when plist_node_empty(&q->list) || q->lock_ptr == 0.
 * The order of wakeup is always to make the first condition true, then
 * the second.
 *
 * PI futexes are typically woken before they are removed from the hash list via
 * the rt_mutex code. See futex_unqueue_pi().
 */
struct futex_q {
    struct plist_node list;               // 一个按优先级排序的等待在此 futex 上的任务列表
    struct task_struct *task;             // 等待在 futex 上的任务的指针
    spinlock_t *lock_ptr;                 // 散列桶的锁指针，用于保护散列桶
    union futex_key key;                  // futex 散列的键值
    struct futex_pi_state *pi_state;      // 可选的优先级继承状态
    struct rt_mutex_waiter *rt_waiter;    // 与 requeue_pi 一起使用的 rt_waiter 存储
    union futex_key *requeue_pi_key;      // requeue_pi 目标 futex 的键值
    u32 bitset;                           // 用于可选的位掩码唤醒的位集
    atomic_t requeue_state;               // 用于 futex_requeue_pi() 的状态字段
#ifdef CONFIG_PREEMPT_RT
    struct rcuwait requeue_wait;          // 用于 futex_requeue_pi() 的 RCU 等待（仅适用于实时内核）
#endif
} __randomize_layout;

```
此外，全局哈希表用于维护所有挂起阻塞在futex变量上的进程（线程）。不同的futex变量会根据其地址标识计算出一个哈希索引，并定位到对应的bucket上。每个bucket包含了自旋等待哈希桶的等待数目、自旋锁和优先级链表等成员。

源码分析
---------
futex的初始化工作在内核启动时完成。初始化包括申请固定数量的bucket用于全局哈希表管理，并初始化每个bucket的链表的自旋锁。

---
Learn more:
1. [linux--futex原理分析](https://www.openeuler.org/zh/blog/wangshuo/Linux_Futex_Principle_Analysis/Linux_Futex_Principle_Analysis.html)
2. [linux futex浅析-阿里云开发者社区](https://developer.aliyun.com/article/6043)
3. [futex(2) - Linux manual page](https://man7.org/linux/man-pages/man2/futex.2.html)

linux futex

在go里面，已经把线程概念抽象完了，几乎没有提供关于线程的操作，在go程序，所有操作都是协程粒度的以前用cpp写的简单协程库，那时候在考虑协程锁怎么实现，如果直接用线程锁的话，那跑在这一个线程上的协程都动不了，所以我们需要一个小粒度的，作用在协程的锁，go是一门只有协程的语言，线程只能由runtime来管理，所以他的锁必然是协程粒度

这段代码是 Go 语言标准库中 `sync` 包中的 `Mutex` 类型的实现。





 `Mutex` 结构体定义：
===
```go
type Mutex struct {
	state int32
	sema  uint32
}
```

- `state` 用于表示互斥锁的状态，其中 `mutexLocked` 标志表示锁已被某个 goroutine 锁定。
- `sema` 是一个信号量，用于在等待锁的 goroutine 之间进行通信。


锁状态
===
```go
const (
	mutexLocked = 1 << iota // mutex is locked
	mutexWoken
	mutexStarving
	mutexWaiterShift = iota

	// Mutex fairness.
	//
	// Mutex can be in 2 modes of operations: normal and starvation.
	// In normal mode waiters are queued in FIFO order, but a woken up waiter
	// does not own the mutex and competes with new arriving goroutines over
	// the ownership. New arriving goroutines have an advantage -- they are
	// already running on CPU and there can be lots of them, so a woken up
	// waiter has good chances of losing. In such case it is queued at front
	// of the wait queue. If a waiter fails to acquire the mutex for more than 1ms,
	// it switches mutex to the starvation mode.
	//
	// In starvation mode ownership of the mutex is directly handed off from
	// the unlocking goroutine to the waiter at the front of the queue.
	// New arriving goroutines don't try to acquire the mutex even if it appears
	// to be unlocked, and don't try to spin. Instead they queue themselves at
	// the tail of the wait queue.
	//
	// If a waiter receives ownership of the mutex and sees that either
	// (1) it is the last waiter in the queue, or (2) it waited for less than 1 ms,
	// it switches mutex back to normal operation mode.
	//
	// Normal mode has considerably better performance as a goroutine can acquire
	// a mutex several times in a row even if there are blocked waiters.
	// Starvation mode is important to prevent pathological cases of tail latency.
	starvationThresholdNs = 1e6
)

```
`Lock` 方法：
===
```go
func (m *Mutex) Lock() {
    // Fast path: 尝试直接获取锁
    if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
        if race.Enabled {
            race.Acquire(unsafe.Pointer(m))
        }
        return
    }
    // Slow path: 锁已被其他 goroutine 占用，调用 lockSlow 进行处理
    m.lockSlow()
}

func (m *Mutex) lockSlow() {
	// 记录等待开始的时间，用于判断是否进入饥饿模式
	var waitStartTime int64
	// 标记是否处于饥饿模式
	starving := false
	// 标记是否被唤醒
	awoke := false
	// 记录自旋次数
	iter := 0
	// 获取当前锁的状态
	old := m.state

	for {
		// 如果锁处于饥饿模式且正在自旋，则不进行自旋，因为锁的所有权已经交给了等待者
		if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
			// 主动自旋有意义
			// 尝试设置 mutexWoken 标志，以通知 Unlock 不要唤醒其他阻塞的 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
		}

		new := old
		// 如果锁不处于饥饿模式，设置新的状态为已锁定
		if old&mutexStarving == 0 {
			new |= mutexLocked
		}
		if old&(mutexLocked|mutexStarving) != 0 {
			new += 1 << mutexWaiterShift
		}
		// 当前 goroutine 将锁切换到饥饿模式
		// 但是如果锁当前处于未锁定状态，则不切换
		// Unlock 预期处于饥饿模式的锁有等待者，而在这种情况下不为真
		if starving && old&mutexLocked != 0 {
			new |= mutexStarving
		}

		// 如果 goroutine 被唤醒，需要重置标志位
		if awoke {
			if new&mutexWoken == 0 {
				throw("sync: inconsistent mutex state")
			}
			new &^= mutexWoken
		}

		// 尝试用 CAS 更新锁的状态
		if atomic.CompareAndSwapInt32(&m.state, old, new) {
			// 如果锁之前未锁定，则成功获取锁并退出循环
			if old&(mutexLocked|mutexStarving) == 0 {
				break // 用 CAS 锁住了 mutex
			}

			// 如果之前已经在等待了，则排队在队列的前面
			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 old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
					throw("sync: inconsistent mutex state")
				}

				// 修复锁的状态，解决饥饿模式下的不一致性
				delta := int32(mutexLocked - 1<<mutexWaiterShift)
				if !starving || old>>mutexWaiterShift == 1 {
					// 退出饥饿模式
					delta -= mutexStarving
				}
				atomic.AddInt32(&m.state, delta)
				break
			}

			awoke = true
			iter = 0
		} else {
			old = m.state
		}
	}

	// 记录 goroutine 获取锁的操作，用于竞争检测
	if race.Enabled {
		race.Acquire(unsafe.Pointer(m))
	}
}

```

- `Lock` 方法用于获取锁。如果锁已被其他 goroutine 占用，就调用 `lockSlow` 方法进行处理。

3. `TryLock` 方法：

```go
func (m *Mutex) TryLock() bool {
    old := m.state
    if old&(mutexLocked|mutexStarving) != 0 {
        return false
    }
    if !atomic.CompareAndSwapInt32(&m.state, old, old|mutexLocked) {
        return false
    }
    if race.Enabled {
        race.Acquire(unsafe.Pointer(m))
    }
    return true
}
```

- `TryLock` 方法尝试获取锁，成功返回 `true`，失败返回 `false`。如果锁已被占用或处于饥饿模式，获取锁失败。

4. `Unlock` 方法：

```go
func (m *Mutex) Unlock() {
    // 快速路径：释放锁
    new := atomic.AddInt32(&m.state, -mutexLocked)
    if new != 0 {
        // 慢速路径：调用 unlockSlow 处理
        m.unlockSlow(new)
    }
}
```

- `Unlock` 方法用于释放锁。如果锁的状态为零，表示成功释放锁。否则，调用 `unlockSlow` 方法进行处理。

5. `unlockSlow` 方法：

```go
func (m *Mutex) unlockSlow(new int32) {
    if (new+mutexLocked)&mutexLocked == 0 {
        fatal("sync: unlock of unlocked mutex")
    }
    if new&mutexStarving == 0 {
        // 非饥饿模式：唤醒等待的 goroutine
        old := new
        for {
            if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
                return
            }
            new = (old - 1<<mutexWaiterShift) | mutexWoken
            if atomic.CompareAndSwapInt32(&m.state, old, new) {
                runtime_Semrelease(&m.sema, false, 1)
                return
            }
            old = m.state
        }
    } else {
        // 饥饿模式：将锁的所有权移交给等待的下一个 goroutine，并让出时间片
        runtime_Semrelease(&m.sema, true, 1)
    }
}
```

- `unlockSlow` 方法处理释放锁的慢速路径。在非饥饿模式下，它尝试唤醒等待的 goroutine。在饥饿模式下，它直接将锁的所有权移交给等待的下一个 goroutine，并让出时间片。

这段代码实现了互斥锁的基本功能，并考虑了锁的饥饿模式。饥饿模式是一种优化，用于防止某些情况下的锁竞争。

---
参考
1.https://mp.weixin.qq.com/s/QLzJ4sXaggPga2biQdExOA
2.https://mp.weixin.qq.com/s/D9Zgh2pm6hqqbIOkefrNcw

go的Mutex实现




实现
===
```go
// Once 是一个对象，用于确保只执行一次动作。
//
// 在首次使用后，Once 不应被复制。
//
// 在 Go 内存模型的术语中，
// 从 f 返回的值在任何对 once.Do(f) 的调用的返回之前“同步完成”。
type Once struct {
    // done 表示动作是否已经执行。
    // 它放在结构体的第一个位置，因为它在热路径中使用。
    // 热路径会在每个调用站点内联。
    // 将 done 放在第一位可以在某些架构（amd64/386）上产生更紧凑的指令，
    // 在其他架构上减少指令（计算偏移量）的数量。
    done uint32
    m    Mutex
}

// Do 在仅在对该 Once 实例的首次调用 Do 时才调用函数 f。
// 换句话说，给定
//
//	var once Once
//
// 如果多次调用 once.Do(f)，只有第一次调用会调用 f，
// 即使每次调用 f 都有不同的值。每个要执行的函数都需要一个新的 Once 实例。
//
// Do 用于确保只执行一次的初始化。
// 由于 f 是无参数的，可能需要使用函数字面量来捕获要由 Do 调用的函数的参数：
//
//	config.once.Do(func() { config.init(filename) })
//
// 由于 Do 不返回，如果 f 导致 Do 被调用，它将导致死锁。
//
// 如果 f 引发 panic，Do 将视为已返回；Do 的未来调用将返回而不调用 f。
func (o *Once) Do(f func()) {
    // 注意：这是 Do 的一个错误实现:
    //
    //	if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
    //		f()
    //	}
    //
    // Do 保证返回时 f 已完成。
    // 这个实现不会实现这个保证：
    // 给定两个同时调用的情况，cas 的获胜者会调用 f，
    // 而第二个将立即返回，而不等待第一个调用的 f 完成。
    // 这就是为什么慢路径会退回到互斥锁，以及为什么 atomic.StoreUint32 必须推迟到 f 返回之后。

    if atomic.LoadUint32(&o.done) == 0 {
        // 内联快路径，以便在热路径中内联。
        o.doSlow(f)
    }
}

func (o *Once) doSlow(f func()) {
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

```