vDSO（virtual dynamic shared object）是一个在Linux内核中的机制，用于提供一些系统调用的快速执行路径，以提高系统调用的性能。它是一个特殊的内存映射区域，包含一个ELF共享目标文件（.so文件），用于加速某些系统调用的执行效率。



vDSO的作用是通过将一些常用的系统调用的执行路径映射到用户空间，避免了进入内核态的开销，从而提高系统调用的执行速度。它主要解决了以下问题：
- 在过去，系统调用的执行速度较慢，需要经历完整的中断处理过程。为了提高系统调用的性能，芯片厂商推出了快速系统调用指令，如Intel的sysenter/sysexit和AMD的syscall/sysret。然而，不同的芯片厂商有不同的实现方式，导致libc和内核开发者需要对不同的指令进行适配。vDSO机制提供了一种通用的解决方案，使得libc可以通过调用vDSO来确定使用哪种快速系统调用指令。
- vDSO还可以加速某些系统调用函数的执行效率。例如，gettimeofday()系统调用返回的结果对于特权用户和非特权用户来说是相同的，因此可以通过vDSO直接读取最新值，避免了执行系统调用的开销。vDSO还支持其他系统调用，如time()和getcpu()。

vDSO与vsyscall的区别在于：
- vDSO是一个ELF共享目标文件，而vsyscall只是一段内存代码和数据。
- vsyscall位于内核地址空间，采用静态地址映射方式，而vDSO可以以进程为粒度动态映射到进程地址空间中。

用户程序可以通过调用vDSO中的函数来使用vDSO提供的快速系统调用路径。在Linux中，vDSO通常被映射到进程地址空间的一个特定区域，可以通过读取/proc/self/maps文件来查看vDSO的映射情况。

总结
===
vDSO是Linux内核中的一个机制，用于提供一些系统调用的快速执行路径，以提高系统调用的性能。它通过将常用的系统调用的执行路径映射到用户空间，避免了进入内核态的开销。用户程序可以通过调用vDSO中的函数来使用vDSO提供的快速系统调用路径。

---

1. [Linux vDSO概述 - 知乎](https://zhuanlan.zhihu.com/p/436454953)
2. [RISC-V Syscall 系列 3：什么是 vDSO？ - 泰晓科技](https://tinylab.org/riscv-syscall-part3-vdso-overview/)
3. [人见人爱的vDSO机制，如今也靠不住了-腾讯云开发者社区-腾讯云](https://cloud.tencent.com/developer/article/1073909)

VDSO

这个库是一个把结构体转换为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