进程相关
===
首先是一些进程相关的常用命令
### `ps`：显示当前系统中的进程状态。常用选项包括：
   - `ps aux`：显示所有进程的详细信息。
   


![image.png](/static/img/b2d21c07d7aaf8749f789622cf40f210.image.webp)
   - `ps -ef`：显示所有进程的ID信息，并包括进程之间的关系。
    
![image.png](/static/img/59561da36e8b4c72d750f12e8b1c044e.image.webp)
2. `top`：实时显示系统中的进程状态和系统性能信息。按下`q`键退出。
    ![image.png](/static/img/886211b5e6d87279205ed09e987988ff.image.webp)
- htop:类似于top，但提供了更直观的界面和更多功能。
    
![image.png](/static/img/e6e6a337883152de9e6a900db8776261.image.webp)
![image.png](/static/img/886211b5e6d87279205ed09e987988ff.image.webp)
3. `pgrep`：根据进程名或其他条件查找匹配的进程ID。
    - 例如：`pgrep nginx` 将显示所有名为 "nginx" 的进程ID。

![image.png](/static/img/01ef3733aa6075b693f66ff587bd9fdc.image.webp)
4. `kill`：向进程发送信号以终止或操作进程。
   - `kill PID`：向指定PID的进程发送终止信号（默认为SIGTERM）。
   - `killall process_name`：向指定进程名的所有进程发送终止信号。
    
5. `killall`：向指定的进程名发送信号以终止进程。

6. `pskill`：杀死指定进程ID的进程。
   - 例如：`pskill 1234` 将终止PID为1234的进程。
    
7. `nice`：设置进程的优先级。
   - `nice -n value command`：将指定命令以指定的优先级运行。
   - 例如：`nice -n 10 ./myprogram` 将以较低的优先级运行"myprogram"。

8. `renice`：修改正在运行的进程的优先级。
   - `renice priority PID`：将指定PID的进程的优先级更改为指定的优先级值。

9. `pstree`：以树形结构显示进程之间的层次关系。

![image.png](/static/img/fd96e231c84195e95f99e1d15acf2ae9.image.webp)
10. pkill： 杀死指定名称的进程。


---
1.https://mp.weixin.qq.com/s/CoAg-RIyy3H4bnkFoqcV6g
2.https://mp.weixin.qq.com/s/n_Nhz9cNaI_aVlX7DA91AA
3.https://mp.weixin.qq.com/s/cpn7Uvra7030FTGZO9ScLA

linux命令常复习

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)

进程相关

ps：显示当前系统中的进程状态。常用选项包括：

`ps`：显示当前系统中的进程状态。常用选项包括：