宁静之森

我的音乐歌手关键词

2024-10-20T10:01:35.000Z

我的音乐歌手关键词

202405061046 音乐-圆桌骑士

2024-07-31T12:13:47.000Z

202405061046 音乐-圆桌骑士

https://music.163.com/song?id=2127857336&userid=16553655

很有西方的骑士感觉

如何合并marginnote笔记本

2024-09-26T07:29:50.000Z

如何合并marginnote笔记本

一个文档的多个笔记本中的笔记能否合并？ - 方法、技巧、工作流 - MarginNote 中文社区

软装-沙发

2024-10-12T14:55:32.000Z

软装-沙发

材质

布艺
科技布？

填充物

一体成型
海绵密度高于 50
海绵加羽绒

尺寸

坐深 65cm 以上
坐高 40cm 左右
靠背高度 55cm 以上
长度 3.2-3.5 米

框架

蛇形弹簧
实木框架

封底

布艺封底

颜色

深色（不容易翻车）

Reference

202405081320 IPv6的回环地址是如何表示的

2024-05-08T05:37:58.000Z

202405081320 IPv6的回环地址是如何表示的

::1

算法新年祝福语

2024-02-05T04:42:49.000Z

算法新年祝福语

祝你冒泡排序，选择排序，插入排序，快速排序，堆排序，归并排序，希尔排序，桶排序，基数排序新年帮您排忧解难。

有向图，无向图，有环图，无环图，完全图，稠密图，稀疏图，拓扑图祝您新年宏图大展。

最长路，最短路，单源路径，所有节点对路径祝您新年路路通畅。

二叉树，红黑树，van Emde Boas树，最小生成树祝您新年好运枝繁叶茂。

最大流，网络流，标准输入流，标准输出流，文件输入流，文件输出流祝您新年顺顺流流。

线性动规，区间动规，坐标动规，背包动规，树型动归为您的新年规划精彩。

散列表，哈希表，邻接表，双向链表，循环链表帮您在新年表达喜悦。

滑动窗口模板

2024-04-20T10:25:52.000Z

滑动窗口模板

以 1052. 爱生气的书店老板为例

class Solution {

    /**
     * @param Integer[] $customers
     * @param Integer[] $grumpy
     * @param Integer $X
     * @return Integer
     */
    function maxSatisfied($customers, $grumpy, $X) {
        if (empty($customers)) {
            return 0;
        }

        // 1. 计算初始状态： 不压抑的时候，最大的满意人数
        $maxSat = 0;
        foreach ($grumpy as $key => $g) {
            if ($g == 0) {
                $maxSat += $customers[$key];
            }
        }
		
		// 1.1 初始化左右指针位置
        $len = count($customers);
        $left = $right = 0;
        $curSat = $maxSat;
		
        // 2. 滑窗具体代码
        // 2.1 右指针一直往右做
        while ($right < $len) {
            $span = $right - $left + 1;

            // 2.1 直到遇到临界条件之后，左指针往右走，直到满足临界条件
            if ($span > $X) {
                if ($grumpy[$left]) {
                    $curSat -= $customers[$left];
                }
                $left ++;
            }

            // 计算当前窗口的数值
            if ($grumpy[$right]) {
                $curSat += $customers[$right];
            }
			
            // 最终结果比较
            $maxSat = max($curSat, $maxSat);
            $right++;
        }

        return $maxSat;
    }
}

多看几个题解：

lc 的官方题解：爱生气的书店老板
一般官方题解的思路会非常详细，建议多看几遍
用「秘密技巧」挽留住最多的原本因为生气而被赶走的顾客

动态规划很多时候就是在填表

2024-10-21T13:52:03.000Z

动态规划很多时候就是在填表

https://leetcode.cn/problems/longest-palindromic-substring/solutions/7792/zhong-xin-kuo-san-dong-tai-gui-hua-by-liweiwei1419

填表的顺序是非常重要的

leetcode题目难度更新了

2024-11-05T16:28:34.000Z

leetcode题目难度更新了

2023-02-25 的时候还是困难题的编辑距离

2024年变成了中等题，哈哈哈哈哈，但是我的脑子没有跟着更新啊

leetcode-557. 反转字符串中的单词 III

2024-10-21T04:41:35.000Z

leetcode-557. 反转字符串中的单词 III

557. 反转字符串中的单词 III - 力扣（Leetcode）

与代码 leetcode-541. 反转字符串 II 相关联，swapStrBytes 函数，使用了上次的代码

func reverseWords(s string) string {
    sBytes := []byte(s)
    
    for left, right := 0, 0; right < len(sBytes);  right++ {
        if sBytes[right] == ' ' {
            swapStrBytes(sBytes, left, right-1)
            left = right+1
        }
        if right == len(sBytes) - 1 {
            swapStrBytes(sBytes, left, right)
        }
    }

    return string(sBytes)
}

func swapStrBytes(s []byte, left, right int) {
	if left >= right {
		return
	}

	for left < right {
		s[left], s[right] = s[right], s[left]
		left++
		right--
	}
}

leetcode-541. 反转字符串 II

2024-10-25T06:50:18.000Z

leetcode-541. 反转字符串 II

541. 反转字符串 II - 力扣（Leetcode）

比较简单，想清楚边界条件，然后做一下字符的反转即可。go 可以将不能变动的字符串转换成可以变动的 []byte 之后，修改完之后，再转成 string

func reverseStr(s string, k int) string {
	if len(s) <= 1 {
		return s
	}

	strBytes := []byte(s)

	var left, right int
	// abcdefg   2
	for ; right < len(strBytes); right++ {
		if (right-left) >= 2*k-1 || right == len(strBytes)-1 {
			if left+k-1 > len(strBytes)-1 {
				swapStrBytes(strBytes, left, len(strBytes)-1)
			} else {
				swapStrBytes(strBytes, left, left+k-1)
			}
			left = right + 1
		}
	}

	return string(strBytes)
}

func swapStrBytes(s []byte, left, right int) {
	if left >= right {
		return
	}

	for left < right {
		s[left], s[right] = s[right], s[left]
		left++
		right--
	}
}

leetcode-53. 最大子数组和

2024-11-01T02:48:24.000Z

leetcode-53. 最大子数组和

53. 最大子数组和

解法

第一版写的时候，可以加一个 dp 数组，保存每个节点的最大值

dp 公式

f_{n} = {\begin{cases} m a x (n u m s [n] + f_{n - 1}, n u m s [n]) & n >= 1 \\ n u m s [n], & n = 0 \end{cases}

class Solution {
    
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function maxSubArray($nums) {
        $len = count($nums);
        if ($len == 1) {
            return $nums[0];
        }
        
        $currentMaxSum = $nums[0];
        
        $max = $nums[0];
        for ($i=1; $i < $len; $i++) {
            $currentMaxSum = max($currentMaxSum + $nums[$i], $nums[$i]);
            $max = max($currentMaxSum, $max);
        }
        
        return $max;
    }
}

2024-10-31

使用go语言重新写一遍，仍然是dp思想

该算法的核心思想是求 “以当前位置为结尾的最大子数组和”

func maxSubArray(nums []int) int {
    if len(nums) == 0 {
        return 0
    }

    winSum := 0
    mxSum := nums[0]

    for i := range nums {
	    winSum = max(nums[i], nums[i]+winSum)
        mxSum = max(mxSum, winSum)
    }

    return mxSum
}

leetcode-49. 字母异位词分组

2024-10-26T08:58:07.000Z

leetcode-49. 字母异位词分组

49. 字母异位词分组 - 力扣（Leetcode）

两种方法，都是把 key 聚合起来

func groupAnagrams(strs []string) [][]string {
    mp := make(map[[26]int][]string)

    for _, str := range strs {
        var cCnt [26]int

        for _, b := range str {
            cCnt[b-'a'] ++
        }

        mp[cCnt] = append(mp[cCnt], str)
    }

    var ret [][]string

    for _, m := range mp {
        ret = append(ret, m)
    }

    return ret
}

2024-10-26 16:44

func groupAnagrams(strs []string) [][]string {
    retMap := map[[26]byte][]string{}

    for _, s := range strs {
        var key [26]byte
        for _, b := range []byte(s) {
            key[b-97] ++
        }

        retMap[key] = append(retMap[key], s)
    }

    ret := [][]string{}
    for _, r := range retMap {
        ret = append(ret, r)
    }

    return ret
}

这两个版本的 groupAnagrams 函数基本实现相同，都是通过构造字母计数数组 key 来对字母异位词进行分组，但有一些细节上的优化空间：

变量类型优化：
- 第二个版本使用 [26]byte 而不是 [26]int 作为 key 的类型。byte 是 uint8 的别名，占用更小的内存，在这种场景下是合理的选择，因为字母计数不会超过 255。
- 在性能上，byte 数组的哈希处理可能稍微快一点，因为它是更小的数值类型。
字符索引转换：
- 第一版使用 cCnt[b-'a']，而第二版使用 key[b-97]。两者在功能上是一样的，只是 97 是 'a' 的 ASCII 值，显式的 97 有助于代码执行更直接的索引定位。
- 为了提升可读性，使用 'a' 可以更直观地说明这个值是为了计算字母位置。
初始化变量的方式：
- 第二个版本直接使用 map[...][]string{} 作为 retMap 的初始化方式，写法上更简洁，减少了 make 的调用。
结构一致性：
- retMap 和 ret 在两版代码中分别表示分组字典和结果容器。虽然功能一致，但如果你更喜欢语义化的命名，可以考虑更贴近业务逻辑的命名。

总的来说，这些修改带来了代码的更紧凑写法和微小的内存性能优化。

后面写的这一版明显比之前的要好很多了，而且写得很快

leetcode-401. 二进制手表

2024-10-21T08:54:48.000Z

leetcode-401. 二进制手表

401. 二进制手表

#算法/回溯算法

1,2,4,8
取 2 个

1，2 = 3
1，4 = 5
1，8 = 9
2，4 = 6
2，8 = 10
4，8 = 12

1，2，4 = 7
1，2，8 = 11
1，4，8 = 13
2，4，8 = 14

1，2，4，8

1,2,4,8,16,32

1,2 = 3
1,4 = 5
1,8 = 9
1,16 =17
1,32 = 33
2,4 = 6
2,8 = 10
2,16 = 18
2,32 = 34
4,8 = 12
4,16 = 20
4,32 = 36
8,16 = 24
8,32 = 40
16,32 = 48

1,2,4 = 7
1,2,8 = 11
1,2,16 = 19
1,2,32 = 35
1,4,8 = 13
1,4,16 = 21
1,4,32 = 37
1,8,16 = 25
1,8,32 = 41
1,16,32 = 49
2,4,8 = 14
2,4,16 = 22
2,4,32 = 38
4,8,16 = 28
4,8,32 = 44
8,16,32 = 56

1,2,4,8,16,32

1,2,4,8 = 15
1,2,4,16 = 23
1,2,4,32 = 39
1,4,8,16 = 29
1,4,8,32 = 45
1,8,16,32 = 57
2,4,8,16 = 30
2,4,8,32 = 46
4,8,16,32 = 60

1,2,4,8,16 = 31
1,2,4,8,32 = 47
2,4,8,16,32 = 62

1,2,4,8,16,32 =

枚举出来所有的集合

        $hourSet   = [
            0 => [0],
            1 => [1, 2, 4, 8],
            2 => [3, 5, 9, 6, 10],
            3 => [7, 11],
        ];
        $minuteSet = [
            0 => [0],
            1 => [1, 2, 4, 8, 16, 32],
            2 => [3, 5, 9, 17, 33, 6, 10, 18, 34, 12, 20, 36, 24, 40, 48],
            3 => [7, 11, 19, 35, 13, 21, 37, 25, 41, 49, 14, 22, 38, 28, 44, 56],
            4 => [15, 23, 39, 29, 45, 57, 30, 46],
            5 => [31, 47],
        ];

话不多说，上代码，差点栽在一个简单题手里，也是我没有想到的

其实呢，我有两种思路

一种就是把小时和分钟的所有位表示的数字都枚举出来，然后最后处理一下最后的输出格式就行了，这个可行，但是废手，而且容易出错
另外一种就是利用递归的方式，计算出每一步的所有可能值

第二种方式：

class Solution {
    
    /**
     * @param Integer $turnedOn
     * @return String[]
     */
    public function readBinaryWatch($turnedOn) {
        // 时针最多有 4 个
        // 分针最多亮 6 个
        
        $hour    = [1, 2, 4, 8];
        $minutes = [1, 2, 4, 8, 16, 32];
        
        $ret = [];
        for ($i = 0; $i <= $turnedOn && $i < 4; $i++) {
            $hourPossible   = $this->getSetPossible($hour, $i, 11);
            $minutePossible = $this->getSetPossible($minutes, $turnedOn - $i, 59);
            
            foreach ($hourPossible as $hItem) {
                foreach ($minutePossible as $mItem) {
                    if ($mItem < 10) {
                        $mItem = '0' . $mItem;
                    }
                    $ret[] = $hItem . ':' . $mItem;
                }
            }
        }
        

        
        return $ret;
    }
    
    /**
     * @param $set
     * @param $count
     * @param $maxValue
     * @return array
     */
    public function getSetPossible($set, $count, $maxValue) {
        if ($count == 0) {
            return [0];
        }
        if ($count == 1) {
            return $set;
        }
        
        $setLen = count($set);
        
        $ret = [];
        
        // 第一个值的取值范围
        $maxIndex = $setLen - $count;
        
        // 第一个值的取值范围如果超过,那么退出
        for ($i = 0; $i <= $maxIndex; $i++) {
            $possibleSet = $this->getSetPossible(array_slice($set, $i + 1), $count - 1, $maxValue);
            foreach ($possibleSet as $setItem) {
                if ($setItem + $set[$i] <= $maxValue) {
                    $ret[] = $set[$i] + $setItem;
                }
            }
        }
        
        return $ret;
    }
}

leetcode-303. 区域和检索 - 数组不可变

2024-10-30T15:25:41.000Z

leetcode-303. 区域和检索 - 数组不可变

303. 区域和检索 - 数组不可变 - 力扣（LeetCode）

解法

直接遍历，也能通过

    function sumRangeV1($i, $j) {
        $ret = 0;
        for (; $i <= $j; $i++) {
            $ret += $this->nums[$i];
        }
        return $ret;
    }

~~## 分析下面数组能不能拆分~~

~~[-2, 0, 3, -5, 2, -1]~~

~~1. 拆分成多个数组~~

~~2. 只有 $i >= $left && $j <= $right 才行~~
[1, 2]


感受一下这个版本,代码即注释，就是把前面的和给减掉就行了，也算是一个 dp 

class NumArray {
private:
    int* sum;
public:
    NumArray(vector<int>& nums) {
        //sum[i] 为 nums[0 : i-1]的和
        sum = new int[nums.size() + 1];
        sum[0] = 0;
        for(int i = 1; i <= nums.size(); i++)
            sum[i] = sum[i - 1] + nums[i - 1];
    }
    ~NumArray(){
        delete[] sum;
    }
    int sumRange(int i, int j) {
        return sum[j + 1] - sum[i];
    }
};


作者：realzzg-2
链接：https://leetcode-cn.com/problems/range-sum-query-immutable/solution/qian-zhui-he-ji-hu-shuang-bai-by-realzzg-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2024-10-30

使用前缀和，轻松拿捏

type NumArray struct {
    preSum []int
}


func Constructor(nums []int) NumArray {
    numArray := NumArray{
        preSum: make([]int, len(nums)+1),
    }
    for i := range nums {
        numArray.preSum[i+1] = numArray.preSum[i]+nums[i]
    }

    return numArray
}


func (this *NumArray) SumRange(left int, right int) int {
    return this.preSum[right+1] - this.preSum[left]
}

leetcode-1137第 N 个泰波那契数

2024-09-09T06:55:02.000Z

leetcode-1137第 N 个泰波那契数

1137. 第 N 个泰波那契数
这个跟斐波那契好像是一样的，一模一样

解法

跟斐波纳契数列一样的解法

class Solution {

    /**
     * @param Integer $n
     * @return Integer
     */
    function tribonacci($n) {
        if ($n <= 0) {
            return 0;
        }
        
        $retArr = [0,1,1];
        for ($i = 3; $i <= $n; $i++) {
            $retArr[$i] = $retArr[$i-1] + $retArr[$i-2] + $retArr[$i-3];
        }

        return $retArr[$n];
    }
}

参考

leetcode-1014. 最佳观光组合

2024-02-28T14:24:03.000Z

#leetcode

leetcode-1014. 最佳观光组合

1014. 最佳观光组合

解法

转换一下公式

vn 代表 i 与 j 的值
fn 为最大值

因为 values[j] - j 是固定的，所以，只需要求 values[i] + i 的最大值就可以了

\begin{array}{l} v_{n} = values [i] + i + values [j] - j \\ f_{n} = max (values [i] + i + values [j] - j \end{array}

class Solution {
    
    /**
     * @param Integer[] $values
     * @return Integer
     */
    function maxScoreSightseeingPair($values) {
        $len = count($values);
        $max = $maxI = 0;
        for ($i = 0; $i < $len; $i++) {
            $max = max($max, $maxI + $values[$i] - $i);
            $maxI = max($values[$i], $maxI);
        }
        
        return $max;
    }
}

参考

官方题解

72. 编辑距离

2024-11-08T04:32:31.000Z

72. 编辑距离

72. 编辑距离 - 力扣（LeetCode）

学习

chatgpt对话
https://chatgpt.com/share/672cf317-1db4-8002-88ab-097738bce5b1

代码

func minDistance(word1 string, word2 string) int {
    if len(word1) == 0 || len(word2) == 0 {
        return max(len(word1), len(word2))
    }

    dp := make([][]int, len(word1)+1)

    for i := range dp {
        dp[i] = make([]int, len(word2)+1)
        dp[i][0] = i
    }

    for j := range dp[0] {
        dp[0][j]= j
    }

    for i:=1;i<len(dp);i++ {
        for j:=1;j<len(dp[i]);j++ {
            if word1[i-1] == word2[j-1] {
                dp[i][j] = dp[i-1][j-1]
            } else {
                dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1])+1
            }
        }
    }

    return dp[len(word1)][len(word2)]
}

关键在于填表

这个解法能打败50%，还有其他的解法，灵神的视频讲解的很清楚：最长公共子序列编辑距离_哔哩哔哩_bilibili

59. 螺旋矩阵 II

2024-11-09T10:21:08.000Z

59. 螺旋矩阵 II

59. 螺旋矩阵 II - 力扣（LeetCode）

代码

func generateMatrix(n int) [][]int {
    res := make([][]int, n)

    for i := range res {
        res[i] = make([]int, n)
    }

    // 方向
    // 右下左上
    direction := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}

    curDirectionIdx := 0
    curPos := []int{0, 0}
    for i := 0; i < n*n; i++ {
        res[curPos[0]][curPos[1]] = i+1

        nexPos := []int{curPos[0]+direction[curDirectionIdx][0], curPos[1] + direction[curDirectionIdx][1]}
        if  nexPos[0] < 0 || nexPos[0] >= n ||
            nexPos[1] < 0 || nexPos[1] >= n || 
            res[nexPos[0]][nexPos[1]] > 0 {
                curDirectionIdx = (curDirectionIdx+1)%4
                nexPos = []int{curPos[0]+direction[curDirectionIdx][0], curPos[1] + direction[curDirectionIdx][1]}
        }

        curPos = nexPos
    }

    return res
}

非常好，螺旋矩阵做的很快

几个关键因素

定义方向数组
当前方向
当前位置
转方向的条件

上一题： 54. 螺旋矩阵
上一题使用的是题解中某一个做法，四次方向转换都在循环中完成

这次用的是方向做法

560. 和为 K 的子数组

2024-10-30T15:40:32.000Z

560. 和为 K 的子数组

560. 和为 K 的子数组 - 力扣（LeetCode）

func subarraySum(nums []int, k int) int {
    cntMap := make(map[int]int, len(nums))
    cntMap[0] = 1

    currentSum := 0
    ans := 0

    for _, num := range nums {
        currentSum+=num

        if val, ok := cntMap[currentSum-k]; ok {
            ans+=val
        }

        cntMap[currentSum]++
    }

    return ans
}

刚开始一直看不懂 currentSum-k 什么意思，后来问了下chatgpt。看下原话：

[!NOTE]

这段代码的目的是检查当前的前缀和减去目标值 k 是否存在于哈希表 sumCount 中，从而帮助我们找到和为 k 的子数组。我们来详细解析一下：

前缀和的概念：

前缀和是指数组中从第一个元素到当前元素的和。例如，对于数组 [1, 2, 3]，其前缀和为：

累计到第一个元素：1

累计到第二个元素：1 + 2 = 3

累计到第三个元素：1 + 2 + 3 = 6

在代码中，currentSum 表示当前遍历到某个元素时的前缀和。

为什么要检查 currentSum - k：

如果当前前缀和是 currentSum，我们希望找到一个子数组，使得这个子数组的和为 k。

设这个子数组的起始位置为 j，那么可以得出：
$sum (j, i) = currentSum - sum (0, j - 1) = k$
其中 i 是当前元素的索引。

通过变形可以得到：

$sum (0, j - 1) = currentSum - k$

这意味着，如果我们能找到某个位置的前缀和等于 currentSum - k，那么从 j 到 i 的子数组的和就是 k。

哈希表的作用：

哈希表 sumCount 记录了每个前缀和出现的次数。

当我们检查 currentSum - k 是否存在于哈希表中时，如果存在，说明从某个之前的位置到当前的位置形成的子数组的和正好是 k。

val 是 sumCount[currentSum-k] 的值，表示前缀和为 currentSum - k 的次数，即表示有多少个以该前缀和为起点的子数组的和为 k。

计数更新：

如果找到了 val，就说明当前前缀和之前有 val 个起点可以形成和为 k 的子数组，因此我们把 count 增加 val。

总之，这段代码的核心思想是利用前缀和的特性，通过检查哈希表来高效地找到和为 k 的子数组。如果有任何具体的疑问，欢迎继续提问！

关键点是这里：

如果当前前缀和是 currentSum，我们希望找到一个子数组，使得这个子数组的和为 k。
设这个子数组的起始位置为 j

遍历到i时，求以i结尾的子数组的和有哪些是k

这个解释相当清晰，写代码也就几分钟就写完了

前缀和如何求可以看： leetcode-303. 区域和检索 - 数组不可变

56. 合并区间

2024-10-24T16:00:24.000Z

56. 合并区间

第一版

import (
	"slices"
)

func merge(intervals [][]int) [][]int {
    // 根据数组的第一个元素进行排序
    slices.SortFunc(intervals, func(a, b []int) int {
        if a[0] < b[0] {
            return -1
        } else if a[0] == b[0] {
            return 0
        } else {
            return 1
        }
    })


    // 依次合并每一个元素
    ret := [][]int{}

    item := intervals[0]
    for i:=1;i<len(intervals);i++ {
        if item[1] < intervals[i][0] {
            ret = append(ret, item)
            item = intervals[i]
        } else {
            item[1] = max(intervals[i][1], item[1])
        }
    }

    ret = append(ret, item)
    return ret
}

优化的点

sortFunc 那里太啰嗦了
没必要加一个item，直接用intervals的尾部进行比较即可

import (
	"slices"
)
func merge(intervals [][]int) [][]int {
    // 根据数组的第一个元素进行排序
    slices.SortFunc(intervals, func(a, b []int) int {
        return a[0]-b[0]
    })


    // 递归合并每一个元素
    ret := [][]int{intervals[0]}
    for i:=1;i<len(intervals);i++ {
        if ret[len(ret)-1][1] < intervals[i][0] {
            // 无法合并
            ret = append(ret, intervals[i])
        } else {
            // 可以合并
            ret[len(ret)-1][1] = max(intervals[i][1], ret[len(ret)-1][1])
        }
    }

    return ret
}

经过优化之后，虽然代码执行用时没有太大的变化，但是更简洁更精炼了，而且减少了一个临时变量的使用

55. 跳跃游戏

2024-11-16T14:38:10.000Z

55. 跳跃游戏

55. 跳跃游戏 - 力扣（LeetCode）

代码一

func canJump(nums []int) bool {

	jumpMap := make(map[int]struct{}, 0)

    jumpMap[0] = struct{}{}

	for i := 0; i < len(nums); i++ {
        if _, ok := jumpMap[i]; !ok {
            continue
        }

		if nums[i]+i+1 >= len(nums) {
			return true
		}

		for j := 1; j <= nums[i]; j++ {
			jumpMap[i+j] = struct{}{}
		}
	}

    return false
}

[!NOTE]
执行用时分布

1145ms

击败5.13%

执行时间很长，但是能通过

代码二 - 贪心

func canJump(nums []int) bool {
    maxReachNum := 0

    for i := range nums {
	    // 如果最大值已经超过了最大索引，那么直接返回
        if maxReachNum >= len(nums)-1 {
            return true
        }
        if i > maxReachNum {
            return false
        }

        maxReachNum = max(maxReachNum, i+nums[i])
    }

    return true
}

维护一个最大可以到达的最大值，如果 i 比这个值大，那么就代表，无法继续往后走了

54. 螺旋矩阵

2024-10-28T12:54:51.000Z

54. 螺旋矩阵

func spiralOrder(matrix [][]int) []int {
    ret := []int{}
    if len(matrix) == 0 {
        return ret
    }

    left:=0
    right:=len(matrix[0])-1
    top:=0
    bottom:=len(matrix)-1

    for {
 

        for j:=left;j<=right;j++ {
            ret = append(ret, matrix[top][j])
        }
        top++
        if top > bottom {
            break
        }

        for i:=top; i <= bottom;i++ {
            ret = append(ret, matrix[i][right])
        }
        right--
        if right < left {
            break
        }

        for j:=right;j >= left;j-- {
            ret = append(ret, matrix[bottom][j])
        }
        bottom--
        if bottom < top {
            break
        }

        for i := bottom;i >= top;i-- {
            ret = append(ret, matrix[i][left])
        }
        left++
        if left > right {
            break
        }
    }

    return ret
}

看了题解，基本就是两种做法，一种是限制左右上下四个边界的数值，达到在各个方向移动时不超过限制

另外一种是dfs，设置四个遍历方向，循环往复，直到所有的块被遍历完全

5. 最长回文子串

2024-09-12T02:27:44.000Z

5. 最长回文子串

动态规划很多时候就是在填表

暴力解法
动态规划
马拉车算法，没仔细看

动态规划算法：

func longestPalindrome(s string) string {
    return dynamic(s)    
}

func dynamic(s string) string {

    dp := make([][]bool, len(s))

    for i := range dp {
        dp[i] = make([]bool, len(s))
        dp[i][i] = true
    }

    ret := s[0:1]
    mxLen := 1
    for j := 1; j < len(s); j++ {
        for i := 0; i<j; i++ {
            if s[i] == s[j] {
                if j-i < 3 {
                    dp[i][j] = true
                } else {
                    dp[i][j] = dp[i+1][j-1]
                }
                if dp[i][j] && j-i+1 > mxLen {
                    mxLen = j-i+1
                    ret = s[i:j+1]
                }
            } else {
                dp[i][j] = false
            }
        }
    }

    return ret
}

初始化：

填表格，对角线，也就是 i=j 时，单个字符，都是回文串，设置为 true dp[i][i] = true

遍历顺序：

因为初始化的是对角线，也就是如图所示：
图中对角线坐标写错了，应该是 [0,0] [1,1] [2,2] [3,3]

如果按照平常的顺序，这么写代码遍历

for i := 0; i < len(s); i++ {
	for j := i+1; j<len(s); j++ {
		...
	}
}

那么会有如图所示的问题，[0,3] 会因为需要 [1,2] 的结果从而导致无法推算出正确的结果

所以需要这么遍历，就能够使用到上一列的数据

239. 滑动窗口最大值

2024-11-08T16:09:01.000Z

239. 滑动窗口最大值

239. 滑动窗口最大值 - 力扣（LeetCode）

这是一道困难题，虽然我看了题解，但是我感觉没有这么困难

代码


func maxSlidingWindow(nums []int, k int) []int {
    res := make([]int, 0, len(nums)-k+1)

    deque := make([]int, 0, k)

    for i := 0; i < len(nums); i++ {
        for len(deque) > 0 && nums[deque[len(deque)-1]] < nums[i] {
            // 将最后一个元素去掉
            deque = deque[:len(deque)-1]
        }

        deque = append(deque, i)

        if i - deque[0] >= k {
            deque = deque[1:]
        }

        // fmt.Println(deque)

        // 获取当前窗口结果
        if i >= k-1 {
            res = append(res, nums[deque[0]])
        }
    }

    return res
}

chatgpt 聊天内容： https://chatgpt.com/c/672e2ed7-8a7c-8002-abe2-a8bc52af9e74

deque 维护了一个单调递减的双端队列，存储的是索引值。
每次遍历时，先清理不在窗口范围内的元素，然后清除比当前值小的所有元素（保证队列从大到小）。
每当窗口达到大小 k 时，将队列的第一个元素（最大值）添加到结果数组中。

200. 岛屿数量

2024-10-21T14:37:10.000Z

200. 岛屿数量

原始写的是这段代码，虽然能执行成功，但是不是很优雅


import "fmt"
var cnt int

func numIslands(grid [][]byte) int {
    cnt=0
    used := map[[2]int]bool{}

    for i := 0; i < len(grid); i++ {
        for j := 0; j < len(grid[i]); j++ {
            dfs(i,j,grid, used, 0)
            // fmt.Println(i,j)
        }
    }

    return cnt
}

func dfs(i int, j int, grid [][]byte, used map[[2]int]bool, depth int) {
    if used[[2]int{i,j}] {
        return
    }

    if grid[i][j] == 48 {
        return
    }
    
    if depth == 0 {
        cnt++
        // fmt.Println(cnt)
    }

    used[[2]int{i,j}] = true

    depth++

    // 上
    if i> 0 {
        dfs(i-1, j, grid, used, depth)
    }

    // 下
    if i < len(grid)-1 {
        dfs(i+1,j,grid,used, depth)
    }

    // 左
    if j>0 {
        dfs(i, j-1, grid, used, depth)
    }

    // 右
    if j < len(grid[i])-1 {
        dfs(i, j+1, grid, used, depth)
    }
}

优化这段代码：

这段代码的目的是计算一个二维 grid 中的岛屿数量（岛屿由值为 1 的相邻单元格组成）。优化点主要在于减少冗余逻辑和提升代码可读性。我们可以进行以下几个优化：

移除不必要的 depth 参数：depth 仅用于判断是否递归的第一层，可以通过直接判断当前格子是否已经访问过和是否为岛屿来增加 cnt。
减少重复的 used 判断：在 dfs 中每次递归之前判断是否已经访问过，可以减少逻辑冗余。
直接在 numIslands 函数中判断是否需要调用 dfs：如果当前格子已经访问或不是岛屿，则不需要调用 dfs。

以下是优化后的代码：

import "fmt"

var cnt int

func numIslands(grid [][]byte) int {
    cnt = 0
    used := map[[2]int]bool{}

    for i := 0; i < len(grid); i++ {
        for j := 0; j < len(grid[i]); j++ {
            // 如果当前格子是岛屿并且没有被访问过，才进行 DFS
            if grid[i][j] == '1' && !used[[2]int{i, j}] {
                cnt++
                dfs(i, j, grid, used)
            }
        }
    }

    return cnt
}

func dfs(i, j int, grid [][]byte, used map[[2]int]bool) {
    if i < 0 || i >= len(grid) || j < 0 || j >= len(grid[i]) || grid[i][j] == '0' || used[[2]int{i, j}] {
        return
    }

    used[[2]int{i, j}] = true

    // 上
    dfs(i-1, j, grid, used)
    // 下
    dfs(i+1, j, grid, used)
    // 左
    dfs(i, j-1, grid, used)
    // 右
    dfs(i, j+1, grid, used)
}

优化细节：

简化了 dfs 函数调用的逻辑：通过提前判断边界和条件来减少递归深度的传递，不需要再维护 depth。
减少了冗余的判断：在 numIslands 中，只有当当前格子是 1 并且没有被访问过时，才开始深度优先搜索，避免了不必要的 dfs 调用。
代码更简洁可读：直接通过坐标来判断上下左右的格子，没有再单独去处理 depth 相关的逻辑。

这样，代码运行效率会更高，并且可读性也更好。

进一步优化

在进一步优化这段代码时，可以考虑以下几个方面：

移除 used 变量：由于我们可以直接修改 grid，将访问过的岛屿格子改为 '0'，这样不需要额外维护一个 used 哈希表来记录访问状态。这样还能减少空间复杂度。
减少递归开销：由于递归调用可能在深度较大时导致栈溢出，可以使用非递归的方式实现深度优先搜索 (DFS)。但为了简单起见，保持递归的实现并优化它。
整合重复代码：可以将上、下、左、右的逻辑整合成方向数组，以减少重复的代码行。

优化后的代码如下：

import "fmt"

func numIslands(grid [][]byte) int {
    cnt := 0

    for i := 0; i < len(grid); i++ {
        for j := 0; j < len(grid[i]); j++ {
            if grid[i][j] == '1' {
                cnt++
                dfs(i, j, grid)
            }
        }
    }

    return cnt
}

func dfs(i, j int, grid [][]byte) {
    if i < 0 || i >= len(grid) || j < 0 || j >= len(grid[i]) || grid[i][j] == '0' {
        return
    }

    // 标记已访问
    grid[i][j] = '0'

    // 定义方向数组，上下左右
    directions := [][2]int{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}

    // 遍历四个方向
    for _, dir := range directions {
        ni, nj := i+dir[0], j+dir[1]
        dfs(ni, nj, grid)
    }
}

进一步优化后的改进点：

移除了 used 变量：我们直接修改 grid 来标记已经访问过的节点，这样节省了空间复杂度，不需要额外维护一个哈希表。
方向数组简化代码：用一个方向数组代替上下左右的手动递归调用，代码更加简洁，易于扩展到其他问题。
递归更加直观：去掉了不必要的条件检查，将条件判断直接放在 dfs 开头，逻辑更加简洁。

时间和空间复杂度：

时间复杂度: O(M * N)，其中 M 和 N 分别是 grid 的行数和列数，每个元素最多访问一次。
空间复杂度: O(M * N)，最坏情况下，递归深度可能达到 M * N。

这段代码的性能已经比较接近理论最优，并且代码结构更加简洁，维护和理解成本更低。

总结：

最大的优化，通过 grid 中的1改成0，直接省略掉used或者叫visited数组。时间直接从超越5%升到80%

一个小技巧，方向遍历时定义方向数组：

// 定义方向数组，上下左右
directions := [][2]int{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}
// 遍历四个方向
for _, dir := range directions {
	ni, nj := i+dir[0], j+dir[1]
	dfs(ni, nj, grid)
}

感慨一下，现在的chatgpt真的好用，学习东西时非常有用

14. 最长公共前缀

2024-10-25T15:47:26.000Z

14. 最长公共前缀

14. 最长公共前缀 - 力扣（LeetCode）

第一版


import (
	"math"
)
func longestCommonPrefix(strs []string) string {
    ret := []byte{}

    minLen := math.MaxInt
    for _, s := range strs {
        minLen = min(minLen, len(s))
    }

    for i := 0; i < minLen; i++ {

        for j := range strs {
            if j == 0 {
                continue
            }

            if strs[j][i] != strs[0][i] {
                return string(ret)
            }
        }

        ret = append(ret, strs[0][i])
    }

    return string(ret)
}

可以将长度判断放到循环里面去做
直接遍历第一个元素就行了，如果遇到不相等的，直接返回prefix，遇到相等的就继续，最多也就是第一个元素这么长

第二版


func longestCommonPrefix(strs []string) string {
    for j, b := range []byte(strs[0]) {
        for _, s := range strs {
            if j == len(s) || s[j] != b {
                return strs[0][:j]
            }
        }
    }

    return strs[0]
}

参考了一下灵神的答案，优雅

贴个灵神答案的链接：简单题，简单做（Python/Java/C++/C/Go/JS/Rust）

希望我以后做题也是这么举重若轻

128. 最长连续序列

2024-10-26T10:01:11.000Z

128. 最长连续序列

看了题解：

func longestConsecutive(nums []int) int {
    nMap := map[int]bool{}

    for _, n := range nums {
        nMap[n]=true
    }

    longest := 0
    for n := range nMap {
        if nMap[n-1] {
            continue
        }

        cur := 0
        for nMap[n] {
            n++
            cur++
        }

        longest = max(longest, cur)
    }

    return longest
}

https://leetcode.cn/problems/longest-consecutive-sequence/solutions/276931/zui-chang-lian-xu-xu-lie-by-leetcode-solution

这个大哥的评论比较好理解：

1143. 最长公共子序列

2024-11-10T11:42:56.000Z

1143. 最长公共子序列

1143. 最长公共子序列 - 力扣（LeetCode）

代码

func longestCommonSubsequence(text1 string, text2 string) int {
	len1 := len(text1)
	len2 := len(text2)
	if len1 == 0 || len2 == 0 {
		return 0
	}

	dp := make([][]int, len1+1)

	for i := range dp {
		dp[i] = make([]int, len2+1)
	}

	for i := 1; i <= len1; i++ {
		for j := 1; j <= len2; j++ {
			if text1[i-1] == text2[j-1] {
				dp[i][j] = dp[i-1][j-1] + 1
			} else {
				dp[i][j] = max(dp[i-1][j], dp[i][j-1])
			}
		}
	}

	return dp[len1][len2]
}

这一题的核心思想是，选或者不选

如果遍历时，
当前的两个字符相等，那么必须选，那么就是：

d p [i] [j] = d p [i - 1] [j - 1] + 1

这里加的1就代表选中了当前的值， $d p [i - 1] [j - 1]$ 代表不选i，不选j的最大值

如果两个字符不相等，那就是有三种情况，那就是：

不选i，选j
选i，不选j
不选i，不选j

d p [i] [j] = m a x (d p [i - 1] [j], d p [i] [j - 1], d p [i - 1] [j - 1])

因为【不选i，不选j】这种情况被前两种包含进去了，所以代码中可以省略

最终的转移方程：

d p [i] [j] = {\begin{cases} d p [i - 1] [j - 1] + 1, & t e x t 1 [i] == t e x t 2 [j] \\ m a x (d p [i - 1] [j], d p [i] [j - 1]), & t e x t 1 [i]! = t e x t 2 [j] \end{cases}

leetcode 编码技巧

2024-10-21T13:51:27.000Z

leetcode 编码技巧

编码技巧

1 数字

1.1 快速上取整

正整数的情况下， a/b 上取整可以使用 :
(a+b-1)/b 快速计算，适用于强类型语言

1.2 取中间数

强类型语言：(left+right)/2 。此方式在 left+right 时有可能会出现溢出，可以使用 left-(left-right)/2 计算

1.3 整除

123 >> 1 // 右移一位即可完成整除

2 二进制

2.1 最低位1变0

num1 &= num1 - 1  // 最低的 1 变成 0

2.2 最低位0变1

num1 |= num1 + 1 // 最低的 0 变成 1

2.3 判断是否是2的整数次

if (num & (num - 1)) == 0 {
	return true
}

2.4 0和1取反

x ^= 1

func flip(a int) int {
	if a == 0 {
		return 1
	}

	return 0
}

x = 1 - x

3 数组

3.1 双指针

1. 两数之和 - 力扣（LeetCode）
leetcode-42. 接雨水
对向双指针 leetcode-11. 盛最多水的容器

3.2 前缀和

pre := []int{}

for i := range nums {
	if i == 0 {
		pre[i] = 0
		continue
	}

	pre[i] = pre[i-1] + nums[i-1]
}

3.2.1 从前缀和中获取后缀和

// 小技巧，前缀和也能得出后缀和
if i == 0 {
    postfixSum = prefixSum[len(prefixSum)-1]
} else {
    postfixSum = prefixSum[len(prefixSum)-1] - prefixSum[i-1]
}

4 深度搜索

4.1 方向

在做深度搜索题时，经常用到方向，可以用下面的代码判断方向

var (
    dx = []int{1, 0, 0, -1}
    dy = []int{0, 1, -1, 0}
)

// 四个方向
for j := 0; j < 4; j++ {
    mx, my := cell[0] + dx[j], cell[1] + dy[j]
    // 查看每个方向有没有超出边界，如果没有超出边界则进行处理
    if mx >= 0 && mx < n && my >= 0 && my < m && image[mx][my] == currColor {
        queue = append(queue, []int{mx, my})
        image[mx][my] = color
    }
}

5 字符串

5.1 字符在数组中的偏移位置

widths[c-'a']

6 矩阵

判断点在对角线上

7 Reference

202404091044 leetcode-会员购买优惠-宫水三叶

2024-10-21T13:53:50.000Z

202404091044 leetcode-会员购买优惠-宫水三叶

宫水三叶的优惠链接，多 60 天： https://leetcode.cn/premium/?promoChannel=acoier

年度会员 : 加赠 425−365=60 天
季度会员 : 加赠 104−90=14 天

同时，同时，同时！！！你还将获取如下福利：

返佣红包：年度会员获得定额红包 ¥66.66（折算后 ¥1.02/天），季度会员获得定额红包 ¥22.22（折算后 ¥1.70/天）

巨划算的 LeetCode 会员专属福利 ~

20240417125706 部落冲突

2024-04-30T13:19:25.000Z

20240417125706 部落冲突

部落冲突玩到13本了，原来部落联盟的人都没了，然后也没有什么动力能继续玩下去，就这样偶尔上线一次了

20240415142052 原神挺好玩

2024-10-12T14:42:54.000Z

20240415142052 原神挺好玩

最近游戏一直在玩原神，一个开放的大世界。主线剧情刚刚做完，确实是我想象中的角色扮演（RPG）游戏。

记得高中在塞班手机上玩的一款RPG游戏，一个周末都在刷怪。后来重新练了个号，结果跟大师傅打架的时候，他的70级宠物不知道为什么变成我的了。我就带着一个70级将近满级的宠物一路过关斩将玩通关了。

原神里面我自己感觉可玩的点有几个：

角色都很二次元，都是按照动漫里面的角色画出来的，二次元的估计会很喜欢。
剧情比较代入，某些剧情需要努力打怪，不过主线剧情并不是很难。
大世界地图非常大，如果不是有传送节点估计跑图都得跑断腿。
大世界里面有很多宝箱，有些宝箱需要解密之后才能获得，不过这些宝箱都是一次性的，我在蒙德、璃月、稻妻的探索度最高才到 50% ，所以也可见大世界有多大东西有多丰富。
支线剧情也很丰富多彩，比如我就特别喜欢璃月里面的一个支线剧情《神女劈观》，并且剧情最后有一首歌，大家可以先听一下。不过没有了解剧情之前听这首歌触动应该不是很大，还是具体体验一下剧情再说。点击可播放：
最后一点，原神不花钱氪金也可以玩的很舒服，每天做做每日任务，开开宝箱，欣赏欣赏美景，然后读一读角色的背景故事。

对了，游戏社区里的前辈忠告，当深渊不存在，能打到哪里就打到哪里。

树莓派无法上网排查

2024-10-23T14:09:35.000Z

树莓派无法上网排查

wget -v baidu.com
- 会有输出：
- 如何处理呢

--2021-07-15 10:52:24--  http://baidu.com/
Resolving baidu.com (baidu.com)... 39.156.69.79, 220.181.38.148
Connecting to baidu.com (baidu.com)|39.156.69.79|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 81 [text/html]
Saving to: ‘index.html’

上次我就卡在了解析 baidu.com 域名这个地方

通过 linux-nslookup 命令查看路由解析
- 发现解析不通
- 查看 /etc/resolv.conf 将 nameserver 改成： 114.114.114.114
- 再次查看路由解析，发现已经 OK 了
如何修改 /etc/resolv.conf ，重启机器之后会发现文件又被改回去了，导致无法联网，正确的做法
- sudo vi /etc/systemd/resolved.conf
- 重启网络服务 sudo service networking restart

树莓派4B】三、笔记本给树莓派Ubuntu 18.04提供网络|为什么Ubuntu18.04更改/etc/resolv.conf修改nameserver重启网络被重置

ubuntu 树莓派启动时配置网络

2024-09-24T10:53:22.000Z

ubuntu 树莓派启动时配置网络

树莓派现在可以安装很多操作系统，其中 ubuntu 也提供了树莓派版本，因为对 ubuntu 更加熟悉，所以就往 SD 卡中烧录了 ubuntu 的 20.04 lts 64位 版本。这里有可供选择的操作系统。

简单提一嘴烧录操作系统到 SD 卡上面的方法，树莓派提供了一个傻瓜式的软件给大家使用，直接打开之后选择系统，就可以烧录了，烧录过程大概会有几分钟。

烧录完成之后，如果你按照树莓派官网的教程进行操作，肯定都行不通，因为树莓派的官方操作系统 Raspberry Pi OS 和 Ubuntu For Raspberry 上面的网络配置方式完全不一样。

1 安装了 ubuntu 的树莓派怎么配置网络？

打开你烧录好的 SD 卡

找到 network-config 文件

写入如下配置：

wifis:
  wlan0:
  dhcp4: true
  optional: true
  access-points:
    <wifi network name>:
      password: "<wifi password>"

如果是企业网络：

wifis:
  wlan0:
  dhcp4: true
  optional: true
  access-points:
        <wifi network name>:
          auth:
            key-management: eap
            method: peap
            identity: "wudanyang"
            password: ""

配置文件的格式

修改完之后，把 SD 卡从电脑上弹出，然后插到树莓派里。

不过，重启之后，你可能还是无法连接到网络。可以看下这里

Note: During the first boot, your Raspberry Pi will try to connect to this network. It will fail the first time around. Simply reboot sudo reboot and it will work.

引用ubuntu官网的一段话，第一次会失败，直接重启，第二次就能连上了。

2 开启网络之后，如何登录树莓派？

安装好之后默认用户名和密码都是 ubuntu

ssh ubuntu@<raspberry ip>

ip 地址的获取这里列举几种方法，不详细介绍：

自己的路由器：登录后台查看分配的 ip
局域网扫描（局域网机器不多的情况下）：
1. 下载个局域网扫描工具，如果局域网机器不多，会看到一个制造商为树莓派的 ip
2. 使用命令行 arp -a 挨个试一下
ubuntu 启动之后会使用 avahi 服务通过 mdns 协议在局域网注册一个域名 ubuntu.local，所以你可以这样登录 ssh ubuntu@ubuntu.local

参考

Mac通过网线直连控制树莓派 - lonerpaul - 博客园

202103251635 - 获取树莓派温度

2024-10-21T08:54:22.000Z

202103251635 - 获取树莓派温度

cat /sys/class/thermal/thermal_zone0/temp

取出值后除以 1000

写个脚本获取

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import commands

def main():
# 查看GPU温度
    gpu = commands.getoutput( '/opt/vc/bin/vcgencmd measure_temp' ).replace( 'temp=', '' ).replace( '\'C', '' )
    gpu = float(gpu)
    print('gpu Temp: %.2f ' % gpu)
	
# 查看CPU温度
    file = open("/sys/class/thermal/thermal_zone0/temp")
    cpu = float(file.read()) / 1000
    file.close()
    print('cpu Temp: %2.2f' % cpu)

if __name__ == '__main__':
    main()

https://my.oschina.net/zhenggao/blog/4336898

202404191548 GTD的主要思想

2024-04-20T16:16:11.000Z

202404191548 GTD的主要思想

把事情做好
执行时是拿结果engage（而不是仅仅去 exec）

主要思想：

捕获
处理，明确下一步行动是什么

bilibili教程

重新认识GTD

#Omnivore

Read on Omnivore
Read Original

Notes

操作系统-内核态与用户态

2024-10-21T08:56:43.000Z

操作系统-内核态与用户态

System: You are a helpful AI assistant.

User: 请说明linux操作系统的系统调用过程的全过程，并配上必要的mermaid图解

Assistant: 在Linux操作系统中，系统调用是用户空间进程与内核空间通交流的主要方式。以下是系统调用过程的全过程：

用户空间进程通过库函数发起系统调用。这些库函数通常是glibc库中的封装函数，如open(), read(), write()等。这些函数内部实际上是通过使用特定的系统调用号和参数来发起系统调用的。
库函数将系统调用号和参数放入适当的寄存器，然后执行一个特殊的陷阱指令（如int 0x80或syscall）。这个指令将CPU从用户模式切换到内核模式，并跳转到内核中预定义的固定地址开始执行。
内核检查系统调用号和参数的有效性，然后找到对应的内核函数并执行。
内核函数执行完毕后，将返回结果放入一个寄存器，然后执行一个特殊的指令（如iret）来将CPU从内核模式切换回用户模式，并跳回到库函数。
库函数从寄存器取出返回结果，然后返回给用户空间进程。

以下是对应的mermaid图解：

sequenceDiagram
    participant P as 用户空间进程
    participant L as 库函数
    participant K as 内核
    P->>L: 发起系统调用
    L->>K: 执行陷阱指令
    K->>K: 检查系统调用号和参数
    K->>K: 执行内核函数
    K->>L: 返回结果
    L->>P: 返回结果

这个图解描述了用户空间进程、库函数和内核之间在系统调用过程中的交互。

User: 从进程或者线程的角度看系统调用是怎样的

Assistant: 从进程或线程的角度来看，系统调用可以被视为一个函数调用。进程或线程通过调用特定的库函数（如open(), read(), write()等）来发起系统调用。然而，与普通的函数调用不同，系统调用涉及到用户空间和内核空间之间的切换。

当进程或线程发起系统调用时，它将被挂起，直到系统调用完成。此时，CPU从用户模式切换到内核模式，开始执行内核中的代码。这种模式切换是必要的，因为内核空间可以访问硬件和所有系统资源，而用户空间的访问权限则被严格限制。

系统调用完成后，结果会被返回到用户空间，CPU模式切换回用户模式，进程或线程继续执行。

因此，即使系统调用看起来像一个简单的函数调用，但它实际上涉及到了许多复杂的步骤，包括模式切换、权限检查、参数验证等。

以下是对应的mermaid图解：

sequenceDiagram
    participant T as 线程/进程
    participant L as 库函数
    participant K as 内核
    T->>L: 调用库函数（如open(), read()等）
    L->>K: 执行陷阱指令，将CPU从用户模式切换到内核模式
    K->>K: 检查参数，执行对应的内核函数
    K->>L: 执行完毕，将结果返回到用户空间，CPU切换回用户模式
    L->>T: 返回结果

这个图解描述了线程/进程、库函数和内核之间在系统调用过程中的交互。

User: 进程做完系统调用操作之后，处理系统调用的进程还是原来的进程吗？

Assistant: 是的，处理系统调用的仍然是原来的进程。当一个进程发起系统调用时，它并没有改变，也没有被替换或转换。相反，它只是暂时地切换到了内核模式，以便内核可以代表它执行特定的操作，如读取文件、打开网络连接等。

在系统调用完成后，控制权将返回到原来的进程，进程将继续从系统调用返回点开始执行。因此，尽管系统调用涉及到用户空间和内核空间之间的上下文切换，但发起系统调用的进程始终保持不变。

这也是为什么系统调用常常被描述为"昂贵"或"耗时"的操作，因为涉及到上下文切换和模式切换，这些都是需要消耗处理器时间的操作。但是，这是必要的，因为它使得用户空间的进程能够安全地访问硬件和系统资源，而不需要关心底层的细节。

User: 为什么有的地方说是先通过软中断陷入系统内核，然后由内核线程执行系统调用，然后再返回给用户线程？

Assistant: 首先，我们需要理解这里的"软中断"和"内核线程"。

软中断（也被称为软件中断或陷阱）是一种 CPU 指令，它会引发 CPU 切换到内核模式并开始执行内核代码。这就是进程如何发起系统调用的：它通过执行一个软中断指令（如 int 0x80 或 syscall），将 CPU 从用户模式切换到内核模式，并跳转到内核中的预定义地址开始执行。

内核线程是内核的一部分，它在内核空间中运行，并且可以访问所有的系统资源和硬件。当进程发起系统调用时，实际上是由内核线程来完成这个调用的。内核线程会检查系统调用的参数、执行相应的内核函数，然后将结果返回给用户空间。

所以，当我们说"通过软中断陷入系统内核，然后由内核线程执行系统调用，然后再返回给用户线程"，其实是这样的过程：

用户线程（或进程）通过执行一个软中断指令，发起一个系统调用。
CPU 切换到内核模式，开始执行内核代码。
内核线程接管，检查系统调用的参数、执行相应的内核函数。
内核线程执行完毕，将结果返回给用户空间。
CPU 切换回用户模式，用户线程（或进程）继续执行。

这就是为什么有的地方会说是通过软中断陷入系统内核，然后由内核线程执行系统调用，然后再返回给用户线程。这个表述可能会让人误解为系统调用是由另一个线程来完成的，但实际上是由同一个进程（只不过是在内核模式下）来完成的。

User: 但是你上文所说的：【当一个进程发起系统调用时，它并没有改变，也没有被替换或转换。相反，它只是暂时地切换到了内核模式，以便内核可以代表它执行特定的操作，如读取文件、打开网络连接等。】和现在说的需要一个内核线程执行，不是自相矛盾的吗？

Assistant: 对不起，让我们来澄清一下。当我们说“内核线程执行系统调用”时，实际上是指在内核模式下的原始进程（或线程）。

在大多数情况下，当一个用户进程发起一个系统调用时，该进程会切换到内核模式并继续执行。在这种情况下，我们可以将其视为“内核线程”，因为它现在正在执行内核代码，尽管它实际上仍然是原始的用户进程。

所以，当我们说“内核线程执行系统调用”时，我们实际上是指原始的用户进程，但现在它正在内核模式下执行。

这是一个复杂的概念，因为它涉及到操作系统的用户模式和内核模式之间的切换，以及用户进程和内核线程之间的区别。我希望这个解释能够帮助你理解。再次对之前可能造成的混淆表示歉意。

总结：
当然，让我们总结一下关于Linux系统调用和进程在用户空间和内核空间之间交互的讨论：

系统调用概念：系统调用是用户空间进程请求操作系统内核提供服务的机制。这些服务包括文件操作、进程控制、网络通信等。
发起系统调用：用户进程通过库函数（如C标准库中的封装函数）发起系统调用。这些库函数将系统调用号和参数放入适当的寄存器，并执行一个特殊的软中断指令（如int 0x80或syscall）来触发系统调用。
用户模式和内核模式：当软中断指令执行时，CPU从用户模式（低权限模式）切换到内核模式（高权限模式），这样进程就可以安全地执行需要更高权限的操作。
内核处理：在内核模式下，操作系统内核接管，验证系统调用参数，执行相应的内核服务，并将结果准备好返回。
返回用户空间：一旦内核完成了系统调用请求的处理，它将结果放入寄存器，并将控制权返回给用户空间进程，同时将CPU模式切换回用户模式。
进程和内核线程：执行系统调用的实际上还是原始的用户进程，只是它现在以内核模式运行。它在执行系统调用期间，可以认为是一个“内核线程”，但这并不意味着它是一个完全独立的线程实体。一旦系统调用完成，原始的用户进程将继续在用户空间执行。这里的“内核线程”描述并不意味着有一个新的、独立的线程被创建来处理系统调用。
概念澄清：在前面的对话中，使用“内核线程执行系统调用”这样的表述可能会导致理解上的混淆。为了澄清，执行系统调用的是在内核模式下运行的用户进程本身，而不是一个单独的内核线程实体。

希望这次的总结能够更加清晰地阐述了Linux系统调用的全过程，以及进程在用户模式和内核模式之间切换的概念。

Reference

Does each system call create a process?

No, they don't. The operating system uses software interrupt to execute the system call operation within the same process. You can imagine them as a function call but they are executed with kernel privileges.
不，它们不是。操作系统使用软件中断在同一进程内执行系统调用操作。你可以将它们想象为函数调用，但它们是以内核特权执行的。

Based on the difference between select poll epoll

内存问题分析

2024-10-22T03:31:51.000Z

内存问题分析

找到内存问题的来源后，下一步就是相应的优化工作了。在我看来，内存调优最重要的就是，保证应用程序的热点数据放到内存中，并尽量减少换页和交换。

常见的优化思路有这么几种。

最好禁止 Swap。如果必须开启 Swap，降低 swappiness 的值，减少内存回收时 Swap 的使用倾向。
减少内存的动态分配。比如，可以使用内存池、大页（HugePage）等。尽量使用缓存和缓冲区来访问数据。比如，可以使用堆栈明确声明内存空间，来存储需要缓存的数据；或者用 Redis 这类的外部缓存组件，优化数据的访问。
使用 cgroups 等方式限制进程的内存使用情况。这样，可以确保系统内存不会被异常进程耗尽。
通过 /proc/pid/oom_adj ，调整核心应用的 oom_score。这样，可以保证即使内存紧张，核心应用也不会被 OOM 杀死。

参考资料

21 | 套路篇：如何“快准狠”找到系统内存的问题？

[短视频BS上线大批实例出现OOM现象问题](https://ku.baidu-int.com/knowledge/HFVrC7hq1Q/pKzJfZczuc/Gs4uNFcjEC/gzGld6QZrpsx1t)

[Linux查看哪些进程占用的系统 buffer/cache 较高 (hcache，lsof）命令 - 陈咬金 - 博客园](https://www.cnblogs.com/zh94/p/11922714.html)

[技术|在 Linux 上如何清除内存的 Cache、Buffer 和交换空间](https://linux.cn/article-5627-1.html)

[tobert/pcstat: Page Cache stat: get page cache stats for files on Linux](https://github.com/tobert/pcstat)

在 pcstat 基础上做的工具： [silenceshell/hcache: showing top X biggest cache files global](https://github.com/silenceshell/hcache)

进程上下文切换详情

2024-09-20T13:17:13.000Z

进程上下文切换详情

当操作系统进行进程上下文切换时，CPU 会保存当前进程的状态并加载下一个要运行的进程的状态。具体来说，以下信息需要在进程上下文切换时保存和恢复：

1 CPU 寄存器状态

这是上下文切换中最关键的部分，因为寄存器中保存了当前进程的执行状态。具体包括：

程序计数器（Program Counter，PC）：保存当前进程正在执行的指令地址，以便在恢复时从该地址继续执行。
栈指针（Stack Pointer，SP）：指向当前进程的栈顶，保存当前进程的调用栈状态。
通用寄存器：如 eax, ebx, ecx, edx 等 CPU 寄存器，存储进程的临时数据、函数参数和返回值等。
状态寄存器（Flags）：保存当前 CPU 的状态标志位，如是否有进位、溢出或中断等。

这些寄存器状态会保存在进程的**进程控制块（Process Control Block，PCB）**中。

2 内存管理信息

每个进程都有独立的虚拟内存空间，系统需要切换进程的内存映射，确保每个进程只能访问自己的内存。具体包括：

页表（Page Table）：虚拟内存到物理内存的映射表，操作系统在上下文切换时需要更新页表，指向新进程的地址空间。
段寄存器（Segment Registers）：如果使用段式内存管理，也需要切换段寄存器，指向新进程的代码段、数据段和栈段。

3 程序状态字（Process Status Word，PSW）

程序状态字记录了当前进程的运行模式（如用户态或内核态）、中断使能状态、优先级等。在上下文切换时，系统会保存当前进程的状态字，并恢复下一个进程的状态字。

4 内核栈

每个进程在内核态运行时都会有一个专属的内核栈，用来存储系统调用或中断处理过程中的数据。上下文切换时，操作系统会切换到下一个进程的内核栈。

5 硬件上下文

除了 CPU 寄存器，某些硬件设备（如浮点运算单元、SIMD 寄存器等）也可能需要保存状态。对于使用了这些硬件的进程，操作系统在切换时也需要保存这些硬件的状态，以便后续恢复。

6 进程优先级和调度信息

在上下文切换过程中，调度器会根据进程的优先级、剩余时间片等调度策略选择下一个要运行的进程。调度信息存储在 PCB 中。

7 文件描述符表、信号处理状态等（较少切换）

虽然这些信息在一般的上下文切换中不会频繁变动，但操作系统仍然为每个进程维护了与之相关的资源信息，包括：

文件描述符表：记录进程打开的文件及其位置等信息。
信号处理状态：记录进程当前的信号处理函数和挂起信号。

8 进程上下文切换的总结步骤：

保存当前进程状态：
- 将当前进程的寄存器状态（程序计数器、栈指针、通用寄存器等）保存到 PCB 中。
- 保存当前进程的内存管理信息（页表等）。
切换内存空间：
- 更新 CPU 的页表寄存器，使其指向新进程的地址空间。
加载新进程状态：
- 从新进程的 PCB 中恢复其寄存器状态、程序计数器等。
- 切换到新进程的内核栈。
恢复执行：
- 将控制权交给新进程，从其上次暂停的位置继续执行。

通过这些操作，CPU 可以在多个进程之间高效切换，使得操作系统能够实现多任务并发执行。

计算机中断

2025-02-12T12:59:21.000Z

计算机中断

1 什么是中断

中断^[1]（英语：Interrupt），又称插断，在计算机科学中是指处理器接收到来自硬件或软件的信号，提示发生了某个事件，应予以注意，这种情况就称为中断。

2 中断是如何工作的

计算机中的中断机制是CPU和操作系统共同配合的结果。

CPU层面的机制：
中断在硬件层面是由CPU管理的。CPU中内置了处理中断的硬件电路，当接收到中断信号时，它会暂停当前正在执行的指令，将程序计数器（PC）和相关寄存器的内容保存起来，然后跳转到一个预定义的中断处理程序的入口地址。CPU需要具备检测中断信号、保存现场（当前程序的状态）、并执行相应的中断处理程序的能力。
操作系统层面的机制：
中断处理程序（Interrupt Service Routine, ISR）通常是由操作系统编写和管理的。操作系统负责：
- 注册和管理中断处理程序。
- 响应不同的中断类型（如硬件中断、软件中断、时钟中断等）。
- 保存和恢复进程的上下文，确保中断处理完毕后能够恢复正常程序执行。
- 控制任务调度，在多任务环境下，当中断发生时，操作系统会决定是继续运行当前任务，还是切换到其他任务。

因此，中断机制的基础来自于CPU硬件支持，而操作系统负责管理中断的高层逻辑。两者紧密协作，确保中断处理的高效和系统的正常运行。

一般来说，中断的优先级高于普通进程

3 中断的种类

3.1 硬件中断

硬件中断是由计算机外部硬件设备（如键盘、鼠标、硬盘、网络接口等）或内部硬件组件（如定时器、控制器）生成的信号，用来通知CPU发生了某个事件，要求CPU暂停当前任务并立即进行处理。这是一种异步的通信方式，能够确保外部设备与CPU高效互动。

键盘中断：当你按下一个键时，键盘发送一个中断信号给CPU，CPU暂停当前任务，读取按键数据。
鼠标中断：移动鼠标时，鼠标发送中断信号给CPU，CPU响应并处理移动事件。
定时器中断：系统定时器会周期性地向CPU发送中断信号，用于管理任务调度和系统时钟。

3.2 软件中断

软件中断是由程序通过特定的指令主动触发的中断，它通常用于实现系统调用或处理特定的程序异常。与硬件中断不同，软件中断是由软件发出的，而不是由外部设备或硬件组件引发的。

系统调用（System Call）：软件中断最常见的用途是实现系统调用。当应用程序需要操作系统提供的服务（如文件读写、内存分配、网络通信等）时，它会触发一个软件中断。操作系统会捕获该中断并执行相应的服务，随后返回给应用程序。这种机制让用户程序能够安全、受控地访问操作系统的资源。
异常处理（Exception Handling）：当程序运行时发生某些异常（如除零错误、非法内存访问），CPU会自动触发软件中断，进入异常处理程序进行处理。
调试（Debugging）：软件中断也可以用于调试。例如，调试器通过在代码中插入断点，利用软件中断暂停程序的执行，检查当前状态，从而帮助开发者进行故障排查。

3.3 Linux 中断处理

Linux 将中断处理过程分成了两个阶段，也就是上半部和下半部：

上半部用来快速处理中断，它在中断禁止模式下运行，主要处理跟硬件紧密相关的或时间敏感的工作。 对应硬中断，快速执行
下半部用来延迟处理上半部未完成的工作，通常以内核线程的方式运行。 对应软中断，延迟执行

3.3.1 查看中断

/proc/softirqs 提供了软中断的运行情况；

                    CPU0       CPU1
          HI:         32          4
       TIMER:     217168     160788
      NET_TX:      58113          1
      NET_RX:      73923         35
       BLOCK:      12544         10
    IRQ_POLL:          0          0
     TASKLET:       2802         54
       SCHED:     283839     258237
     HRTIMER:          0          0
         RCU:     116166     128092

具体字段解释如下：

HI：高优先级软中断，用于处理非常紧急的软中断任务，极少使用。
TIMER：定时器软中断，系统定时器触发的中断。用于定期任务（如进程调度、系统计时）的处理。
NET_TX：网络传输（发送）软中断，处理网络数据包的发送。
NET_RX：网络接收软中断，处理网络数据包的接收。
BLOCK：块设备 I/O 的软中断，处理硬盘等块设备的 I/O 操作。
BLOCK_IOPOLL：块设备 I/O 轮询软中断，处理块设备的 I/O 轮询操作，通常在高性能场景中用到。
TASKLET：任务队列（Tasklets），用于延迟执行一些非紧急任务。
SCHED：调度软中断，触发进程调度相关的任务。
HRTIMER：高精度定时器软中断，用于高精度计时任务。
RCU：RCU（Read-Copy Update）软中断，RCU 是 Linux 内核中的一种同步机制，通常用于读写锁的管理和延迟删除任务。

软中断实际上是以内核线程的方式运行的，每个 CPU 都对应一个软中断内核线程，这个软中断内核线程就叫做 ksoftirqd/CPU 编号。

wudanyang@dy-turbo-vm:~$ ps aux | grep softirq
root          16  0.0  0.0      0     0 ?        S    02:08   0:00 [ksoftirqd/0]
root          24  0.0  0.0      0     0 ?        S    02:08   0:00 [ksoftirqd/1]

/proc/interrupts 提供了硬中断的运行情况。硬件中断输出示例

4 参考

中断 - 维基百科，自由的百科全书: https://zh.wikipedia.org/wiki/中斷 ↩︎

线程上下文切换详情

2024-09-20T13:17:21.000Z

线程上下文切换详情

线程上下文切换与进程上下文切换类似，但由于线程是轻量级的进程，线程上下文切换主要涉及保存和恢复线程的执行状态，而无需切换进程的虚拟内存空间和其他与进程相关的资源。以下是线程上下文切换时需要保存和恢复的主要内容：

1 CPU 寄存器状态

与进程上下文切换一样，线程上下文切换中，最重要的是保存和恢复 CPU 的寄存器状态，具体包括：

程序计数器（Program Counter，PC）：保存当前线程正在执行的指令地址，以便恢复时从该地址继续执行。
栈指针（Stack Pointer，SP）：保存当前线程的栈顶指针，指向当前调用栈的位置。
通用寄存器：保存线程当前的寄存器状态，包括 CPU 寄存器中的数据、临时变量、函数参数等内容。
状态寄存器（Flags）：保存 CPU 的状态标志，如是否有中断、溢出或进位等。

这些寄存器状态会保存在 线程控制块（Thread Control Block，TCB） 中。

2 线程栈

每个线程都有独立的栈，用于存储函数调用的局部变量、返回地址等。在上下文切换时，操作系统会切换到新线程的栈指针，指向该线程的栈顶。

3 程序状态字（Program Status Word，PSW）

和进程一样，线程上下文切换时也需要保存程序状态字，记录线程的运行状态（如用户态或内核态）、中断状态等信息。

4 线程本地存储（Thread-Local Storage，TLS）

线程可能会使用线程本地存储来保存

系统调用时上下文调度

2024-09-20T13:17:37.000Z

系统调用时上下文调度

CPU 的特权等级：
linux 中只使用了 `Ring 0` 和 `Ring3`

在系统调用时可能会发生上下文切换，但这取决于具体情况。系统调用涉及从用户态（User Mode）切换到内核态（Kernel Mode），这是一个模式切换，不一定总是伴随完整的进程上下文切换。让我们更详细地看一下：

1) 用户态和内核态切换（模式切换）

当一个进程执行系统调用时，CPU 会从用户态切换到内核态，以便操作系统内核执行需要访问硬件资源或特权操作的指令（如文件读写、内存管理等）。这叫做模式切换。

模式切换 ≠ 上下文切换：
模式切换是 CPU 从执行用户代码切换到执行内核代码，并不涉及进程的完整上下文（如寄存器、页表、内存等）切换，因此它比完整的上下文切换开销要小。

2) 系统调用时的上下文切换

在以下几种情况下，系统调用会导致真正的进程上下文切换：

进程阻塞：
如果系统调用需要等待某些事件（如 I/O 操作、网络请求、锁等），当前进程会被挂起，进入等待状态。此时，操作系统会进行进程上下文切换，将 CPU 资源分配给其他进程执行，直到当前进程的请求完成，再切换回该进程继续执行。

例如：
- 调用 read() 时，如果数据还没有准备好，进程会进入阻塞状态，等待 I/O 完成，导致上下文切换。
时间片用完：
如果系统调用时间过长，进程在内核态执行时，可能会因为时间片耗尽被操作系统调度器切换出去，调度其他进程。这样会产生上下文切换。
高优先级进程的出现：
当进程在系统调用中运行时，如果有更高优先级的进程进入可运行队列，操作系统可能强制进行上下文切换，将 CPU 资源让给更高优先级的进程。

3) 不会导致上下文切换的系统调用

某些系统调用不会导致上下文切换，比如短时间内能立即完成的调用。典型的例子包括：

getpid()：返回进程的 PID，几乎是瞬时操作。
gettimeofday()：获取当前时间，操作非常快。

这些系统调用通常只涉及模式切换（从用户态切换到内核态再返回），不会导致进程切换。

4) 总结

系统调用时不一定会发生上下文切换：

如果系统调用涉及 I/O 操作或进程需要等待某些资源时，系统会发生进程上下文切换。
仅涉及用户态和内核态的模式切换时，不涉及完整的上下文切换，开销较小。

5) 参考

操作系统之哲学原理第2版 - 3.3 内核态和用户态 - 邹恒明 - 微信读书: https://weread.qq.com/web/reader/9eb326d05933d79ebf22eb3k6ea321b021d6ea9ab1ba605
现代操作系统（原书第4版） (豆瓣): https://book.douban.com/subject/27096665/

硬件中断输出示例

2024-09-20T13:17:58.000Z

硬件中断输出示例

cat /proc/interrupts
           CPU0       CPU1
 10:     690796     792946     GICv3  27 Level     arch_timer
 12:          0          0       MSI 344064 Edge      PCIe PME, pciehp
 13:          0          0       MSI 346112 Edge      PCIe PME, pciehp
 14:          0          0       MSI 348160 Edge      PCIe PME, pciehp
 15:          0          0       MSI 350208 Edge      PCIe PME, pciehp
 16:          0          0       MSI 352256 Edge      PCIe PME, pciehp
 17:          0          0       MSI 354304 Edge      PCIe PME, pciehp
 18:          0          0       MSI 356352 Edge      PCIe PME, pciehp
 19:          0          0       MSI 358400 Edge      PCIe PME, pciehp
 20:          0          0       MSI 360448 Edge      PCIe PME, pciehp
 21:          0          0       MSI 362496 Edge      PCIe PME, pciehp
 22:          0          0       MSI 364544 Edge      PCIe PME, pciehp
 23:          0          0       MSI 366592 Edge      PCIe PME, pciehp
 24:          0          0       MSI 368640 Edge      PCIe PME, pciehp
 25:          0          0       MSI 370688 Edge      PCIe PME, pciehp
 26:          0          0       MSI 372736 Edge      PCIe PME, pciehp
 27:          0          0       MSI 374784 Edge      PCIe PME, pciehp
 28:          0          0       MSI 376832 Edge      PCIe PME, pciehp
 29:          0          0       MSI 378880 Edge      PCIe PME, pciehp
 30:          0          0       MSI 380928 Edge      PCIe PME, pciehp
 31:          0          0       MSI 382976 Edge      PCIe PME, pciehp
 32:          0          0       MSI 385024 Edge      PCIe PME, pciehp
 33:          0          0       MSI 387072 Edge      PCIe PME, pciehp
 34:          0          0       MSI 389120 Edge      PCIe PME, pciehp
 35:          0          0       MSI 391168 Edge      PCIe PME, pciehp
 36:          0          0       MSI 393216 Edge      PCIe PME, pciehp
 37:          0          0       MSI 395264 Edge      PCIe PME, pciehp
 38:          0          0       MSI 397312 Edge      PCIe PME, pciehp
 39:          0          0       MSI 399360 Edge      PCIe PME, pciehp
 40:          0          0       MSI 401408 Edge      PCIe PME, pciehp
 41:          0          0       MSI 403456 Edge      PCIe PME, pciehp
 42:          0          0       MSI 405504 Edge      PCIe PME, pciehp
 43:          0          0       MSI 407552 Edge      PCIe PME, pciehp
 44:          0          0     GICv3  32 Level     ehci_hcd:usb1
 46:          0          0     GICv3  23 Level     arm-pmu
 48:      81341          0       MSI 1048576 Edge      ens160-rx-0
 49:      61793          0       MSI 1048577 Edge      ens160-tx-0
 50:          7          0       MSI 1048578 Edge      ens160
 51:      13113          0       MSI 573440 Edge      ahci[0000:01:03.0]
 52:        116          0       MSI 9437184 Edge      nvme0q0
 53:      14025          0       MSI 9437185 Edge      nvme0q1
 54:          0      15724       MSI 9437186 Edge      nvme0q2
 56:        232          0       MSI 5242880 Edge      xhci_hcd
 59:       3364          0       MSI 14336 Edge      vmw_vmci
 60:          0          0       MSI 14337 Edge      vmw_vmci
 61:       6732          0       MSI 14338 Edge      vmw_vmci
 62:          0          0       MSI 245760 Edge      vmwgfx
 63:          0          0       MSI 245761 Edge      vmwgfx
 64:          0          0       MSI 245762 Edge      vmwgfx
 65:          0          0       MSI 245763 Edge      vmwgfx
 66:          0          0       MSI 245764 Edge      vmwgfx
 67:          0          0       MSI 245765 Edge      vmwgfx
 68:        315          0       MSI 540672 Edge      snd_hda_intel:card0
IPI0:      9633      18455       Rescheduling interrupts
IPI1:    133913     157019       Function call interrupts
IPI2:         0          0       CPU stop interrupts
IPI3:         0          0       CPU stop (for crash dump) interrupts
IPI4:         0          0       Timer broadcast interrupts
IPI5:       198       2356       IRQ work interrupts

/proc/interrupts 文件记录了系统中各个中断源的触发情况。根据你提供的内容，以下是该文件中各个字段的解释：

1) 字段解析

中断号（IRQ Number）：
- 第一列表示每个中断的唯一标识符。中断号以数字表示，例如 10, 12, 13 等。
CPU 列：
- 接下来的列表示各个 CPU 核心上该中断被触发的次数。在你的输出中，有 CPU0 和 CPU1，后面分别是它们上面的中断触发计数。
中断类型：
- 中断的类型（如 GICv3 和 MSI），表示该中断的来源和处理方式。
  - GICv3：代表使用通用中断控制器（Generic Interrupt Controller）版本 3。
  - MSI（Message Signaled Interrupts）：一种通过消息而不是物理线路发送中断的机制。
中断编号/级别：
- 某些中断行后面有数字（如 27, 32），这些数字通常表示该中断的向量号或中断级别。
- Level 表示该中断为电平触发（持续有效）中断。
- Edge 表示为边缘触发中断（只在状态变化时有效）。
设备名称：
- 最后一列通常是中断源设备的描述，表示触发该中断的硬件设备。例如：
  - arch_timer：表示体系结构定时器。
  - pciehp：表示 PCI Express 热插拔控制器。
  - ens160-rx-0 和 ens160-tx-0：表示网络接口卡的接收和发送中断。

2) 示例行解释

10: 690796 792946 GICv3 27 Level arch_timer：
- 中断号为 10。
- CPU0 上该中断触发了 690796 次，CPU1 上触发了 792946 次。
- 中断类型为 GICv3，向量号为 27，为电平触发。
- 设备为 arch_timer，表示这是体系结构定时器的中断。

3) IPI（Inter-Processor Interrupts）

IPI 代表处理器间中断（Inter-Processor Interrupts），用于在多核处理器系统中进行通信或协调。例子包括：
- IPI0 表示重新调度中断，触发次数分别为 9633 和 18455。

模拟软中断特别多的情况

2024-09-26T05:20:33.000Z

模拟软中断特别多的情况

1 客户端请求

sudo hping -S -p 8080 -i u100 192.168.135.130

# 如果上面的命令没有显著提高软中断的占用率，可以将 -i 间隔取消，加上 --flood 忽略回复消息
sudo hping -S -p 8080 --flood 192.168.135.130

2 服务端情况

watch -d cat /proc/softirqs

观察服务端软中断情况

模拟突发进程特别多的情况

2024-09-20T13:18:14.000Z

模拟突发进程特别多的情况

突发进程特别多的情况构建：

# 如果无写入权限，iowait 都不会升高，否则 wa 使用率值升高
# top 中只能看到 us 使用率值升高非常多
# 无法观测到具体什么进程CPU使用率较高
# 因为全是突发进程
while true;do stress -t 1 -d 1 2>&1 ;done

快速分析系统CPU瓶颈的命令工具

2025-01-26T13:24:20.000Z

快速分析系统CPU瓶颈的命令工具

1 参考

11 | 套路篇：如何迅速分析出系统CPU的瓶颈在哪里？-Linux 性能优化实战-极客时间: https://time.geekbang.org/column/article/72685

中断上下文切换详情

2024-10-12T15:10:44.000Z

中断上下文切换详情

中断上下文切换是指当硬件或软件中断^[1]发生时，操作系统需要暂停当前正在执行的任务，去处理中断事件的过程。与进程或线程上下文切换不同，中断上下文切换主要在用户态或内核态中断当前执行的任务，将 CPU 切换到中断处理程序执行。它是一种临时的、优先级很高的切换，不涉及切换到其他进程或线程的执行。

1 中断上下文切换的过程

保存当前 CPU 寄存器状态:
- 当中断发生时，CPU 会首先保存当前任务的部分寄存器状态，例如程序计数器（PC）、栈指针（SP）、标志寄存器等，以确保在中断处理完成后能够恢复到中断前的状态。这部分信息通常会被保存到内核栈中。
切换到内核栈:
- 中断处理是在内核态执行的，因此 CPU 会切换到当前任务的内核栈。每个进程或线程在内核中都有独立的内核栈。切换到内核栈后，中断处理程序可以安全地执行需要的内核操作。
执行中断处理程序:
- CPU 切换到中断处理程序执行。中断处理程序可以是硬件中断处理（如键盘输入、中断时钟、网络数据到达等）或软件中断处理（如系统调用）。在这个阶段，处理程序可以执行与中断相关的操作，例如读取设备数据、更新状态等。
恢复 CPU 状态:
- 中断处理完成后，操作系统会恢复之前保存的 CPU 寄存器状态，包括程序计数器、通用寄存器、栈指针等，确保中断发生前的任务能够继续运行。
返回中断前的执行:
- 恢复到中断发生前的执行状态，继续执行中断前的任务。

2 中断上下文切换与进程/线程上下文切换的区别

中断上下文切换只涉及当前执行任务的部分寄存器状态的保存与恢复，不涉及切换到其他进程或线程，因此通常比进程/线程上下文切换更轻量。
中断上下文切换发生在内核态，其目的是快速处理硬件或软件中断，使系统能够及时响应外部事件。
中断上下文不涉及虚拟内存空间的切换，因为中断处理程序运行在内核态，并且不关心哪个用户进程引发了中断。

3 中断上下文中的注意事项

在中断上下文中，不允许执行阻塞操作（如等待 I/O、睡眠等），因为中断处理程序需要尽快完成，避免影响系统的实时性和性能。
中断处理程序通常只完成必要的工作，其余的处理可能会被推迟到软中断或内核线程中，以减少中断处理的开销。

4 小结

中断上下文切换是一个高优先级、临时的切换，用于处理外部事件（如硬件中断）。它会保存当前任务的部分 CPU 寄存器状态，然后切换到中断处理程序。处理完中断后，系统恢复中断前的执行状态，继续原来的任务。由于中断上下文切换并不涉及切换到其他进程或线程，它的开销相对较小。

5 参考

计算机中断 ↩︎

sar命令输出

2024-09-20T13:16:48.000Z

sar命令输出

Linux 6.8.0-44-generic (dy-turbo-vm) 	09/19/2024 	_aarch64_	(8 CPU)

10:54:49 AM     CPU     %user     %nice   %system   %iowait    %steal     %idle
10:54:50 AM     all      0.12      0.00      0.12      0.00      0.00     99.75
10:54:51 AM     all      0.00      0.00      0.25      0.00      0.00     99.75
10:54:52 AM     all      0.00      0.00      0.12      0.00      0.00     99.88
10:54:53 AM     all      0.00      0.00      0.12      0.00      0.00     99.88
10:54:54 AM     all      0.00      0.00      0.00      0.00      0.00    100.00
Average:        all      0.03      0.00      0.13      0.00      0.00     99.85

mpstat命令输出

2024-09-20T13:16:37.000Z

mpstat命令输出

Linux 6.8.0-44-generic (dy-turbo-vm) 	09/19/2024 	_aarch64_	(8 CPU)

10:52:27 AM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest  %gnice   %idle
10:52:27 AM  all    0.02    0.00    0.05    0.01    0.00    0.00    0.00    0.00    0.00   99.91

linux-perf

2024-10-21T13:32:00.000Z

linux-perf

linux 下的性能分析工具

1 perf top

显示占用 cpu 时钟最多的函数或指令，可以用来查找热点函数

表头四个字段：

Overhead 百分比
Shared 该函数或指令所在的动态共享对象（dynamic Shared Object）
Object 动态对象类型，[.] 代表用户空间可执行程序、动态链接库，[k] 代表内核空间
Symbol 符号名，函数名。

2 常用命令

记录当前状态

perf record -a -g -- sleep 30

产出一份图标报告

perf report -g graph,0

3 参考

https://time.geekbang.org/column/article/70476

linux-execsnoop

2024-09-20T13:18:39.000Z

linux-execsnoop

[!NOTE]
execsnoop - Trace new processes via exec() syscalls. Uses Linux eBPF/bcc.

适合查看系统中突发进程比较多的情况

wudanyang@dy-turbo-vm:~$ sudo execsnoop
[sudo] password for wudanyang:
PCOMM            PID    PPID   RET ARGS
stress           17095  1351     0 /usr/bin/stress
stress           17097  1351     0 /usr/bin/stress
stress           17099  1351     0 /usr/bin/stress -t 1 -d
stress           17101  1351     0 /usr/bin/stress
stress           17103  1351     0
stress           17105  1351     0 /usr/bin/stress -t
stress           17107  1351     0 /usr/bin/stress -t
stress           17109  1351     0 /usr/bin/stress -t
stress           17111  1351     0 /usr/bin/stress -t 1 -d
stress           17113  1351     0 /usr/bin/stress
stress           17115  1351     0
stress           17117  1351     0 /usr/bin/stress -t 1
stress           17119  1351     0 /usr/bin/stress -t 1 -d 1
stress           17121  1351     0 /usr/bin/stress
stress           17123  1351     0 /usr/bin/stress -t 1 -d
stress           17125  1351     0 /usr/bin/stress -t
stress           17127  1351     0
stress           17129  1351     0 /usr/bin/stress -t 1
stress           17131  1351     0 /usr/bin/stress -t 1 -d 1
stress           17133  1351     0 /usr/bin/stress
stress           17135  1351     0 /usr/bin/stress
stress           17137  1351     0 /usr/bin/stress

CPU 平均负载

2024-09-20T13:16:05.000Z

CPU 平均负载

1 什么是平均负载?

System load averages is the average number of processes that are
either in a runnable or uninterruptable state. A process in a
runnable state is either using the CPU or waiting to use the CPU.
A process in uninterruptable state is waiting for some I/O
access, eg waiting for disk. The averages are taken over the
three time intervals. Load averages are not normalized for the
number of CPUs in a system, so a load average of 1 means a single
CPU system is loaded all the time while on a 4 CPU system it
means it was idle 75% of the time.
https://man7.org/linux/man-pages/man1/uptime.1.html

简单来说，平均负载是指单位时间内，系统处于可运行状态和不可中断状态的平均进程数，也就是平均活跃进程数

2 如何查看linux平均负载

top
uptime
w
cat /proc/loadavg

# CPU 平均负载
load average: 0.62, 0.72, 0.76

3 平均负载的高低判断标准

最理想的，就是每个 CPU 上都刚好运行着一个进程

所以说平均负载高不高，需要看你的 CPU 到底有几个

CPU个数查询： cat /proc/cpuinfo

4 参考

CPU比喻成一辆地铁，正在使用CPU的进程就是在地铁上的人；等待CPU的进程就是在下一站等地铁来的人；等待I/O的进程就是在下一站要上车和下车的人，虽然现在对CPU没影响，可未来会影响，所以也要考虑到平均负载上。

02 | 基础篇：到底应该怎么理解“平均负载”？-Linux 性能优化实战-极客时间: https://time.geekbang.org/column/article/69618

CPU 使用率

2024-09-25T10:51:53.000Z

CPU 使用率

CPU 使用率（CPU Utilization）是指在一段时间内，处理器用于执行任务的时间占总时间的比例。它反映了 CPU 的繁忙程度，通常以百分比表示。

1 基本概念：

用户态（User Mode）CPU 使用率：
- CPU 在用户态（用户空间）运行用户应用程序的时间。
- 例如，当你运行一个程序（如文本编辑器、浏览器等）时，CPU 会在用户态处理这些任务。
系统态（System Mode）CPU 使用率：
- CPU 在内核态（内核空间）执行系统调用、驱动程序等操作的时间。
- 例如，文件读写操作、网络请求处理等属于内核态。
空闲态（Idle）CPU 使用率：
- CPU 处于空闲状态，没有任务要执行的时间。
- 这个数值越大，表示 CPU 越空闲。
等待 I/O（I/O Wait）：
- CPU 等待输入输出（如硬盘、网络）的时间。这种情况下，CPU 可能是空闲的，但由于等待 I/O 完成而无法进行其他任务。
中断时间（IRQ & SoftIRQ）：
- CPU 处理硬件中断（IRQ）和软件中断（SoftIRQ）的时间。

高 CPU 使用率的含义：

高 CPU 使用率意味着系统在执行大量的计算任务，可能是正常现象（例如运行密集型计算任务），也可能是系统负载过高。
低 CPU 使用率则表明系统相对空闲，CPU 大部分时间处于空闲状态。

如何查看 CPU 使用率：

使用 top 或 htop 等工具可以实时监控 CPU 的使用情况。
使用 mpstat 可以更详细地查看每个 CPU 核心的使用率。

2 如何查看CPU时间

cat /proc/stat 查看开机以来的系统CPU时间 /proc/stat

The amount of time, measured in units of USER_HZ
(1/100ths of a second on most architectures, use
sysconf(SC_CLK_TCK) to obtain the right value),
that the system ("cpu" line) or the specific CPU
("cpu_N" line) spent in various states

单位为时间数量，一般是 1/100 秒，具体值根据 USER_HZ 确定。

3 CPU 使用率的计算方法

总CPU使用率（开机以来）

CPU 使用率 = 1 - \frac{空闲时间}{总 CPU 时间}

一段时间内的平均CPU使用率

平均 CPU 使用率 = 1 - \frac{{空闲时间}_{new} - {空闲时间}_{old}}{{总 CPU 时间}_{new} - {总 CPU 时间}_{old}}

4 获得CPU使用率的几种方法

top命令
按1可以看每个CPU单独的数据 linux-top
htop 命令
优势：可以响应鼠标点击事件，滚动查看，查看进程树
vmstat 1 每秒输出一次 vmstat reports information about processes, memory, paging, block IO, traps, disks and cpu activity
mpstat 或者 mpstat -u 1 10 获取一段时间内的CPU使用率

mpstat命令输出

Linux 6.8.0-44-generic (dy-turbo-vm) 	09/19/2024 	_aarch64_	(8 CPU)

10:52:27 AM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest  %gnice   %idle
10:52:27 AM  all    0.02    0.00    0.05    0.01    0.00    0.00    0.00    0.00    0.00   99.91

sar 1 5 此命令每秒采集一次数据，连续采集 5 次。

sar命令输出

Linux 6.8.0-44-generic (dy-turbo-vm) 	09/19/2024 	_aarch64_	(8 CPU)

10:54:49 AM     CPU     %user     %nice   %system   %iowait    %steal     %idle
10:54:50 AM     all      0.12      0.00      0.12      0.00      0.00     99.75
10:54:51 AM     all      0.00      0.00      0.25      0.00      0.00     99.75
10:54:52 AM     all      0.00      0.00      0.12      0.00      0.00     99.88
10:54:53 AM     all      0.00      0.00      0.12      0.00      0.00     99.88
10:54:54 AM     all      0.00      0.00      0.00      0.00      0.00    100.00
Average:        all      0.03      0.00      0.13      0.00      0.00     99.85

ps： ps -eo pid,ppid,cmd,%mem,%cpu --sort=-%cpu | head
cat /proc/stat 通过读取CPU时间，自行计算CPU使用率
查看指定进程的CPU使用情况： linux-pidstat

CPU 上下文切换

2024-09-20T13:17:31.000Z

CPU 上下文切换

上下文切换（Context Switch） 是操作系统中，当 CPU 在多个进程或线程之间切换执行时发生的操作。它是多任务系统实现并发执行的核心机制之一。

上下文 是指 CPU 运行一个进程或线程时的状态，包括以下内容：

寄存器：存储当前进程的运行状态（如指令指针、程序计数器、栈指针等）。
内存映射：包括进程的地址空间、虚拟内存页表等。
CPU 状态：进程当前的运行模式（用户态或内核态）。
进程控制块（PCB）：保存进程的上下文信息。

上下文切换的场景：

进程上下文切换：当操作系统调度器决定暂停一个进程并切换到另一个进程时，需要保存当前进程的上下文，并恢复目标进程的上下文。
线程上下文切换：线程属于同一个进程，但每个线程有自己独立的执行上下文（如寄存器状态、栈指针），切换时也会涉及上下文保存与恢复。
中断上下文处理：当硬件或软件中断发生时，CPU 会暂停当前进程处理中断，完成后恢复原进程的上下文。

上下文切换的步骤：

保存上下文：将当前进程/线程的寄存器、栈指针等信息保存到进程控制块（PCB）中。
加载新上下文：从目标进程的 PCB 中加载该进程的寄存器状态、栈指针等信息。
切换内存映射：切换虚拟内存的页表，以确保 CPU 访问的是新进程的内存空间。

上下文切换的开销：上下文切换涉及保存和恢复进程状态、切换内存映射等操作，这需要 CPU 额外的时间。频繁的上下文切换会导致性能下降，因为每次切换时，CPU 需要停下来保存/加载状态，而不是执行有用的工作。因此，系统设计通常会尽量减少不必要的上下文切换。

1 进程上下文切换

进程上下文切换详情

调度的时机：

进程进行系统调用时，可能会发生系统调用时上下文调度
时间片耗尽
进程阻塞
优先级调度
中断

2 线程上下文切换

线程上下文切换详情

线程属于不同的进程
- 同进程上下文调度
线程间属于同一进程
- 共享相同的虚拟内存、全局变量等资源
- 切换栈、寄存器等线程私有数据

3 中断上下文切换

中断上下文切换详情

硬件&软件中断时
优先级比进程、线程优先级高
中断只需要内核态的状态，CPU 寄存器，内核堆栈，硬件中断参数等

4 CPU 上下文切换的问题

会将大量的CPU时间浪费保存和恢复程序状态上面，缩短真正的运行时间，导致系统整体性能大幅下降

5 查看CPU上下文切换

# CPU 上下文切换
vmstat 5

输出内容：

procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st gu
 1  0      0 3230412  44980 526092    0    0     5     8   49    0  0  0 99  0  0  0

内容含义查看：

vmstat(8) - Linux 手册页 --- vmstat(8) - Linux manual page: https://man7.org/linux/man-pages/man8/vmstat.8.html

重要字段：

cs（context switch）是每秒上下文切换的次数。
in（interrupt）则是每秒中断的次数。
r（Running or Runnable）是就绪队列的长度，也就是正在运行和等待 CPU 的进程数。
b（Blocked）则是处于不可中断睡眠状态的进程数。

pidstat -w 5

内容输出：

Linux 6.8.0-44-generic (dy-turbo-vm) 	09/14/2024 	_aarch64_	(2 CPU)

11:54:39 AM   UID       PID   cswch/s nvcswch/s  Command
11:54:44 AM     0        16      0.20      0.00  ksoftirqd/0
11:54:44 AM     0        17      0.40      0.00  rcu_preempt
11:54:44 AM     0        18      0.40      0.00  migration/0
11:54:44 AM     0        23      0.40      0.00  migration/1
11:54:44 AM     0        34      1.98      0.00  kcompactd0
11:54:44 AM     0        48      0.20      0.00  kworker/0:1H-kblockd
11:54:44 AM     0       470      1.39      0.00  multipathd
11:54:44 AM     0       712     10.69      0.00  vmtoolsd
11:54:44 AM     0      5892      3.17      0.00  kworker/0:1-events
11:54:44 AM     0      6488      1.98      0.00  kworker/u4:0-events_power_efficient
11:54:44 AM     0      6501      6.34      0.00  kworker/1:3-events
11:54:44 AM     0      6677      4.75      0.00  kworker/u4:2-events_unbound
11:54:44 AM  1000      6969     18.22      0.00  sshd
11:54:44 AM  1000      7085      0.20      0.00  pidstat

pidstat(1) - Linux manual page: https://man7.org/linux/man-pages/man1/pidstat.1.html

重要字段：

cswch/s ：每秒自愿上下文切换次数（自愿：I/O等待，申请内存等需要等待资源ready的操作）
nvcswch/s ：每秒非自愿上下文切换次数（非资源：时间片达到等）

202409121624 Linux 性能分析优化-CPU

2025-01-24T09:11:52.000Z

202409121624 Linux 性能分析优化-CPU

1 Linux 系统概览

1.1 CPU 概览

冯诺依曼结构：

CPU大概内部结构：

1.2 Linux 内核概览

2 基本概念

3 CPU 使用率过高如何排查

通过top ps pidstat 找到 CPU 使用率过高的进程 CPU 使用率#4) 获得CPU使用率的几种方法
- 找到占用 CPU 最多的函数
  - 使用GDB或者其他Debug工具进行调试
  - 使用 linux-perf
针对突发进程如何处理呢？
- 模拟突发进程特别多的情况
  - 开启终端，演示突发进程的现象
- top 直接查看，无法发现具体哪个进程的问题
- 几种观测突发进程的方法
  - 使用 top -b -c 输出到文件，然后分析文件内容
  - 使用 linux-perf 记录一段时间的内容，然后通过 report 查看 cpu 使用率
    - 观察到了CPU使用率比较高的command之后，可以使用 pstree 找到对应的父进程
  - 使用 linux-execsnoop 观测 exec 生成的新进程
软中断CPU使用率升高如何排查
- 模拟软中断特别多的情况
- top 看 si st 使用率
  - cat /proc/softirqs 查看软硬中断的情况，观察是什么类型的中断上涨比较多计算机中断#3.3.1) 查看中断
- 一般情况下，都是网络问题，可以使用 sar -n DEV 1 观察输入输出包的速度
快速分析系统CPU瓶颈的命令工具

4 性能优化的思路

参考之前的分享： QB性能优化指南

5 参考

Linux 性能优化实战: https://time.geekbang.org/column/intro/100020901?tab=catalog
Linux man pages online: https://man7.org/linux/man-pages/index.html
第八章 CPU的结构和功能_排队器是在cpu中的吗-CSDN博客: https://blog.csdn.net/qq_45091353/article/details/127096768

当前状态和下一状态的随想.excalidraw

2024-10-18T05:01:57.000Z

如何追查线上问题

2024-10-12T15:29:04.000Z

如何追查线上问题

止损优先

不能先追查问题根源，首先应该止损，不让问题进一步扩大，代码回滚、服务降级等都可以起到止损的效果。
对于止损有一个比较好的实践，新业务或者重构业务上线时，可以加一个 配置开关 控制是否启用逻辑，在发现有损时，可以及时关掉业务逻辑，比重新上线要快特别多

及时通告

在问题发生之后，要及时对处理问题的过程进行通告。特别是应对线上有损的问题时，更应该及时通告。在内部群中，简单描述一下问题与可能的原因，处理的进度。而在外部群里，可以只说一下处理的进度。如果有必要，可以将问题上诉到领导，如果还解决不了问题，可以逐级继续上诉。

追查问题的方法

逻辑方法:

先收集现象：业务报错、线上报错日志等
对紧急的问题来说，需要对线上业务、服务器等非常熟悉，才能迅速收集到有用的报错信息。
针对现象假设原因：
1. 常见问题依据追查手册
2. 其他问题保持思路开放，大胆假设
是否有损的判断：
根据现象假设出可能的原因，判断是否是有损的，如果是有损的问题，参考 止损优先
质疑所有数据：
各个数据、监控系统等的有效性也需要质疑，不能完全相信，需要小心求证

知识准备

对线上各种日志的熟悉，从日志中能看到具体的问题，比如 nginx 日志 php 日志等
对线上的各种配置更要做到心中有数
对细节的追查，每次都更细一些，这样才能获得更多的信息
计算机基本功，有时问题追查不下去，不是没有线索，而是追查到了一个未知的领域，没有相关的知识，无法追查

总结经验

成熟的方法落地成工具
对问题的追查形成文档

问题解决之后

如果问题解决之后，我们就不再跟进了，那么我们就沦为了解决问题的工具，问题也随之越来越多，解决不完。
那么，我们可以通过思考以下几点来提升自己

线上是否恢复了正常？（最基本的）
问题的原因是什么？（落到追查文档）
通过什么手段恢复的？（解决方案）
怎么可以避免下次再次出现问题？（防患未然）
除了此次出现的问题，会不会有其他的问题出现（举一反三）
出现此类问题是否是架构问题造成的？（根本原因）

如何做监控

2024-10-12T15:29:18.000Z

如何做监控

监控：

什么是监控？
1. 对线上质量的一个实时检查
重要性
1. 发现线上问题（早于用户）
2. 快速止损、定位
3. 及时发现隐藏的问题，指导策略优化
如何做好监控？
1. 监控的流程及内容
  1. 监控需求提出
  2. 监控需求开发
  3. 监控需求测试
  4. 监控指标确认
  5. 监控报警添加
2. 确认监控内容
  1. 新功能添加监控
  2. 补充监控
  3. 围绕
    1. 系统正确性
    2. 系统异常
    3. 异常定位
    4. 隐藏问题指导策略
3. 监控数据获取
  1. 打点数据
  2. 日志数据
  3. 数据库数据
  4. redis 数据
4. 监控报警添加
  1. 监控可视化
  2. 确定触发报警策略
  3. 确定报警频率
  4. 确定报警接收人
  5. 配置监控
5. 监控处理
  1. 收到报警
  2. 问题跟进
  3. 问题周知
  4. 问题处理
  5. 定损
  6. 复盘 & casestudy
6. 监控报警优化
  1. 漏报
    1. 不同报警类型
    2. 突升突降代替固定阈值
  2. 无效报警太多（准确率）
    1. 准确性提升
      1. 放大时间窗口，屏蔽预期内的单点抖动
      2. 工作日、节假日不同阈值
    2. 推送方式优化
      1. 连续失败
      2. 通知间隔
      3. 通知依赖
      4. 不同方式报警（短信、电话）
  3. 报警处理不及时
    1. 自愈脚本等
7. 问题定位
  1. 流量分析
    1. 流量细分
      1. 行业
      2. 地域
      3. 机房
  2. 系统分析
    1. 线上出现报错、fatal、pvlost
    2. 例行上线功能影响
    3. 数据变更

监控发现有问题之后可以了解一下如何追查线上问题

202404251145 破解软件的成本如果比较高就不要去花时间破解了

2025-02-18T13:43:13.000Z

202404251145 破解软件的成本如果比较高就不要去花时间破解了

你的时间值得去做其他的事情，即使是睡觉 202404251146 破解mindnode

202404171707 当你学不下去的时候

2025-02-14T08:40:58.000Z

202404171707 当你学不下去的时候

当你学不下去的时候，闭上眼，想象高考刚刚出分，没考上，你崩溃大哭，问能不能再给我一次机会。睁开眼，这就是你新的机会。

202404082353 取乎其上得乎其中

2025-02-13T04:55:34.000Z

202404082353 取乎其上得乎其中

将目标定的高一些，最后的结果可能是中间的效果。目标是通过卡片【笔记】【写作】法创作几十本书出来，那么最后应该是可以写出来一本书的吧。

就如同这个视频中说的，将卡片笔记法一直践行下去：

神奇的笔记法！你也能轻松开始写作【卡片笔记写作法】 - 哔哩哔哩

#Omnivore

Read on Omnivore
Read Original

Notes

搜索引擎技巧

2024-09-08T04:37:46.000Z

搜索引擎技巧

在使用搜索时，可选用的几个参数

双引号限定关键词 图片"你好"
intitle 标题关键词 intitle:你好
allintitle 多个标题关键词 allintitle:你好世界
intext 内容关键词 intext:世界
inurl 网址关键词 inurl:nginx
site 限定网站域名 site:github.com
imagesize 限定尺寸 imagesize:1920x1080 风景
filetype 文件格式 filetype:pdf OR filetype:doc 机器学习教程

各种资源国内镜像

2025-02-06T03:26:40.000Z

各种资源国内镜像

出现了一个杀死比赛的工具：

RubyMetric/chsrc: chsrc 全平台通用换源工具与框架. Change Source everywhere for every software

使用: chsrc <command> [options] [target] [mirror]

help                      # 打印此帮助，或 h, -h, --help
issue                     # 查看相关issue

list (或 ls, 或 l)        # 列出可用镜像源，和可换源目标
list mirror/target        # 列出可用镜像源，或可换源目标
list os/lang/ware         # 列出可换源的操作系统/编程语言/软件

measure <target>          # 对该目标所有源测速
cesu    <target>

list <target>             # 查看该目标可用源与支持功能
get  <target>             # 查看该目标当前源的使用情况

set  <target>             # 换源，自动测速后挑选最快源
set  <target>  first      # 换源，使用维护团队测速第一的源
set  <target> <mirror>    # 换源，指定使用某镜像站 (通过list命令查看)
set  <target> https://url # 换源，用户自定义源URL
reset <target>            # 重置，使用上游默认使用的源

选项:
-dry                      # Dry Run，模拟换源过程，命令仅打印并不运行
-local                    # 仅对某项目而非全局换源 (仅部分软件如bundler,pdm支持)
-ipv6                     # 使用IPv6测速
-en(glish)                # 使用英文输出
-no-color                 # 无颜色输出

创建一个chrome独立APP窗口

2025-01-21T09:27:50.000Z

创建一个chrome独立APP窗口

创建出的窗口本质还是一个 chrome 网页，但是比较方便使用

按步骤操作：

点击 chrome 右上角的三个点
点击保存并分享
点击创建快捷方式
在弹窗中勾选 在窗口打开，点击创建
即可得到一个独立 APP 窗口

弹窗出来之后，选择 在窗口中打开

就会得到一个独立软件一样的百度

Reference

vscode vim 状态下显示提示

2025-02-13T04:59:33.000Z

vscode vim 状态下显示提示

visual studio code - Keyboard shortcut to show hover tooltip - Stack Overflow

If you're using the VSCodeVim plugin, you can use gh to show the tooltip.

如下图所示，光标所在位置，平常是需要鼠标移动刀红色波浪线位置后才出现这个提示，在使用VSCodeVim的情况下，按下gh可以调出此弹窗快速查看错误提示信息

vscode git 只暂存部分改动

2024-02-29T15:41:01.000Z

vscode git 只暂存部分改动

可以只暂存这部分改动

Reference

visual studio code - How can I commit some changes to a file, but not others, in VSCode? - Stack Overflow

vim显示列分隔符

2024-04-18T08:06:19.000Z

vim显示列分隔符

:set list

显示 tab 和结尾符号 $，不显示开头的 ^ 符号

phpstorm 两下 ctrl 可以快速运行程序

2024-03-19T03:19:05.000Z

phpstorm 两下 ctrl 可以快速运行程序

在 phpstorm 中的工具栏中，有一个绿色的按钮，可以运行已经定义好的配置

但是每次切换的时候，都需要点一下切换到具体的程序

但是如果双击 ctrl 就可以直接弹出运行的搜索栏

在搜索栏中输入你想运行的程序，上下键选中，然后 enter 即可运行

mermaid 图表自动生成

2025-01-16T05:35:31.000Z

mermaid 图表自动生成

https://www.min2k.com/tools/mermaid/

marginnote 使用方法

2024-10-21T08:57:13.000Z

marginnote 使用方法

1 标记

跟红绿灯联系起来，应该会比较好记住

红色：理解并记住
黄色：理解
绿色：了解
灰色：稍微注意一下

2 网页内容剪藏

202409021102 marginnote 从 Web 网页导入内容

marginnote 实现阅读历史跳转

2024-10-21T04:48:12.000Z

marginnote 实现阅读历史跳转

进入系统设置=键盘=快捷键=App快捷键

【全局自定义快捷键方法】MarginNote 3 阅读跳转的 Back 功能快捷键 - 方法、技巧、工作流 - MarginNote 中文社区

网易云音乐mac端回退到2.x版本

2025-02-13T15:08:44.000Z

网易云音乐mac端回退到2.x版本

3.x版本，进入播放页面时，还需要滑动一下（非常吃力的滑动），才能看到精彩评论

决定回退到老版本

https://music.163.com/#/download

接入外置键盘时如何关掉内置键盘

2024-09-26T10:50:58.000Z

接入外置键盘时如何关掉内置键盘

下载： Karabiner-Elements
连接外接设备后，点击 Disable the built-in keyboard while this device is connected 后面的按钮，即可达到此功能
我主要是用在外置键盘放到mac键盘上面，防止误触

mac-鼠须管-使用lua脚本

2024-09-26T07:32:50.000Z

mac-鼠须管-使用lua脚本

在 lua 目录中，添加脚本，以 date 日期文件为例：

--[[
date_translator: 将 `date` 翻译为当前日期

translator 的功能是将分好段的输入串翻译为一系列候选项。

欲定义的 translator 包含三个输入参数：
 - input: 待翻译的字符串
 - seg: 包含 `start` 和 `_end` 两个属性，分别表示当前串在输入框中的起始和结束位置
 - env: 可选参数，表示 translator 所处的环境（本例没有体现）

translator 的输出是若干候选项。
与通常的函数使用 `return` 返回不同，translator 要求您使用 `yield` 产生候选项。

`yield` 每次只能产生一个候选项。有多个候选时，可以多次使用 `yield` 。

请看如下示例：
--]]

local function translator(input, seg)
   -- 如果输入串为 `date` 则翻译
   if (input == "date" or input == "shijian") then
      --[[ 用 `yield` 产生一个候选项
           候选项的构造函数是 `Candidate`，它有五个参数：
            - type: 字符串，表示候选项的类型
            - start: 候选项对应的输入串的起始位置
            - _end:  候选项对应的输入串的结束位置
            - text:  候选项的文本
            - comment: 候选项的注释
       --]]
      yield(Candidate("date", seg.start, seg._end, os.date("%Y年%m月%d日"), "日期"))
      --[[ 用 `yield` 再产生一个候选项
           最终的效果是输入法候选框中出现两个格式不同的当前日期的候选项。
      --]]
      yield(Candidate("date", seg.start, seg._end, os.date("%Y-%m-%d"), "日期"))
      yield(Candidate("date", seg.start, seg._end, os.date("%Y-%m-%d %H:%M:%S"), "日期时间"))
   end
end

-- 将上述定义导出
return translator

rime.lua 中引入此脚本:

-- date_translator: 将 `date` 翻译为当前日期
-- 详见 `lua/date.lua`:
date_translator = require("date")

在 double_pinyin.custom.yaml 或 double_pinyin.schema.yaml 中配置上此处理程序

  engine/translators:
    - lua_translator@date_translator
    - lua_translator@week_translator
    - lua_translator@time_translator
    - lua_translator@number_translator
    - lua_translator@reverse_lookup_filter

最终效果

1 date

2 time

3 number

输入 / ，然后输入数字 1，会显示大写数字

参考

https://github.com/hchunhui/librime-lua

mac-获取程序名称-系统名称

2024-09-26T07:32:07.000Z

mac-获取程序名称-系统名称

#mac

在 raycast 中，可以更方便的取到进程名称，如，图中软件 copy 出来之后是： com.culturedcode.ThingsMac

mac-自定义快捷键

2024-11-05T04:49:57.000Z

mac-自定义快捷键

mac-合上盖子不断网

2024-09-26T07:31:56.000Z

mac-合上盖子不断网

将电池的设置【唤醒以供网络访问】改成【始终】就会生效了

202506172251 mac 强制程序使用代理

2025-06-17T14:53:59.000Z

202506172251 mac 强制程序使用代理

不知道为什么有时候 obsidian 无法使用到代理

可以在命令行启动

export https_proxy=http://127.0.0.1:7890 http_proxy=http://127.0.0.1:7890 all_proxy=socks5://127.0.0.1:7890
open /Applications/Obsidian.app

然后就可以使用到代理了

202404231624 如何在 Finder 中拷贝文件路径全称

2024-10-12T10:33:06.000Z

202404231624 如何在 Finder 中拷贝文件路径全称

在文件上右键，按住 opt 键，点击"将xxx拷贝为路径名称"

拷贝为下面的字符串：

/Users/wudanyang/Downloads/WeTypeInstaller_1.1.0_322.zip

ithoughtx破产了

2024-09-14T07:53:04.000Z

ithoughtx破产了

ithoughtx 思维导图软件的公司 toketaWare 破产了。一个十几年的软件公司就这么没了，这个软件我觉得是非常好用的。

https://www.toketaware.com/about

ai-动画制作

2025-06-05T12:57:59.000Z

ai-动画制作

Animated Drawings | Meta FAIR

202506171613 vscode 如何粘贴文件不覆盖

2025-06-17T15:07:42.000Z

202506171613 vscode 如何粘贴文件不覆盖

vscode 配置， Incremental Naming 选 default => simple

重复文件自动命名

202409022100 things3 与 mac 备忘录联动

2024-09-02T14:07:50.000Z

202409022100 things3 与 mac 备忘录联动

在备忘录中选择【添加App链接】后，当打开对应的页面时，对应的备忘录会在右下角露出一个小图标

202409021102 marginnote 从 Web 网页导入内容

2024-09-26T07:30:40.000Z

202409021102 marginnote 从 Web 网页导入内容

选择学习集或文件夹，点击导入按钮，选择【从Web网页】

使用原始的页面样式，会比较难看，但是 MN 没有抓取页面部分的功能

有一个折中方案，拖动右边的边框，将软件框变小，就变成了下面这样的图片，会比较好看一些

点击软件下面中间的按钮，下载下来即可

有时候代码片段等渲染不是很好
这种情况只能使用 chrome 截图来解决了，在chrome中，可以开启开发者工具进行长截图

利用 Chrome 原生工具进行网页长截图 - 一日一技 - 少数派

#Omnivore

Read on Omnivore

Read Original

Notes

202405081331 mac 鼠须管 - rime 如何使用命令行执行同步操作

2024-09-25T16:07:16.000Z

202405081331 mac 鼠须管 - rime 如何使用命令行执行同步操作

/Library/Input\ Methods/Squirrel.app/Contents/MacOS/Squirrel --sync

配置一个定时任务：

# crontab -e
0 22 * * * /Library/Input\ Methods/Squirrel.app/Contents/MacOS/Squirrel --sync

202404251146 破解mindnode

2024-10-21T08:49:53.000Z

202404251146 破解mindnode

下载mindnode：
MindNode Pro 2023.3.1 思维导图工具 - 精品MAC应用分享

https://xclient.info/s/mind-node-pro.html

如遇：「xxx.app已损坏，打不开。你应该将它移到废纸篓」，请参考：《新手常见问题》中“下载好的DMG 打不开”第二项中内容；如果仅是部分TNT软件闪退打不开，参考《修复TNT和谐软件闪退问题》

10x程序员工作法

2024-10-12T15:16:46.000Z

10x程序员工作法

1 Content

1.1 以终为始

倒着想
DoD（Definition of Done 完成的定义）
- 弥合差异
- 个人的DoD，团队的DoD
- DoD 是一个思维模式，是一种尽可能消除不确定性，达成共识的方式。
- DoD 让我们能够在一开始就把“终”清晰地定义出来。
- 在做任何事之前，先定义完成的标准。
用户故事（User Story）
- 标题
- 概述
- 详述
- 验收标准
- 在做任何需求或任务之前，先定好验收标准。
持续集成
- 尽早提交代码去集成。
精益创业：产品经理不靠谱，你该怎么办？
- MVP 最小可行产品
- 比较早成型的面向不确定创造新事物的方法论是精益创业，它提出了“开发（build）-测量（measure）-认知（learn）”这样一个反馈循环和最小可行产品的概念。
  如何试出来经过验证的认知
- 精益创业提供给我们的是一个做产品的思考框架，我们能够接触到的大多数产品都可以放在这个框架内思考。
- 默认所有需求都不做，直到弄清楚为什么要做这件事。
上下文
- 扩大自己工作的上下文，别把自己局限在一个“程序员”的角色上。
在动手做一件事之前，先推演一番。
数字衡量
- 从数字中发现问题，让系统更稳定。
- 问一下自己，我的工作是不是可以用数字衡量。
开发前的准备
- 设计你的迭代0清单，给自己的项目做体检。

1.2 任务分解

动手做一个工作之前，请先对它进行任务分解。
测试
- 测试模型：冰淇淋蛋卷：
- 金字塔模型：
- 小事反馈周期短，而大事反馈周期长。
- 多写单元测试。
- 我们应该编写可测的代码。
- 将任务拆小，越小越好。
- 按照完整实现一个需求的顺序去安排分解出来的任务。
- 什么是好的测试
  - 怎么衡量测试是否做好了呢？有一个标准：A-TRIP，这是五个单词的缩写，分别是Automatic（自动化）、Thorough（全面）、Repeatable（可重复的）、Independent（独立的）和 Professional（专业的）。
  - 要想写好测试，就要写简单的测试。
需求分解
- 需求估算-大小标准
- 发现大的需求，一个迭代内做不完
- 想要管理好需求，先把需求拆小。
尽量做最重要的事。
做好产品开发，最可行的方式是采用 MVP。

1.3 沟通反馈

对齐？信息对齐
通过沟通反馈，不断升级自己的编解码能力。
用业务的语言写代码。
多面对面沟通，少开会。
多尝试用可视化的方式进行沟通。
定期复盘，找准问题根因，不断改善。
多走近用户。
事情往前做，有问题尽早暴露。
金字塔原理
多输出，让知识更有结构。

1.4 自动化

请谨慎地将工作自动化。
有体系地学习运维知识。
将验收测试自动化。
把函数写短。
~~构建好你的领域模型。~~
用简单技术解决问题，直到问题变复杂。
学习领域驱动设计。再去拆分微服务

1.5 综合

了解一个项目，从大图景开始。
- 业务
- 技术
- 团队运作
小步改造遗留系统，不要回到老路上。
什么叫 T 型人？简言之，一专多能。
在学习区工作和成长。

2 Reference

2.1 39 面对遗留系统，你应该这样做

2.2 https://learn.lianglianglee.com/专栏/10x程序员工作法/总复习重新来“看书”.md

202409022041 神经网络过拟合了怎么办？

2024-10-12T14:17:56.000Z

202409022041 神经网络过拟合了怎么办？

(2 封私信 / 25 条消息) 【寻径06】如何突破学习瓶颈，为何打了10年游戏还是那么菜？ - 知乎: https://www.zhihu.com/zvideo/1447996778805714944?utm_source=ZHShareTargetIDMore&utm_medium=social&utm_oi=649223696263417856

对应到人身上，
- 第一个基本是别想了
- 第二个是最好的方法
- 第三个没看懂什么意思，不知道怎么操作

如果一生只读6本书，推荐哪几本？

2025-02-06T15:05:29.000Z

如果一生只读6本书，推荐哪几本？

嗯，用户问如果一生只能读六本书，推荐哪几本。这个问题看起来简单，但实际上要考虑很多因素。首先，得确定用户的需求是什么。他们可能是在寻找能够全面涵盖人生不同方面的书籍，或者希望这些书能带来深刻的思考和长久的价值。不过，也有可能用户只是想要一些经典中的经典，节省时间，直接读最有价值的书。

接下来要考虑的是书籍的多样性和覆盖领域。文学、哲学、科学、心理学、历史、个人成长这些方面都应该涵盖到，这样才能全面。但六本的数量限制很大，必须精选再精选。比如，文学方面可能选一本小说，哲学选一本基础又深刻的，科学选一本能改变世界观的书，心理学选理解人性的，历史选宏观视角的，个人成长选实用又有深度的。

然后，得想哪些书是经久不衰的，被广泛认可的。比如《活着》这样的中国文学作品，反映了人性和历史，可能比较合适。哲学方面，《苏菲的世界》作为入门书，可能更适合大众，但如果是更深刻的，可能选《存在与时间》之类的，但后者可能太难了。科学方面，《人类简史》虽然不算纯科学，但综合了历史和社会科学，容易引发思考。心理学的话，《思考，快与慢》是行为经济学的经典，但像《影响力》可能更实用。历史可能需要一本更宏观的，比如《枪炮、病菌与钢铁》。个人成长方面，《少有人走的路》结合心理学，可能比《高效能人士的七个习惯》更有深度。

还要考虑不同文化和视角的平衡。比如《百年孤独》代表拉美文学，《沉思录》是西方古典哲学，《道德经》则是东方智慧。这样组合起来，可能更全面。但六本的限制下，可能需要更精炼的选择。

另外，用户可能的背景也很重要。如果是普通读者，可能需要易懂且启发性强的书；如果是学术型，可能需要更专业的著作。但问题中没有说明，所以得假设是普通读者，希望这些书既有深度又不过于晦涩。

然后，还要考虑每本书的独特性和不可替代性。比如《1984》这样的反乌托邦小说，探讨权力与自由，可能比一般小说更具思想性。或者《小王子》这样的寓言，虽然简短但深刻，适合不同年龄层。

不过，可能有些书虽然经典，但内容有重叠。比如《人类简史》和《枪炮、病菌与钢铁》都涉及历史发展，可能需要选其一。或者哲学方面，《道德经》和《沉思录》都是哲学，但来自不同传统，可以互补。

还要考虑书籍的可读性和影响力。比如《百年孤独》虽然文学价值高，但魔幻现实主义可能让部分读者难以进入。而《活着》相对更易读，情感冲击力强。

最后，综合这些因素，可能需要平衡文学、哲学、科学、心理学、历史和个人成长，每类一本，同时兼顾东西方视角，既有小说也有非虚构，既有理论也有实用建议。可能最终的推荐需要覆盖这些方面，同时每本书都能引发深层次的思考，具有持久的影响力。

如果一生只能读6本书，我会推荐涵盖哲学、人性、科学、文学、历史与生活智慧的经典，兼顾东西方思想平衡与深度。以下是我的精选书单及理由：

1. 《道德经》（老子）

核心价值：东方哲学之源
这部5000字的短篇浓缩了道家对自然、社会与生命的终极思考。"上善若水"的柔性智慧、"无为而无不为"的辩证思维，在当代社会竞争中提供反直觉的生存策略。相比西方哲学的系统性，它更像思维种子，每次重读都能在人生不同阶段萌芽新解。

2. 《卡拉马佐夫兄弟》（陀思妥耶夫斯基）

核心价值：人性的百科全书
这部未完成的巨著通过弑父案展开信仰与理性的终极辩论。伊万"宗教大法官"的寓言直指自由与幸福的悖论，阿廖沙的圣徒之路展现救赎可能。书中每个角色都是人性碎片的放大镜，读它等于经历一次灵魂解剖实验。

3. 《存在与时间》（海德格尔）

核心价值：现代性困境的解码
这部晦涩的哲学经典揭示了"被抛入世"的生存本质。当技术理性将人异化为工具，海德格尔提出的"向死而生"与"本真性生存"，为焦虑的现代人提供了存在主义锚点。建议搭配《禅与摩托车维修艺术》辅助理解。

4. 《哥德尔、艾舍尔、巴赫》（侯世达）

核心价值：认知科学的元思考
这部跨界奇书通过数学、音乐与艺术的互文，揭示自我意识与智能的本质。书中"怪圈"概念预示了后来的人工智能困境，读三次才能初窥门径：第一次被创意震撼，第二次理解形式系统，第三次看见认知的边界。

5. 《黑天鹅》（塔勒布）

核心价值：不确定时代的生存指南
在概率统治的现代世界，本书颠覆了传统认知框架。作者提出的"反脆弱"概念比"韧性"更具建设性，建议配合《易经》对照阅读，你会发现概率思维与东方变易哲学的奇妙共鸣。

6. 《追忆似水年华》（普鲁斯特）

核心价值：时间维度的生命实验
这部意识流巨著不是小说，而是用文字构建的时间晶体。当玛德琳蛋糕的味道触发记忆洪流，普鲁斯特示范了如何从碎片中重建生命整体性。建议五十岁后重读，你会惊觉它预言了每个人的记忆重构过程。

选书逻辑：

思维维度互补：覆盖形而上（道德经）、存在论（海德格尔）、认知科学（GEB）、概率哲学（黑天鹅）四重思维框架
时空平衡：东方智慧（道德经）与西方理性（存在与时间）对冲，历史纵深（追忆）与未来预见（黑天鹅）交织
阅读挑战梯度：从叙事文本（卡拉马佐夫）渐进到哲学思辨（存在与时间），最终抵达意识流的认知极限（追忆）

这6本书构成完整的思维生态系统：前3本锻造认知武器，后3本提供应用场景。每十年重读一次，随着阅历增长，同一文本会显现不同维度的智慧，如同六面棱镜折射出人生的光谱。真正的经典不是答案之书，而是培养提出关键问题能力的思维催化剂。

202404151420 哲学的分支

2024-10-12T09:05:31.000Z

202404151420 哲学的分支

哲学是一个广泛的学科，包含多个分支，除了形而上学之外，还包括以下主要领域：

认识论（Epistemology）：研究知识的性质、起源、范围和极限。认识论探讨我们如何知道什么是真实的，什么可以被认为是知识，以及我们如何获取知识。
伦理学（Ethics）：探讨行为的道德性，即什么是对的，什么是错的。伦理学涉及到道德原则、价值观和好的生活方式的探讨。
逻辑学（Logic）：研究有效推理的原则。逻辑学关注于如何构建有效的论证，以及如何区分有效论证和无效论证。
政治哲学（Political Philosophy）：探讨政府、公民、政治权利、公正、法律、自由、正义等概念。政治哲学试图理解人类社会和政治结构的理想形态。
美学（Aesthetics）：研究美和艺术的本质、经验和价值。美学涵盖了艺术作品的创造、欣赏和批评等方面。
存在主义（Existentialism）：虽然更多被视为哲学的一个流派，但存在主义对个体存在、自由和选择的探讨对整个哲学领域有深远影响。
心灵哲学（Philosophy of Mind）：研究心灵本质、心灵与身体的关系等问题。心灵哲学试图理解意识、感觉、感知和思维的本质。
语言哲学（Philosophy of Language）：探索语言的本质、使用以及语言与现实之间的关系。语言哲学关注如何通过语言表达思想以及语言如何影响我们的理解和认识世界。
科学哲学（Philosophy of Science）：分析科学的方法、目的和理论基础。它探讨了科学如何工作，以及科学知识的性质和局限性。

这些领域相互交织，共同构成了哲学这一广泛的学科。每个领域都有其特定的研究问题和方法，但它们共同探讨人类知识和存在的基本问题。

形而上学是哲学的一个核心分支，它探讨现实的最基本结构和本质。词语“形而上学”（Metaphysics）源自拉丁语“Metaphysica”，最早可追溯到亚里士多德的作品集，意味着“超越自然之学”。形而上学关注那些超越物理科学研究范畴的问题，试图理解和解释存在的根本性质、宇宙的本质、事物存在的原因以及它们是如何存在的。

20240415141933 什么是哲学

2024-10-12T05:38:19.000Z

20240415141933 什么是哲学

哲学是在探究根本性的问题，【为什么】这个问题要问到根本

比如，为什么要吃饭，因为要活着，为什么活着。。。

生成

2024-04-16T15:18:10.000Z

tags: #how-to-learn

一句话简单描述：自己想出一个答案，如果错了就给出反馈，纠正答案

生成

自己想出答案

参考

认知天性

20240417103919 卡片盒笔记法的标题是对内容的一句话描述

2024-10-12T14:44:01.000Z

20240417103919 卡片盒笔记法的标题是对内容的一句话描述

补充 202011192023 - 卡片盒笔记法的基本元素

20240408201701 卡片盒笔记法

2024-10-12T15:45:41.000Z

20240408201701 卡片盒笔记法

#zettelkasten

202011192022 - 什么是卡片盒笔记法

202011201016 - 什么是知识和信息

202011201301 - 基础概念

202011192023 - 卡片盒笔记法的基本元素

202011210003 - 卡片盒笔记法的基本流程

202011201315 - 卡片盒笔记法主要关注什么

Reference

202404081818 为什么建立笔记时要指明原因

2024-10-12T15:45:36.000Z

202404081818 为什么建立笔记时要指明原因

建立笔记连接的同时，还需要指明原因，不然回顾的时候会感觉到困惑

比如：

什么是知识： 202011222324 - 知识

在链接前面增加解释语言

202404081701 针对过时的想法怎么处理

2024-10-12T15:45:15.000Z

202404081701 针对过时的想法怎么处理

一些过时的想法，该删就删，别犹豫

202404081646 卡片笔记应该记录什么

2024-10-12T15:45:03.000Z

202404081646 卡片笔记应该记录什么

20240408201701 卡片盒笔记法应该是记录知识202011222324 - 知识而不是202011222325 - 信息的

知识，也许应该就是想法，思考，或者闪念

但是信息怎么记录呢？记录到哪里呢？比较有疑问

1 Reference

卢曼卡片盒笔记法介绍 (Introduction to the Zettelkasten Method) • Zettelkasten Method: https://zettelkasten.de/introduction/zh/

202011230004 - 如何写出容易理解的卡片

2025-02-13T04:56:42.000Z

tags: #zettelkasten #communicate

一句话简单描述这张卡片：几年之后，你可能无法理解这张卡片，
那么如何能做到更容易理解呢？

202011230004 - 如何写出容易理解的卡片

一个好的标题，可以是一种注释
第一句话应该是关于此卡片的
写的话要简单
你是在教育你的卡片盒，他会在以后的某个时间点出来跟你对话
想象一下，你是在跟以后的自己在对话

参考

https://zettelkasten.de/posts/how-to-write-notes-you-can-understand/

202011222338 - 使用卡片盒笔记法输出的流程

2024-04-21T03:08:27.000Z

tags: #output #process

202011222338 - 使用卡片盒笔记法输出的流程

整体看一下相关的知识
为写作列出需要的大纲
把永久笔记放到大纲中
使用更多的知识（研究）填补空白，重复3-4步，直到满意为止
根据提纲复制笔记到文档中
重写你的手稿

参考

https://zettelkasten.de/posts/ease-into-writing/

202011222325 - 信息

2024-07-03T16:06:51.000Z

202011222325 - 信息

信息是死的，一系列数据的陈列

信息是 what/when/where/who

信息是你应该被告诉什么是事情

202011222324 - 知识

2024-05-14T06:26:19.000Z

202011222324 - 知识

知识拿到之后，能让你有借鉴意义，能指导你的下一步工作，是活的

知识是 how/why

202011222310 - 卡片盒笔记法的模块

2024-02-01T04:53:19.000Z

202011222310 - 卡片盒笔记法的模块

Inbox
Archive
Reference Database

Information is the Basic Unit of Your Throughput

如果没有输入，那么知识库就不会成长

如果没有输出，那么知识库的增长就毫无意义

参考

卡片盒的构建模块

202011222209 - 卡片盒笔记法的步骤

2024-04-17T05:14:30.000Z

202011222209 - 卡片盒笔记法的步骤

卡片盒笔记法的步骤？

202011210003 - 卡片盒笔记法的基本流程

参考

https://blog.jimmylv.info/2020-06-03-zettelkasten-in-action/

202011220028 - 从输出的角度看卡片盒笔记法的优势

2024-04-21T03:01:11.000Z

202011220028 - 从输出的角度看卡片盒笔记法的优势

从输出层面看，如果你在写作的时候才去找资料，那么很容易脱离主线，而如果你之前都整理好了资料，那么在写作的时候，只要顺着自己的卡片写下去就行了
在输出的时候能够补全自己的盲点

20240408201701 卡片盒笔记法

参考

https://www.zhihu.com/search?type=content&q=Zettelkasten

202011210003 - 卡片盒笔记法的基本流程

2024-04-17T05:13:13.000Z

202011210003 - 卡片盒笔记法的基本流程

#process

记录：将自己的想法记录到临时卡片
提炼：阅读书籍、资料的时候将内容记录到临时卡片
参考：将参考目录加上一个简介
整理：将记录的临时卡片和文献卡片通过链接联系起来
1. 建立链接，看一下你的永久笔记，有哪些能连接起来
2. 提炼索引
3. 建立入口
回顾：定期进行回顾，通过双向链接回顾全篇文章
产出：将卡片内容产出成文章
1. 选定一个主题，沿着链接将内容(链接)提炼出来

202011201315 - 卡片盒笔记法主要关注什么

2024-04-20T16:07:54.000Z

202011201315 - 卡片盒笔记法主要关注什么

链接 linking
回顾 recalling
索引 indexing

参考

Zettelkasten In Notion & How I Use Its Principles

202011201301 - 基础概念

2024-04-16T14:35:51.000Z

202011201301 - 基础概念

四种卡片

临时卡片，把自己的想法记录下来
文献卡片，看书或者其他信息，觉得自己能用到就记录下来，注意，用自己的话来描述，不能复制粘贴或者剪藏
永久卡片，将临时笔记和文献笔记组织成文，找出笔记之间的联系，将笔记放到卡片盒中
项目卡片

两种卡片盒

知识卡片盒
文献笔记盒

202011201016 - 什么是知识和信息

2024-04-27T12:32:55.000Z

202011201016 - 什么是知识和信息

202011222324 - 知识

知识拿到之后，能让你有借鉴意义，能指导你的下一步工作，是活的

知识是 how/why

202011222325 - 信息

信息是死的，一系列数据的陈列

信息是 what/when/where/who

信息是你应该被告诉什么是事情

信息是回答“when，where，what，who”的问题，形成回答某个特定问题的文本，以及被解释具有某些意义的数字、事实、图像等形式的信息，更多关注对事实和数据的陈述。而知识是回答“how，why”的问题，能移积极地指导任务的执行和管理，进行决策和解决问题，更多关注人们如何解释信息的经验、偏见、运用的法则和价值标准。知识与信息的效用处于并列地位，没有层次之分。 ⤴️

202011192023 - 卡片盒笔记法的基本元素

2024-09-24T11:00:29.000Z

202011192023 - 卡片盒笔记法的基本元素

唯一 id ， id后面的标题： 20240417103919 卡片盒笔记法的标题是对内容的一句话描述
tags 标签
内容
1. links 连接到其他的笔记
2. content，使用自己的话写下这个想法
3. citation，引用，这个想法是从哪里得到的
参考（对书籍等信息的参考）

The most important aspect of the body of the Zettel is that you write it in your own words.

202011192022 - 什么是卡片盒笔记法

2024-04-16T15:15:08.000Z

202011192022 - 什么是卡片盒笔记法

卡片盒笔记法是德国的一个社会学家发明的

是一种处理笔记的流程

将自己的想法感悟收集起来，
然后使用卡片盒笔记法进行整理，
建立笔记之间的联系

以便于以后检索和使用

redis-rdb 文件分析

2024-10-07T04:15:55.000Z

202011281031 - 安装 rdbtools 工具

redis-rdb 文件分析

命令行工具使用，先看 `--help`

usage: usage: rdb [options] /path/to/dump.rdb

Example : rdb --command json -k "user.*" /var/redis/6379/dump.rdb

positional arguments:
  dump_file             RDB Dump file to process

optional arguments:
  -h, --help            show this help message and exit
  -c CMD, --command CMD     
                        Command to execute. Valid commands are json, diff,
                        justkeys, justkeyvals, memory and protocol
  -f FILE, --file FILE  Output file
  -n DBS, --db DBS      Database Number. Multiple databases can be provided.
                        If not specified, all databases will be included.
  -k KEYS, --key KEYS   Keys to export. This can be a regular expression
  -o NOT_KEYS, --not-key NOT_KEYS
                        Keys Not to export. This can be a regular expression
  -t TYPES, --type TYPES
                        Data types to include. Possible values are string,
                        hash, set, sortedset, list. Multiple typees can be
                        provided. If not specified, all data types will be
                        returned
  -b BYTES, --bytes BYTES
                        Limit memory output to keys greater to or equal to
                        this value (in bytes)
  -l LARGEST, --largest LARGEST
                        Limit memory output to only the top N keys (by size)
  -e {raw,print,utf8,base64}, --escape {raw,print,utf8,base64}
                        Escape strings to encoding: raw (default), print,
                        utf8, or base64.
  -x, --no-expire       With protocol command, remove expiry from all keys
  -a N, --amend-expire N
                        With protocol command, add N seconds to key expiry
                        time

参数解析

-c 执行命令输出不同格式的数据
1. json; 输出 json 格式的字符串如： [{"int":"1"}]
2. diff; 导出可供 diff 、kdiff 、 vimdiff 比较的数据
3. justkeys; 只输出 key
4. justkeyvals; 只输出键值对，以空格分隔
5. memory; 输出内存分布状态
6. protocol; 输出原始的 RESP 协议
-f 指定输出到文件
-n 指定输出的 db
-k 指定输出哪些 key; 可以使用正则表达式，如： '^users_\d+$'
-o 排除哪些 key; 可以使用正则表达式
-t 指定输出 value 的类型
-b 指定大于此字节数的 key 输出
-l 输出最大的多少个 key
-e 转义字符串到其他格式
1. raw 原始字符串
2. print
3. utf8 输出原始 utf8 格式字符串
4. base64 对于二进制数据来说，可以先 base64 存储到文件，然后在程序中 decode 出来
-x 在导出 RESP 协议内容时，去掉过期时间
-a 导出 RESP 协议内容时，给有过期时间的 key 加上几秒钟过期时间

下面看一下一些常见用法：

生成内存报告

rdb --command memory dump.rdb > memory.csv

生成 CSV 格式的内存报告。包含的列有：
数据库 ID，数据类型，key，内存使用量(byte)，编码。内存使用量包含 key、value 和其他值，结果：

database,type,key,size_in_bytes,encoding,num_elements,len_largest_element,expiry
0,set,fruit,252,hashtable,2,6,
0,hash,webset,81,ziplist,1,13,
0,string,baiduyun,64,string,5,5,
0,list,languages,161,quicklist,2,6,
0,sortedset,page_rank,80,ziplist,1,9

使用参数过滤想要的数据

# 使用这个命令会将存储的 int 值显示为 json 的字符串
> rdb -c json --db 2 --type hash --key "a.*" /var/redis/6379/dump.rdb

[{},{
"aroma":{"pungent":"vinegar","putrid":"rotten eggs","floral":"roses"}}]

比较两个 rdb 文件

> rdb --command diff /var/redis/6379/dump1.rdb | sort > dump1.txt
> rdb --command diff /var/redis/6379/dump2.rdb | sort > dump2.txt

# 使用 diff 软件查看 diff
> kdiff3 dump1.txt dump2.txt

查看一个 key 的内存使用情况

> redis-memory-for-key person:1

> redis-memory-for-key -s localhost -p 6379 -a mypassword person:1

Key 			person:1
Bytes				111
Type				hash
Encoding			ziplist
Number of Elements		2
Length of Largest Element	8          # hash 中占用内存最大的那个 value 的占用字节数

常见问题 FAQ

内存报告的精确度如何？

答：最多有 10% 的误差
存储了一个二进制 binary 数据，但是输出的时候是乱码，不可读，怎么处理？

答：可以使用 -e 命令先输出 base64 编码的字符串，然后程序中解码之后使用
这个工具能解析哪个版本的 rdb 文件？

答：2~6 版本
我不想用 python，有其他的解析方案吗？

答：
1. redis-rdb is written in Ruby
2. rdbhs is written in Haskell
3. rdb-parser is written in Node.js
4. rdb is written in Go
5. rdb-rs is written in Rust
6. 参阅 rdb 文件格式自己写一个解析

参考

https://github.com/sripathikrishnan/redis-rdb-tools

202011281031 - 安装 rdbtools 工具

2024-04-25T03:15:37.000Z

202011281031 - 安装 rdbtools 工具

pip install rdbtools python-lzf

或者

git clone https://github.com/sripathikrishnan/redis-rdb-tools
cd redis-rdb-tools
sudo python setup.py install

python-为什么 {} 不能作为默认参数？

2025-02-11T14:48:01.000Z

python-为什么 {} 不能作为默认参数？

这里会有个提示，但不是报错

为什么 {} 不能作为默认参数？

在 Python 中，函数的默认参数只在函数定义时计算一次，所以如果你使用 {} 作为默认值，它会在所有函数调用之间共享。这意味着：

多次调用 resp_success() 时，data 会共享同一个字典
如果 data 在一个调用中被修改，后续调用也会受到影响（因为所有调用都引用同一个 {}）

比如下面的代码：

def add_item(item, items=[]):
    items.append(item)
    return items

# 第一次调用，期望返回 [1]
print(add_item(1))  # 输出 [1]

# 第二次调用，期望返回 [2]，但实际输出 [1, 2]
print(add_item(2))  # 输出 [1, 2]

解决方法，默认参数改成不可变的变量，或者 None

def add_item_fixed(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

# 第一次调用返回 [1]
print(add_item_fixed(1))  # 输出 [1]

# 第二次调用返回 [2]
print(add_item_fixed(2))  # 输出 [2]

python-Asyncer

2025-04-25T11:03:19.000Z

python-Asyncer

fastapi/asyncer: Asyncer, async and await, focused on developer experience.

使用raise_sync_error=False，如果 syncify 在 worker thread（异步的线程池上下文）中执行，可以将异步函数从worker thread 中发送到主异步线程运行。

如果程序不是异步的，也就是不在 worker thread，那么会使用 anyio.run 重新开启一个事件循环，这个过程比较耗费资源，需要谨慎使用

import time

import anyio
from asyncer import asyncify, syncify


async def do_async_work(name: str):
    await anyio.sleep(1)
    return f"Hello, {name}"


def do_sync_work(name: str):
    time.sleep(1)
    message = syncify(do_async_work, raise_sync_error=False)(name=name)
    return message


async def main():
    message = await asyncify(do_sync_work)(name="World")
    print(message)


def sync_main():
    message = do_sync_work(name="Sync World")
    print(message)


anyio.run(main)
sync_main()

python 虚拟环境

2025-05-13T14:32:53.000Z

python 虚拟环境

venv： python 内置的模块，用于创建隔离的python环境

Conda：一个开源的包管理系统和环境管理系统，用于安装多种包，且可以创建多个独立的环境

venv

jetbrains 会自动创建 venv 环境

vscode中，需要执行命令Python: Create Environment 进行创建

创建完之后，会在项目根目录创建一个文件夹 .venv

# 终端开启虚拟环境
source .venv/bin/activate
# 安装依赖， -i 使用镜像
pip3 install -r requirements.txt -i 镜像源 https://pip.baidu-int.com/simple/

vscode 的python扩展会在打开内置terminal的时候自动加载虚拟环境

参考

Python虚拟环境venv（和我一起玩Python）_哔哩哔哩_bilibili

python fastapi 默认线程数

2025-06-19T05:34:56.000Z

python fastapi 默认线程数

默认的线程数限制：

asyncio 事件循环的默认线程池执行器（ThreadPoolExecutor）默认是：

max_workers = min(32, (os.cpu_count() or 1) + 4)

fastapi 修改线程数

同步函数的线程池大小：可以通过 anyio.to_thread.current_default_thread_limiter().total_tokens 获取。默认是40个。

修改线程池大小：

from anyio import to_thread

async def foo():
    # Set the maximum number of worker threads to 60
    to_thread.current_default_thread_limiter().total_tokens = 60

gunicorn+uvicorn+fastapi 进程模型.excalidraw

2025-05-27T06:12:43.000Z

php-xml 如何解析 cdata

2024-04-18T08:27:43.000Z

php-xml 如何解析 cdata

$content = simplexml_load_string(
    '<content><![CDATA[Hello, world!]]></content>'
    , null
    , LIBXML_NOCDATA // merge cdata as text node
);

https://stackoverflow.com/questions/2970602/php-how-to-handle-cdata-with-simplexmlelement

PHP生成zip压缩包

2024-10-20T09:53:15.000Z

PHP生成zip压缩包

1 将文件压缩成zip格式

<?php
$path = "file.txt";
$filename = "file.zip";

$zip = new ZipArchive();
$zip->open($filename, ZipArchive::CREATE); //打开压缩包
$zip->addFile($path, basename($path)); //向压缩包中添加文件
$zip->close(); //关闭压缩包

202012081017 - php8.0 新特性

2025-02-13T05:11:20.000Z

202012081017 - php8.0 新特性

把 youtube 中的 php8.0 的新特性看完了
1. doc 属性
2. jit
3. ?-> null 安全运算符
4. WeakMap
5. string 的函数 str_contain
6. 命名参数
7. 构造函数成员提升
8. match 表达式匹配
9. mixed 类型
10. 使用对象进行 ::class 调用
11. 联合类型 float|int

不打开obsidian的情况下记录当前事件

2024-10-12T15:16:21.000Z

不打开obsidian的情况下记录当前事件

将输入设置成你想附带的文本，传入内容改成“作为参数”

加上 open --background "$1" 即可实现在不将 obsidian 放到前台的情况下记录日志。

使用这种方法 obsidian 不会到前台占用注意力，不过仍然会将对应的操作完成

参考

Leave Obsidian in background when making URI call? - Developers & API - Obsidian Forum

obsidian 开发过程支持的ICON

2024-02-01T07:25:33.000Z

obsidian 开发过程支持的ICON

[!info]- Icons

add-note-glyph

any-key

audio-file

blocks

bold-glyph

box-glyph

bracket-glyph

broken-link

bullet-list

bullet-list-glyph

calendar-glyph

calendar-with-checkmark

check-in-circle

check-small

checkbox-glyph

checkmark

clock

clock-glyph

cloud

code-glyph

command-glyph

compress-glyph

create-new

cross

cross-in-box

crossed-star

dice

dice-glyph

document

documents

dot-network

double-down-arrow-glyph

double-up-arrow-glyph

down-arrow-with-tail

down-chevron-glyph

down-curly-arrow-glyph

duplicate-glyph

enlarge-glyph

enter

exit-fullscreen

expand-vertically

file-explorer-glyph

filled-pin

folder

forward-arrow

fullscreen

gear

github-glyph

go-to-file

graph-glyph

hashtag

heading-glyph

help

highlight-glyph

horizontal-split

image-file

image-glyph

import-glyph

indent-glyph

info

install

italic-glyph

keyboard-glyph

languages

left-arrow

left-arrow-with-tail

left-chevron-glyph

lines-of-text

link

link-glyph

links-coming-in

links-going-out

logo-crystal

magnifying-glass

merge-files

merge-files-glyph

microphone

microphone-filled

minus-with-circle

navigate-glyph

note-glyph

number-list-glyph

open-elsewhere-glyph

open-vault

pane-layout

paper-plane

paper-plane-glyph

paste

paste-text

paused

pdf-file

pencil

percent-sign-glyph

pin

play-audio-glyph

plus-minus-glyph

plus-with-circle

popup-open

presentation

presentation-glyph

price-tag-glyph

question-mark-glyph

quote-glyph

reading-glasses

redo-glyph

reset

restore-file-glyph

right-arrow

right-arrow-with-tail

right-chevron-glyph

right-triangle

run-command

scissors

scissors-glyph

search

search-glyph

select-all-text

sheets-in-box

split

stacked-levels

star

star-glyph

star-list

stop-audio-glyph

strikethrough-glyph

switch

sync

sync-small

tag-glyph

three-horizontal-bars

tomorrow-glyph

trash

two-blank-pages

undo-glyph

unindent-glyph

up-and-down-arrows

up-arrow-with-tail

up-chevron-glyph

up-curly-arrow-glyph

uppercase-lowercase-a

vault

vertical-split

vertical-three-dots

wand

wand-glyph

workspace-glyph

wrench-screwdriver-glyph

yesterday-glyph

Icon148	Name
	add-note-glyph
	any-key
	audio-file
	blocks
	bold-glyph
	box-glyph
	bracket-glyph
	broken-link
	bullet-list
	bullet-list-glyph
	calendar-glyph
	calendar-with-checkmark
	check-in-circle
	check-small
	checkbox-glyph
	checkmark
	clock
	clock-glyph
	cloud
	code-glyph
	command-glyph
	compress-glyph
	create-new
	cross
	cross-in-box
	crossed-star
	dice
	dice-glyph
	document
	documents
	dot-network
	double-down-arrow-glyph
	double-up-arrow-glyph
	down-arrow-with-tail
	down-chevron-glyph
	down-curly-arrow-glyph
	duplicate-glyph
	enlarge-glyph
	enter
	exit-fullscreen
	expand-vertically
	file-explorer-glyph
	filled-pin
	folder
	forward-arrow
	fullscreen
	gear
	github-glyph
	go-to-file
	graph-glyph
	hashtag
	heading-glyph
	help
	highlight-glyph
	horizontal-split
	image-file
	image-glyph
	import-glyph
	indent-glyph
	info
	install
	italic-glyph
	keyboard-glyph
	languages
	left-arrow
	left-arrow-with-tail
	left-chevron-glyph
	lines-of-text
	link
	link-glyph
	links-coming-in
	links-going-out
	logo-crystal
	magnifying-glass
	merge-files
	merge-files-glyph
	microphone
	microphone-filled
	minus-with-circle
	navigate-glyph
	note-glyph
	number-list-glyph
	open-elsewhere-glyph
	open-vault
	pane-layout
	paper-plane
	paper-plane-glyph
	paste
	paste-text
	paused
	pdf-file
	pencil
	percent-sign-glyph
	pin
	play-audio-glyph
	plus-minus-glyph
	plus-with-circle
	popup-open
	presentation
	presentation-glyph
	price-tag-glyph
	question-mark-glyph
	quote-glyph
	reading-glasses
	redo-glyph
	reset
	restore-file-glyph
	right-arrow
	right-arrow-with-tail
	right-chevron-glyph
	right-triangle
	run-command
	scissors
	scissors-glyph
	search
	search-glyph
	select-all-text
	sheets-in-box
	split
	stacked-levels
	star
	star-glyph
	star-list
	stop-audio-glyph
	strikethrough-glyph
	switch
	sync
	sync-small
	tag-glyph
	three-horizontal-bars
	tomorrow-glyph
	trash
	two-blank-pages
	undo-glyph
	unindent-glyph
	up-and-down-arrows
	up-arrow-with-tail
	up-chevron-glyph
	up-curly-arrow-glyph
	uppercase-lowercase-a
	vault
	vertical-split
	vertical-three-dots
	wand
	wand-glyph
	workspace-glyph
	wrench-screwdriver-glyph
	yesterday-glyph

Reference

digital-garden 在 windows 上面 diff 出错

2024-10-12T15:16:11.000Z

digital-garden 在 windows 上面 diff 出错

https://github.com/oleeskild/obsidian-digital-garden
obsidian 插件 digital-garden 在windows上面有个 bug，会将我的 frontmatter 全部透传
推到代码库中是这样的： https://github.com/wudanyang6/dy_turbo/commit/7b66296c349fb067d3d62c43d5f04b6a784a2197

可以看到，格式完全变了

所以千万不要在 windows 上面使用，不过也可能是我的机器问题

从而导致的问题是，我的网站上面所有的文章全都使用新路径重新发布了一遍

dg-publish=true的标签云

2024-10-23T12:28:06.000Z

dg-publish=true的标签云

效率 (1) tools (2) things3 (2) linux (8) shell (3) aigc (6) 压力测试 (1) aigc-kimi (1) 文件 (1) 操作系统 (1) 描述符 (1) 文件描述符 (1) 甲沟炎 (1) Go (5) (3) chatgpt (1) kafka (1) 学习 (1) mysql (1) nginx (4) master (1) Process (2) source-code (2) php (2) 压缩 (1) excalidraw (2) redis (1) rdb (1) zettelkasten (1) 哲学 (2) aigc-deepseek (1) 思维导图 (1) rime (1) marginnote (1) 阅读器 (1) mac (4) 输入法 (1) phpstorm (1) ide (1) chrome (1) 镜像 (1) 开发经验 (1) linux命令 (1) 树莓派 (1) leetcode (15) 前缀和 (2) dp (1) network (1) 家 (1)

digital-garden 还是很牛的，居然是能用的

贴一下完整代码：

``dataviewjs
let tagCounts = {};

// 遍历所有包含标签的笔记，收集标签并统计出现次数
for (let page of dv.pages().where(p => p.tags && p["dg-publish"] === true)) {  // 只处理包含标签的页面
	let tags = page.tags.toString()
	let tagArr = tags.split(',')
	
    for (let tag of tagArr) {
        tagCounts[tag] = (tagCounts[tag] || 0) + 1;
    }
}

// 找到标签的最大频次，以便调整大小
let maxCount = Math.max(...Object.values(tagCounts));

// 设置字体大小范围（最小10px，最大40px）
const minSize = 10;
const maxSize = 40;

// 生成标签云，根据频次调整标签字体大小
dv.container.innerHTML = Object.entries(tagCounts)
    .map(([tag, count]) => {
        // 根据标签出现的频次计算字体大小
        let size = minSize + ((count / maxCount) * (maxSize - minSize));
        // 创建可点击的链接，链接到搜索栏
        return `<span style="font-size:${size}px; margin-right:20px;">
                    <a href="obsidian://search?query=tag:${encodeURIComponent(tag)}" style="text-decoration:none; color:inherit;">
                        <strong>${tag}</strong> (${count})
                    </a>
                </span>`;
    })
    .join('');  // 每个标签后换行
``

202409052343 github 部署任务设置 reviewer

2024-10-12T14:22:13.000Z

202409052343 github 部署任务设置 reviewer

之前用 windows 机器部署的时候出了问题，大概率是 digital 插件兼容问题：digital-garden 在 windows 上面 diff 出错

所以在站点部署时，增加了一个 review 环节，防止站点陷入瘫痪状态

202404181240 快捷指令-记录今天的事情 obsidian

2024-05-14T06:25:00.000Z

202404181240 快捷指令-记录今天的事情 obsidian

快捷指令地址： https://www.icloud.com/shortcuts/6f0552b8622c4b3389b0f53a7af1e919

安装快捷指令

修改快捷指令中的参数

最终效果：

obsidian 不会到前台占用你的注意力不打开obsidian的情况下记录当前事件

202404181228 使用 open --background 的形式打开 obsidian 不够轻便

2024-10-16T11:00:21.000Z

202404181228 使用 open --background 的形式打开 obsidian 不够轻便

mac 的快捷指令执行太慢，所以不打开obsidian的情况下记录当前事件虽然能够实现后台记录日志，但是对流程太过打扰，所以我现在使用了 202404181237 Raycast 的 floating note 进行简单记录一些一闪而过的想法，或者使用 202404181237 Things 的快速捕获功能进行记录

编译 nginx

2024-10-21T11:13:29.000Z

编译 nginx

1 在 mac 上面编译

./configure --with-debug --with-cc=/usr/bin/cc --with-cc-opt='-O0 -g' --prefix="/Users/wudanyang/workspace/reading-code-of-nginx-1.9.2/nginx-compile" --with-stream

在 vagrant 上面编译

在 vagrant 上面安装
./configure \
--with-debug \
--with-cc=/usr/bin/cc \
--with-cc-opt='-O0 -g' \
--prefix="/vagrant/reading-code-of-nginx-1.9.2/nginx-compile/" \
--with-stream \
--with-file-aio

./configure \
--with-debug \
--with-cc=/usr/bin/cc \
--with-cc-opt='-O0 -g' \
--prefix="/mnt/mydisk/var/nginx" \
--with-stream \
--with-file-aio

安装 pcre 库，http rewrite module 需要使用

sudo apt-get install libpcre3 libpcre3-dev

make

make install

2 树莓派上面编译

auto/configure --prefix=/home/ubuntu/mydisk/var/nginx-debug-1 --with-http_v2_module --with-http_ssl_module

2.1 编译时遇到的报错

2.1.1 implicit fallthrough error

linux下编译nginx1.0.15报错：Implicit fallthrough error

CFLAGS表示编译的可选参数，我们只需要在后面加上**-Wno-implicit-fallthrough**，即可忽略gcc7编译时switch-case中缺少break的错误。

2.1.2 'struct crypt_data' has no member named 'current_salt'

编译nginx时struct crypt_data’没有名为‘current_salt’的成员：cd.current_salt[0] = ~salt[0]；的解决方案
在源码中注释掉那行代码

2.1.3 cast between incompatible function types

cast function type
https://github.com/SELinuxProject/setools/issues/2
-Wno-cast-function-type

如何查看 nginx 的rewrite记录

2024-04-25T11:06:19.000Z

如何查看 nginx 的rewrite记录

设置 rewrite_log on;

并且将error_log 的报错等级改成 notice;

官网对 rewrite_log 的解释：

Syntax:	rewrite_log on | off;
Default:	
rewrite_log off;
Context:	http, server, location, if
Enables or disables logging of ngx_http_rewrite_module module directives processing results into the error_log at the notice level.

可以看到，这个指令只能在 http server location if 配置指令中使用，日志等级是 notice 写入到 error_log 配置的文件中。

示例

url： /q?someparams

2021/04/22 18:21:28 [notice] 18131#0: *102982 "^/+m/question(.*)?qid=\d+(.*)?$" does not match ...
... 中间省略一些日志
2021/04/22 18:21:28 [notice] 18131#0: *102982 "^/+question/(\w+.*?)$" does not match ...
2021/04/22 18:21:28 [notice] 18131#0: *102982 "^/+q\?(.*)?tn=nsatom_qb_main(.*)?$" matches ...
2021/04/22 18:21:28 [notice] 18131#0: *102982 "^/+q" matches ...
2021/04/22 18:21:28 [notice] 18131#0: *102982 rewritten data: "/q/q/q/q/q"

从上面的日志中可以看出，当触发了重写规则时，会有关键字 matches 否则会有 does not match 。

最终重写完成之后，访问的地址会有标记：rewritten data

这里就是 /q/q/q/q/q

参考

best way to debug nginx rewrite rules in config file?

nginx官方文档：Module ngx_http_rewrite_module

vscode 调试nginx代码

2024-10-12T15:02:05.000Z

vscode 调试nginx代码

修改 auto/cc/conf

ngx_compile_opt 中添加 -g
修改后如下：

ngx_compile_opt="-c -g"

[[#gcc -g 的作用]]

编译 & 安装 & 运行

# prefix 是想要安装到的目录
auto/configure --prefix=/home/ubuntu/mydisk/var/nginx-debug-1

# 编译安装
make
make install

修改配置

vim /home/ubuntu/mydisk/var/nginx-debug-1/conf/nginx.conf
将监听端口号改成 8080
worker_processes 改成 1 (方便调试)

启动 nginx

/home/ubuntu/mydisk/var/nginx-debug-1/sbin/nginx

nginx 的进程：

ps aux | grep nginx
ubuntu     17093  0.0  0.0   4184   372 ?        Ss   Mar30   0:00 nginx: master process /home/ubuntu/mydisk/var/nginx-debug-1/sbin/nginx
ubuntu     17094  0.0  0.0   4620  2316 ?        S    Mar30   0:00 nginx: worker process
ubuntu     46072  0.0  0.0   7692   648 pts/0    S+   11:21   0:00 grep --color=auto nginx

配置 vscode 调试

{
    // 使用 IntelliSense 了解相关属性。 
    // 悬停以查看现有属性的描述。
    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "debug master",
            "type": "cppdbg",
            "request": "launch",
            "program": "/home/ubuntu/mydisk/var/nginx-debug-1/sbin/nginx",
            "args": [],
            "stopAtEntry": true,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "为 gdb 启用整齐打印",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        },
        {
            "name": "debug worker",
            "type": "cppdbg",
            "request": "attach",
            "program": "/home/ubuntu/mydisk/var/nginx-debug-1/sbin/nginx",
            "processId": 17094,
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "为 gdb 启用整齐打印",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}

在 worker 上调试需要改成 attach 的形式，并且使用了一次 attach 之后，就不能使用 strace -p 17094 查看系统调用了

然后就可以打断点，进行单步调试了

参考

Mac上用Visual Studio Code调试Nginx

gcc -g 的作用

GCC 参数详解-runoob
在编译的时候会产生调试信息

kernel.yama.ptrace_scope

sysctl -a 查看内核参数
kernel.yama.ptrace_scope
https://www.kernel.org/doc/Documentation/security/Yama.txt

sudo vim /etc/sysctl.d/10-ptrace.conf

VSCode调试出现无法打开glibc库的“raise.c“或“abort.c“等文件的错误

sudo strace 报操作不被允许

sudo strace -p 17094

strace: Could not attach to process. If your uid matches the uid of the target process, check the setting of /proc/sys/kernel/yama/ptrace_scope, or try again as the root user. For more details, see /etc/sysctl.d/10-ptrace.conf: Operation not permitted
strace: attach: ptrace(PTRACE_SEIZE, 17094): Operation not permitted

https://stackoverflow.com/questions/19215177/how-to-solve-ptrace-operation-not-permitted-when-trying-to-attach-gdb-to-a-pro
Maybe someone has attached this process with gdb.

ps -ef | grep gdb

can't gdb attach the same process twice.
将 vscode 中的调试关掉，就可以使用 strace 了
如下图，可以看到，子进程停在了 epoll_pwait 系统调用上了

nginx-master-start-worker

2025-01-20T13:13:27.000Z

nginx-master-start-worker

入口

启动子进程的流程在ngx_start_worker_processes函数中，具体代码如下：

static void
ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t n, ngx_int_t type)
{
    ngx_int_t  i;

    ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");

    for (i = 0; i < n; i++) {

        ngx_spawn_process(cycle, ngx_worker_process_cycle,
                          (void *) (intptr_t) i, "worker process", type);

        ngx_pass_open_channel(cycle);
    }
}

创建子进程

其中创建子进程的函数为 ngx_spawn_process，主要就是封装了 fork 函数。

ngx_pid_t
ngx_spawn_process(ngx_cycle_t *cycle, ngx_spawn_proc_pt proc, void *data,
    char *name, ngx_int_t respawn)
{
    // ...
    pid = fork();

    switch (pid) {

    case -1:
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      "fork() failed while spawning \"%s\"", name);
        ngx_close_channel(ngx_processes[s].channel, cycle->log);
        return NGX_INVALID_PID;

    case 0:
        ngx_parent = ngx_pid;
        ngx_pid = ngx_getpid();
        proc(cycle, data);
        break;

    default:
        break;
    }

    ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start %s %P", name, pid);

    ngx_processes[s].pid = pid;
    ngx_processes[s].exited = 0;

  // ...
}

fork 函数的返回值：

子进程返回0，父进程返回子进程id，若出错，返回 -1

子进程在 case 0 中执行 proc 函数，proc 函数是 ngx_start_worker_processes 函数中传进来的第二个参数 ngx_worker_process_cycle。

ngx_worker_process_cycle 函数，就是 worker 进程的主要流程，以后会继续分析。

最大子进程数量

if (s == NGX_MAX_PROCESSES) {
    ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                    "no more than %d processes can be spawned",
                    NGX_MAX_PROCESSES);
    return NGX_INVALID_PID;
}

#define NGX_MAX_PROCESSES         1024

最大子进程数量定义成了 NGX_MAX_PROCESSES 也就是 1024，如果超过了 1024个进程，就会报错

`respawn` 参数的意义

`respawn` 大于等于0时

respawn 大于等于0时，代表重启子进程，respawn 代表给 ngx_processes 数组的下标

if (respawn >= 0) {
    s = respawn;
} else {
    ...
}

`respawn` 小于0时

respawn 小于0时，代表启动的子进程的属性，子进程的几种属性：

#define NGX_PROCESS_NORESPAWN     -1
#define NGX_PROCESS_JUST_SPAWN    -2
#define NGX_PROCESS_RESPAWN       -3
#define NGX_PROCESS_JUST_RESPAWN  -4
#define NGX_PROCESS_DETACHED      -5

那么 respawn 小于0时，子进程在 ngx_processes数组中的下标是多少呢？

看下面这段代码：

for (s = 0; s < ngx_last_process; s++) {
    if (ngx_processes[s].pid == -1) {
        break;
    }
}

if (s == NGX_MAX_PROCESSES) {
    ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                  "no more than %d processes can be spawned",
                  NGX_MAX_PROCESSES);
    return NGX_INVALID_PID;
}

实际上就是在找 ngx_processes 数组中未使用的最小下标。

参考

《UNIX 环境高级编程》

os/unix/ngx_process.c源代码分析

nginx 进程模型-整体架构

2024-10-12T15:03:04.000Z

nginx 进程模型-整体架构

从网上找了一个非常好的图片，从图中可以看到很多东西

Nginx 会生成多个进程
worker 使用了 io 多路复用的事件驱动框架
worker 内部有很多模块
worker 处理磁盘 I/O 时，使用了标准 I/O ， sendfile ， AIO ，mmap 等 I/O 技术
Cache loader 和 Cache manager 操作 proxy cache
后端支持多种基于 tcp 的网络协议

nginx master 进程

2024-04-18T08:30:16.000Z

nginx master 进程

之前有说到 nginx 进程模型-整体架构，下面来看一下 nginx master 进程的主要工作

nginx 的入口 main 函数在 nginx.c 文件中

函数原型为：

int ngx_cdecl
main(int argc, char *const *argv)

在这个函数中，master 做了一系列的初始化操作

最终在下面这个地方进入了主流程中：

//...
    if (ngx_process == NGX_PROCESS_SINGLE) {
        ngx_single_process_cycle(cycle);

    } else {
        ngx_master_process_cycle(cycle);
    }
//...

因为我们主要看 master-worker 这种进程模型，所以进入 ngx_master_process_cycle

设置信号屏蔽字，防止创建子进程过程中被信号中断

// 先清空信号集
    sigemptyset(&set);
    sigaddset(&set, SIGCHLD);
    sigaddset(&set, SIGALRM);
    sigaddset(&set, SIGIO);
    sigaddset(&set, SIGINT);
    sigaddset(&set, ngx_signal_value(NGX_RECONFIGURE_SIGNAL));
    sigaddset(&set, ngx_signal_value(NGX_REOPEN_SIGNAL));
    sigaddset(&set, ngx_signal_value(NGX_NOACCEPT_SIGNAL));
    sigaddset(&set, ngx_signal_value(NGX_TERMINATE_SIGNAL));
    sigaddset(&set, ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
    sigaddset(&set, ngx_signal_value(NGX_CHANGEBIN_SIGNAL));

// 设置信号屏蔽字，将 set 中的信号设置为阻塞状态，防止创建worker 的过程中，被进来的信号打断
    if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      "sigprocmask() failed");
    }

// 将 set 清空
    sigemptyset(&set);

设置信号屏蔽字，防止在创建子进程的过程中被信号处理程序中断

关于信号屏蔽字，引用 《UNIX 环境高级编程》 中信号一节的部分内容：

进程可以选用“阻塞信号递送”。如果为进程产生了一个阻塞的信号,而且对该信号的动作是系统默认动作或捕捉该信号, 则为该进程将此信号保持为未决状态,直到该进程对此信号解除了阻塞, 或者将对此信号的动作更改为忽略。内核在递送一个原来被阻塞的信号给进程时(而不是在产生该信号时),才决定对它的处理方式。于是进程在信号递送给它之前仍可改变对该信号的动作。进程调用 sigpending 函数(见10.13节)来判定哪些信号是设置为阻塞并处于未决状态的。

每个进程都有一个信号屏蔽字( signal mask),它规定了当前要阻塞递送到该进程的信号集。对于每种可能的信号,该屏蔽字中都有一位与之对应。对于某种信号,若其对应位已设置,则它当前是被阻塞的。进程可以调用 sigprocmask(在10.12节中说明)来检测和更改其当前信号屏蔽字。

当然，在下面创建完子进程之后，会使用 sigsuspend 解除信号屏蔽，并使 master 进程进入休眠

关于 sigsuspend 函数，简单来说，它是一个 sigprocmask(SIG_SETMASK, &emptyset, NULL) 和 pause() 函数的结合体，不过相对于使用两个函数完成上述操作，sigsuspend 是 原子操作。

具体的操作如下：

使用新的信号集合设置屏蔽字，在这里是清空屏蔽字
调用信号处理函数，并从信号处理程序返回
屏蔽字恢复成调用 sigsuspend 之前的值（再次不让进程被信号打断）

设置 master 进程的 title

static u_char  master_process[] = "master process";

    size = sizeof(master_process);

    for (i = 0; i < ngx_argc; i++) {
        size += ngx_strlen(ngx_argv[i]) + 1;
    }

    title = ngx_pnalloc(cycle->pool, size);
    if (title == NULL) {
        /* fatal */
        exit(2);
    }

    p = ngx_cpymem(title, master_process, sizeof(master_process) - 1);
    for (i = 0; i < ngx_argc; i++) {
        *p++ = ' ';
        p = ngx_cpystrn(p, (u_char *) ngx_argv[i], size);
    }

    ngx_setproctitle(title);

将进程title设置成三个部分：

固定字符：nginx:
主进程标志: master process
命令行启动的命令，如：/home/ubuntu/mydisk/var/nginx-debug-1/sbin/nginx

所以进程刚开始是这样显示的：

$ ps aux | grep nginx | grep -v grep
root      183117  0.0  0.0   4324  2680 ?        ts   17:07   0:00 /home/ubuntu/mydisk/var/nginx-debug-1/sbin/nginx

设置了 title 之后，变成了下面这样：

$ ps aux | grep nginx | grep -v grep
root      183117  0.0  0.0   4324  2680 ?        ts   17:07   0:00 nginx: master process /home/ubuntu/mydisk/var/nginx-debug-1/sbin/nginx

根据配置启动相应数量的 `worker` 和 `cache` 管理进程

ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

ngx_start_worker_processes(cycle, ccf->worker_processes,
                           NGX_PROCESS_RESPAWN);
ngx_start_cache_manager_processes(cycle, 0);

监听信号，并作出响应

在 ngx_init_signals 函数中，对原始信号做了变量名映射，具体映射如下：

信号	对应进程中的标志位变量	含义
QUIT	ngx_quit	优雅关闭服务
TERM 或 INT	ngx_terminate	强制关闭服务
USR1	ngx_reopen	重新打开服务中的所有文件
WINCH	ngx_noaccept	所有子进程不再接受处理新的连接，实际相当于对所有的子进程发送 QUIT 信号
USR2	ngx_change_binary	平滑升级到新版本的 Nginx 程序
HUP	ngx_reconfigure	重新读取配置文件并使服务对新配置项生效
CHLD	ngx_reap	有子进程意外结束 master 会监控所有子进程，并在子进程意外退出时调用 ngx_reap_children 方法重启子进程

master 并不是时刻不停的执行循环检测这些标志位，而是通过 sigsuspend 进入休眠，等待有信号唤醒进程时，再循环检测所有信号并处理。

参考

nginx中的ngx_cdecl

Nginx源码|Nginx信号处理

nginx 信号处理

LINUX C中sigprocmask()函数用法

linux信号的阻塞和未决

《UNIX 环境高级编程》

nginx-master-start-worker

mysql5.7json支持

2024-07-03T16:09:01.000Z

mysql5.7json支持

内容

原生支持 json

create table user ( uid int auto_increment, data json,primary key(uid)) engine=innodb;

可以选择使用 json 类型来创建列

虚拟列，可以创建索引

-- 先创建一个虚拟列
alter table user add user_name varchar(128) generated always as (json_extract(data,'$.name')) virtual;

-- 然后在虚拟列上创建索引
alter table user add index idx_username (user_name);

这里存疑一点，虚拟列的维护可能会耗费比较多的资源，会导致插入性能降低

虽然虚拟列的值在实际查询时动态计算，节省了磁盘存储空间，但这种计算确实可能在一定程度上影响插入和更新性能。每次插入或更新记录时，MySQL 都需要计算或重新计算虚拟列的值。

如果在虚拟列上建立索引，这种效果可能会更加显著，因为每次插入或更新操作还需要更新索引。此外，创建索引本身也会消耗磁盘空间。

然而，这些影响因情况而异。虚拟列表达式的计算性能，以及查询虚拟列和索引所带来的性能提升，可能会抵消甚至超过额外的插入和更新成本。特别是在对存储空间有严格要求，或者需要频繁查询 JSON 属性的场景中，使用虚拟列和索引可能是一个好的选择。

总的来说，是否使用虚拟列和在其上建立索引，需要根据实际的数据特性、查询模式和性能要求综合考虑决定。在实际应用中，可能需要进行一些性能测试和调优来找到最适合的解决方案。

参考

MySQL 5.7原生JSON格式支持 - 腾讯云开发者社区-腾讯云

MySQL :: MySQL 5.7 Reference Manual :: 11.5 The JSON Data Type

mac 运行 kafka

2024-05-14T06:22:38.000Z

mac 运行 kafka

安装

brew install kafka

启动 broker

手动启动 kafka，同时启动一个使用 2181 端口的 zookeeper

/opt/homebrew/opt/kafka/bin/zookeeper-server-start /opt/homebrew/etc/kafka/zookeeper.properties
/opt/homebrew/opt/kafka/bin/kafka-server-start /opt/homebrew/etc/kafka/server.properties

启动生产者

/opt/homebrew/opt/kafka/bin/kafka-console-producer --topic test --bootstrap-server localhost:9092

启动消费者

/opt/homebrew/opt/kafka/bin/kafka-console-consumer --topic test --bootstrap-server localhost:9092  --from-beginning

创建 topic

kafka-topics --create  --replication-factor 1 --partitions 5 --topic myTopic --bootstrap-server localhost:9092

查看 topic 列表

/opt/homebrew/opt/kafka/bin/kafka-topics --bootstrap-server localhost:9092   --list

数据文件目录

/opt/homebrew/var/lib/kafka-logs/

简易 go 程序

package main

import (
	"fmt"

	"github.com/confluentinc/confluent-kafka-go/v2/kafka"
)

func main() {

	p, err := kafka.NewProducer(&kafka.ConfigMap{"bootstrap.servers": "localhost"})
	if err != nil {
		panic(err)
	}

	defer p.Close()

	// Delivery report handler for produced messages
	go func() {
		for e := range p.Events() {
			switch ev := e.(type) {
			case *kafka.Message:
				if ev.TopicPartition.Error != nil {
					fmt.Printf("Delivery failed: %v\n", ev.TopicPartition)
				} else {
					fmt.Printf("Delivered message to %v\n", ev.TopicPartition)
				}
			}
		}
	}()

	// Produce messages to topic (asynchronously)
	topic := "myTopic"
	for _, word := range []string{"Welcome", "to", "the", "Confluent", "Kafka", "Golang", "client"} {
		p.Produce(&kafka.Message{
			TopicPartition: kafka.TopicPartition{Topic: &topic, Partition: kafka.PartitionAny},
			Value:          []byte(word),
		}, nil)
	}

	// Wait for message deliveries before shutting down
	p.Flush(15 * 1000)
}

《Kafka 权威指南》章节列表

《kafka 权威指南》
章节列表：
第 1 章初识 kafka
第 2 章安装 Kafka
第 3 章 Kafka 生产者——向 Kafka 写入数据
第 4 章 Kafka 消费者——从 Kafka 读取数据
第 5 章深入 Kafka
第 6 章可靠的数据传递
第 7 章构建数据管道
第 8 章跨集群数据镜像
第 9 章管理 Kafka
第 10 章监控 Kafka
第 11 章流式处理

Reference

mac环境下使用brew安装Kafka(详细过程)_brew kafka-CSDN博客

Kafka整体架构、工作流程与文件存储机制 - 细雨骑驴入剑门 - 博客园

扫盲Kafka？看这一篇就够了！ - 京东云技术团队 - 博客园

Kafka元数据缓存(metadata cache) - huxihx - 博客园

Kafka入门

2025-02-13T05:12:00.000Z

Kafka入门

1 什么是 Kafka

Apache Kafka 是一个分布式流处理平台，被设计用来高效地处理高吞吐量的数据流。它广泛应用于实时数据管道和流式应用程序中。以下是 Kafka 的一些主要优点：

高吞吐量：Kafka 支持高吞吐量的数据处理，即使是非常大的数据量也能够快速处理。
可扩展性：Kafka 集群可以横向扩展以处理更多的数据，可以在不停机的情况下动态添加更多的 Broker。
持久性和可靠性：Kafka 可以将数据持久化到磁盘，因此即使系统发生故障，数据也不会丢失。它使用分区和副本机制来确保数据的高可用性和耐用性。
容错能力：通过数据副本，Kafka 可以在节点故障时保证数据不丢失，从而提供高可靠性。
低延迟：Kafka 能够在保持高吞吐量的同时实现低延迟的消息传递。
可靠的消息传递保证：Kafka 支持几种消息传递保证，包括最多一次、至少一次和精确一次（事务性传递）。
多客户端支持：Kafka 提供多种编程语言的客户端库，方便不同开发环境下的集成。
流处理：Kafka Streams API 允许构建实时流处理应用，可以进行复杂的数据处理和分析。
可观测性：Kafka 提供了监控数据流和系统性能的工具，有助于性能调优和问题诊断。
大型社区和生态系统：Kafka 拥有一个庞大的社区和丰富的生态系统，提供了大量的工具和插件以及集成方案，可以帮助用户更好地开发和维护 Kafka 系统。

2 使用场景

Kafka 的这些优点使它在需要处理大量实时数据的系统中特别有价值，包括日志聚合、流式处理、事件源、实时监控和分析等场景。

3 kafka 生产消费流程

../100 Programmer/mac 运行 kafka

2 Kafka 整体架构

Kafka 系统的核心概念包括：

Producer（生产者）：负责发布消息到 Kafka 的 Topic（主题）中。
Consumer（消费者）：订阅 Topic，并处理发布到这些 Topic 的消息。
Consumer Group（消费者组）：一个消费者组可以有一个或多个消费者实例。当多个消费者实例属于同一个消费者组时，它们会在组内共享 Topic 的 Partition。这意味着，每个 Partition 只会被消费者组中的一个消费者实例消费，这样可以保证每条消息只被组内的一个消费者处理，从而实现消息的负载均衡。
Broker（代理）：Kafka 集群中的服务器，负责存储数据并处理 Producer 和 Consumer 的请求。
Topic（主题）：消息的分类，Producer 发布消息到指定的 Topic，Consumer 订阅并消费 Topic 中的消息。
Partition（分区）：Topic 的物理分割，每个 Partition 在存储层面是独立的，可以在不同的 Broker 上。Partition 内的消息是有序的。
Offset（偏移量）：Partition 中每条消息的唯一标识，可以看作是消息在 Partition 中的索引。
Replica（副本）：Partition 的副本，用于提高数据的可靠性和容错性。
Zookeeper：Kafka 使用 Zookeeper 来进行集群管理和协调。
Stream Processing（流处理）：Kafka Streams 是 Kafka 的流处理库，用于构建流式应用程序。
Connect（连接器）：Kafka Connect 是用于构建和运行可重用的数据导入和导出连接器的工具。

Kafka 生产者将消息发送到负责存储目标 Topic 的 Partition 的 Broker 上。在 Kafka 集群中，每个 Topic 可以分为多个 Partition，而每个 Partition 可能分布在不同的 Broker 上。每个 Partition 有一个 Broker 充当 Leader，其他的 Broker 充当 Follower。所有的读写操作都是通过 Leader Broker 进行的，Follower 负责同步数据以保证高可用性和数据的冗余。

3 Kafka 核心逻辑

1 物理存储

Kafka 的基本存储单元是分区。

kafka 存储的时候也是使用同样的格式存储到磁盘上，这样可以利用到零拷贝技术

2 生产者

流程如下：

首先，我们需要创建一个 ProducerRecord，这个对象需要包含消息的主题（topic）和值（value），可以选择性指定一个键值（key）或者分区（partition）。
发送消息时，生产者会对键值和值序列化成字节数组，然后发送到分配器。
如果我们指定了分区，那么分配器返回该分区即可；否则，分配器将会基于键来选择一个分区并返回。
选择完分区后，生产者知道了消息所属的主题和分区，它将这条记录添加到相同主题和分区的同一批次消息中，另一个线程负责发送这些批量消息到对应的 Kafka Broker。
当 Broker 接收到消息后，如果成功写入则返回一个包含消息的主题、分区及位移的 RecordMetadata 对象，否则返回异常。
生产者接收到结果后，对于异常可能会进行重试。重试几次还是失败会返回错误。

生产者并不是将消息发送到任意的 Broker，而是发送到管理特定 Partition 的 Leader Broker 上，以确保消息的正确存储和分发。

消息写入多个分区

3 消费者

3.1 提交 offset

Kafka 消费者提交偏移量的过程是为了记录消费者在消费 Topic 的 Partition 时当前的位置，以便在消费者重启或发生故障时能从上次处理的位置继续消费，保证消息不会丢失也不会被重复消费。提交偏移量的过程主要包括以下步骤：

消费消息：消费者从 Broker 拉取数据并进行处理。
提交偏移量：在成功处理完一批消息后，消费者会将最新的偏移量提交给 Kafka。提交的偏移量是消费者下一次预期读取的起始位置。
偏移量存储：提交的偏移量存储在 Kafka 内的一个特殊的 Topic 中，名为 __consumer_offsets。每个消费者组的偏移量都会在这个 Topic 中维护。
偏移量读取：如果消费者发生重启或故障，它会从 __consumer_offsets Topic 中读取上次提交的偏移量，从而恢复其消费状态。

提交偏移量的方式主要有两种：

自动提交偏移量：Kafka 消费者默认的偏移量提交方式是自动提交。这是通过在消费者配置中设置 enable.auto.commit=true 来实现的，并且可以通过 auto.commit.interval.ms 配置项来指定提交间隔。这种方式简单方便，但是由于提交是周期性进行的，可能会导致消息重复消费（如果在两次提交间隔内消费者失败）。
手动提交偏移量：为了更精确地控制消息的消费状态，可以选择手动提交偏移量。手动提交可以是同步的也可以是异步的：
- 同步提交：通过调用 consumer.commitSync() 方法，消费者会阻塞直到偏移量提交完成。这种方式会确保偏移量提交成功，如果提交失败，可以立即进行重试处理。
- 异步提交：通过调用 consumer.commitAsync() 方法，消费者可以在不阻塞当前线程的情况下提交偏移量。异步提交通常会提供一个回调函数来处理可能发生的提交错误。
- 异步 + 同步：针对异步提交偏移量丢失的问题，通过对消费者进行异步批次提交并且在关闭时同步提交的方式，这样即使上一次的异步提交失败，通过同步提交还能够进行补救，同步会一直重试，直到提交成功。

4 复制

4.1 控制器

有一个概念需要单独阐明：控制器

控制器其实就是一个 Broker，只不过它除了具有一般 Broker 的功能之外，还负责分区首领的选举。

控制器是 Kafka 集群的管理节点。在一个 Kafka 集群中，所有的 Broker 节点中只有一个节点会被选举为控制器。

每个新选出的控制器通过 Zookeeper 的条件递增操作获得一个全新的、数值更大的 epoch 值，防止脑裂

简而言之，Kafka 使用 Zookeeper 的临时节点来选举控制器，并在节点加入集群或退出集群时通知控制器。控制器负责在节点加入或离开集群时进行分区首领选举。控制器使用 epoch 来避免“脑裂”。“脑裂”是指两个节点同时认为自己是当前的控制器。

4.2 与首领保持一致

为了与首领保持同步，跟随者向首领发送获取数据的请求，这种请求与消费者为了读取消息而发送的请求是一样的。首领将响应消息发给跟随者。请求消息里包含了跟随者想要获取消息的偏移量，而且这些偏移量总是有序的。

5 处理请求

Kafka 使用零复制技术向客户端发送消息——也就是说，顺序读写内容，Kafka 直接把消息从文件 (或者更确切地说是 Linux 文件系统缓存) 里发送到网络通道，而不需要经过任何中间缓冲区。

零拷贝示意图：

零拷贝省略了数据在内核空间和用户空间之间的重复穿梭；用户态和内核态切换时产生中断，耗时；

生产请求和获取请求都必须发送给分区的首领副本。

如何获取分区首领所在的 broker：

4 可靠性保证

先了解一个概念：不完全的首领选举

1 消息传递语义

最多一次（at most once）：消息可能会丢失，但绝不会被重复发送。
1. 消费者端配置自动提交偏移量，并且在处理消息之前就提交。如果在提交偏移量后处理消息时发生了故障，那么这些消息可能不会被重新消费。
至少一次（at least once）：消息不会丢失，但有可能被重复发送。
1. 手动提交偏移量。如果消费者在成功处理消息之前失败，那么同一消息可能会被再次消费。
恰好一次（exactly once）：消息不会丢失，也不会被重复发送。
1. Kafka 通过“幂等生产者”（Idempotent Producer）和“事务”（Transactions）来支持恰好一次的语义。幂等生产者确保即使生产者发送重复的消息，Broker 也只会接收一次。事务性生产者可以将消息的发送和偏移量的提交放在同一个事务中，确保它们要么都成功，要么都失败。（恰好一次语义在 Kafka 0.11 版本及以上被引入。）

2 不完全的首领选举

是否允许不完全的首领选举：unclean.leader.election
如果在选举过程中没有丢失数据，也就是说提交的数据同时存在于所有的同步副本上，那么这个选举就是“完全”的。
如果在首领不可用时其他副本都是不同步的，那么这个选举就是“不完全”的。

简而言之，如果我们允许不同步的副本成为首领，那么就要承担丢失数据和出现数据不一致的⻛险。如果不允许它们成为首领，那么就要接受较低的可用性，因为我们必须等待原先的首领恢复到可用状态。

unclean.leader.election=false

3 复制

复制系数
replication.factor >= 2
min.insync.replicas > 1 则至少有一个同步从副本

4 使用生产者

发送确认：

acks=0 立即返回，不论是否写入
acks=1 当前首领副本已经写入
acks=-1 或 all 所有同步的副本已经被写入

重试

配置重试次数
设置重试间隔
程序兜底其他错误

5 使用消费者

如果消费者提交了偏移量却未能处理完消息，那么就有可能造成消息丢失，这也是消费者丢失消息的主要原因。

正确的做法是：拉取数据、业务逻辑处理、提交消费 Offset 位移信息。

enable.auto.commit = false 采用手动提交位移的方式。

对于消费消息重复的情况，业务自己保证幂等性，保证只成功消费一次即可。

6 思考

Q: 知道了 kafka 的物理存储的结构，那么 kafka 通过 offset 查找对应的文件位置的过程是什么样的呢？

Q: 从副本在什么情况下被认为是不同步 (OSR) ？

Q: offset 为什么要从 zookeeper 挪到 kafka 本身存储呢？

Q：分区分成多少比较好？

Q：在主题流量不是很大的情况下，消费者一直轮询会造成浪费，有没有什么方式能够避免这种情况？

Q：Kafka 为什么要把自己定位成一个分布式流平台？

7 参考

《Kafka 权威指南》 Neha Narkhede Gwen Shapira Todd Palino 著薛命灯译

官网文档： Apache Kafka

mac环境下使用brew安装Kafka(详细过程)_brew kafka-CSDN博客

Kafka整体架构、工作流程与文件存储机制 - 细雨骑驴入剑门 - 博客园

扫盲Kafka？看这一篇就够了！ - 京东云技术团队 - 博客园

Kafka元数据缓存(metadata cache) - huxihx - 博客园

Kafka 物理存储机制 - Java程序员进阶 - 博客园

稀疏索引与其在Kafka和ClickHouse中的应用-腾讯云开发者社区-腾讯云

8张图带你全面了解kafka的核心机制 - JAVA旭阳 - 博客园

进阶，Kafka 如何保证消息不丢失？ - 知乎

Kafka的自我定位

快速创建一个可访问的服务

2025-02-24T07:29:43.000Z

快速创建一个可访问的服务

1 创建一个 k8s 集群

安装 Docker Desktop，并在设置中开启Kubernetes 功能

这时，你会得到一个单节点的 k8s 集群

通过 kubectl get nodes 查看，会输出以下内容：

➜  qsk-book git:(main) ✗ kubectl get nodes
NAME             STATUS   ROLES           AGE   VERSION
docker-desktop   Ready    control-plane   14h   v1.30.2

现在启动了一个名为 docker-desktop 的 control-plane （控制面）节点

2 将应用部署到 `k8s`

下载示例文件（示例文件是《Kubernetes 快速入门》一书的附带内容）：

git clone https://github.com/nigelpoulton/qsk-book.git
cd qsk-book
ls -l 

# 输出内容
total 24
drwxr-xr-x 7 wudanyang 224 10 13 15:50 App
drwxr-xr-x 8 wudanyang 256 10 13 15:50 Appv1.1
-rw-r--r-- 1 wudanyang 509 10 14 13:04 deploy.yml
-rw-r--r-- 1 wudanyang 225 10 13 15:50 pod.yml
-rw-r--r-- 1 wudanyang 929 10 13 15:50 readme.md
-rw-r--r-- 1 wudanyang 509 10 13 15:50 rolling-update.yml
-rw-r--r-- 1 wudanyang 178 10 13 15:50 svc-cloud.yml
-rw-r--r-- 1 wudanyang 217 10 13 15:50 svc-local.yml

部署 Pod：

kubectl apply -f pod.yml

➜  qsk-book git:(main) ✗ kubectl get pods
NAME                          READY   STATUS    RESTARTS   AGE
first-pod                     1/1     Running   0          6s

查看部署的 Pod

kubectl describe pod first-pod

可以看到，现在 Pod 是运行中了，端口号监听的是 8080

Name:             first-pod
Namespace:        default
Priority:         0
Service Account:  default
Node:             docker-desktop/192.168.65.3
Start Time:       Mon, 14 Oct 2024 14:49:56 +0800
Labels:           project=qsk-book
Annotations:      <none>
Status:           Running
IP:               10.1.0.27
IPs:
  IP:  10.1.0.27
Containers:
  web-ctr:
    Container ID:   docker://d06da3abd9e749933edc798a99571e3540bf8a16059823a78e4483530157e323
    Image:          nigelpoulton/qsk-book:latest
    Image ID:       docker-pullable://nigelpoulton/qsk-book@sha256:ea4422925917a5d957aab20603bbd2521e811088dc68ca3f5703458966733d72
    Port:           8080/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Mon, 14 Oct 2024 14:50:00 +0800
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-j8kn6 (ro)
Conditions:
  Type                        Status
  PodReadyToStartContainers   True
  Initialized                 True
  Ready                       True
  ContainersReady             True
  PodScheduled                True
Volumes:
  kube-api-access-j8kn6:
    Type:                    Projected (a volume that contains injected data from multiple sources)
    TokenExpirationSeconds:  3607
    ConfigMapName:           kube-root-ca.crt
    ConfigMapOptional:       <nil>
    DownwardAPI:             true
QoS Class:                   BestEffort
Node-Selectors:              <none>
Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                             node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  16m   default-scheduler  Successfully assigned default/first-pod to docker-desktop
  Normal  Pulling    16m   kubelet            Pulling image "nigelpoulton/qsk-book:latest"
  Normal  Pulled     16m   kubelet            Successfully pulled image "nigelpoulton/qsk-book:latest" in 3.231s (3.231s including waiting). Image size: 193578060 bytes.
  Normal  Created    16m   kubelet            Created container web-ctr
  Normal  Started    16m   kubelet            Started container web-ctr

3 连接到应用

如果只是部署了一个应用，那么在外部是不能访问到这个应用的，因为它的网络只工作在 k8s 的内部

要想在外部访问应用，还得使用 Service 才行

使用 svc-local.yml 文件部署一个 Service 对象

➜  qsk-book git:(main) ✗ kubectl apply -f svc-local.yml
service/svc-local created

# 2022 version
apiVersion: v1
kind: Service
metadata:
  name: svc-local
spec:
  type: NodePort
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
    nodePort: 31111
  selector:
    project: qsk-book

配置文件的内容大概意思就是将 label 为 project: qsk-book 的应用的8080 端口映射到节点的 31111 端口，细节再去看书

➜  qsk-book git:(main) ✗ kubectl get svc
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP          15h
svc-local    NodePort    10.101.54.180   <none>        8080:31111/TCP   2m34s

访问 http://localhost:31111/

出现下面的情况，就代表访问通了

4 清理应用

kubectl delete pod first-pod

5 应用自我修复

自我修复需要一个新的对象：Deployment

kubectl apply -f deploy.yml

replicas 副本数 5 个

# 2022 version
apiVersion: apps/v1
kind: Deployment
metadata:
  name: qsk-deploy
spec:
  replicas: 5
  selector:
    matchLabels:
      project: qsk-book
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        project: qsk-book
    spec:
      containers:
      - name: qsk-pod
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
        image: nigelpoulton/qsk-book:1.1

➜  qsk-book git:(main) ✗ kubectl get deploy
NAME         READY   UP-TO-DATE   AVAILABLE   AGE
qsk-deploy   5/5     5            5           4h5m

➜  qsk-book git:(main) ✗ kubectl get pods
NAME                          READY   STATUS    RESTARTS   AGE
qsk-deploy-668c8bdb95-6cw5d   1/1     Running   0          141m
qsk-deploy-668c8bdb95-dgtx5   1/1     Running   0          140m
qsk-deploy-668c8bdb95-f97mk   1/1     Running   0          140m
qsk-deploy-668c8bdb95-qhzl4   1/1     Running   0          141m
qsk-deploy-668c8bdb95-xssrf   1/1     Running   0          141m

5.1 Pod 故障重新拉起

使用命令删除掉一个 pod，模拟有一个 pod 故障了

kubectl delete pod qsk-deploy-668c8bdb95-6cw5d

可以看到立刻有一个 pod 被创建

➜  qsk-book git:(main) ✗ kubectl get pods
NAME                          READY   STATUS              RESTARTS   AGE
qsk-deploy-668c8bdb95-6cw5d   1/1     Terminating         0          143m
qsk-deploy-668c8bdb95-dgtx5   1/1     Running             0          141m
qsk-deploy-668c8bdb95-f97mk   1/1     Running             0          141m
qsk-deploy-668c8bdb95-qbhtg   0/1     ContainerCreating   0          3s
qsk-deploy-668c8bdb95-qhzl4   1/1     Running             0          142m
qsk-deploy-668c8bdb95-xssrf   1/1     Running             0          142m

5.2 工作节点故障重新部署

本地没有多节点环境，所以无法模拟

具体现象是，如果故障节点上面有 2 个 pod，那么这 2 个 pod 会被部署到仍存在的节点上

如果节点机器提供者也有故障恢复，那么故障的节点会重新加入到 k8s 集群中，但是已经被迁移走的 pod 不会重新回来

6 应用扩缩容

修改 deploy.yml 将 replicas 修改成你想要的数量

重新执行： kubectl apply -f deploy.yml

扩容时，会重新创建新 pod

➜  qsk-book git:(main) ✗ kubectl get pods
NAME                          READY   STATUS              RESTARTS   AGE
qsk-deploy-668c8bdb95-dgtx5   1/1     Running             0          148m
qsk-deploy-668c8bdb95-f97mk   1/1     Running             0          149m
qsk-deploy-668c8bdb95-fxh4n   0/1     ContainerCreating   0          4s
qsk-deploy-668c8bdb95-hn5bq   0/1     ContainerCreating   0          4s
qsk-deploy-668c8bdb95-qbhtg   1/1     Running             0          7m8s
qsk-deploy-668c8bdb95-qhzl4   1/1     Running             0          149m
qsk-deploy-668c8bdb95-tj4wv   0/1     ContainerCreating   0          4s
qsk-deploy-668c8bdb95-xssrf   1/1     Running             0          149m

缩容时，会将多余的 pod 删掉（我发现都是删除的运行时间比较短的 pod）

➜  qsk-book git:(main) ✗ kubectl get pods
NAME                          READY   STATUS        RESTARTS   AGE
qsk-deploy-668c8bdb95-dgtx5   1/1     Running       0          149m
qsk-deploy-668c8bdb95-f97mk   1/1     Terminating   0          149m
qsk-deploy-668c8bdb95-fxh4n   1/1     Terminating   0          48s
qsk-deploy-668c8bdb95-hn5bq   1/1     Terminating   0          48s
qsk-deploy-668c8bdb95-qbhtg   1/1     Terminating   0          7m52s
qsk-deploy-668c8bdb95-qhzl4   1/1     Running       0          150m
qsk-deploy-668c8bdb95-tj4wv   1/1     Terminating   0          48s
qsk-deploy-668c8bdb95-xssrf   1/1     Running       0          150m

7 应用滚动更新

kubectl apply -f rolling-update.yml

rolling-update.yml 和原来的配置的区别：

执行之后，会新创建一个新的 Pod，将老的 pod 删掉

js超长数字溢出问题

2024-10-12T15:19:38.000Z

tags: #js #联调 #踩坑

https://www.cnblogs.com/wudanyang/p/15940613.html

js超长数字溢出问题

之前遇到过的一个问题
接口要返回给前端（js）一个比较长的数字：759830849237899244

看了接口返回是没问题的，但是前端拿着数字去取详情的时候，传过来的是另外一个数字：759830849237899300

一比较，看起来是数字被转换了

759830849237899244 => 759830849237899300

在前端控制台执行一下：

果然被转成了另外一个数字，而且看规律很像是后三位被上取整了

原理

后来了解到js会将数字按照下图方式切分后表示数字，以至于最高表示的数字只能到 9007199254740991 比这个数字更大的数字就会发生进位溢出

解决方案

解决方案很好办，那就是将数字转成字符串，只要前端不强转成数字，那就不会出问题

参考文档

JSON Bigint 大数精度丢失的背后

JSON.parse parses / converts big numbers incorrectly

golang-cobra

2024-12-31T02:27:43.000Z

golang-cobra

简介

cobra 可以帮助快速构建命令行程序

用法

快速搭建脚手架

安装cobra-cli

go install github.com/spf13/cobra-cli@latest

在一个已有的代码库中，使用 cobra-cli init 可以初始化一个代码库，然后执行 go run main.go 会展示出当前支持的命令
初始化之后的目录结构如下所示：

  ▾ app/
    ▾ cmd/
        root.go
      main.go

新增命令

cobra-cli add serve
cobra-cli add config
cobra-cli add create -p 'configCmd'

细节安装后查看

命令代码编写

以我的一个代码上传开发机的小程序为例： https://github.com/wudanyang6/simple-file-sync.git
我增加了两个命令，一个是client一个是server

拿简单点的 server 来看：

var serverCmd = &cobra.Command{  
    Use:   "server --port",  
    Short: "server for simple file sync",  
    Long:  `A server for simple file sync. For example: simple-file-sync server `,  
    Run: func(cmd *cobra.Command, args []string) {  
       server.NewServer(ServerPort, ServerToken, ServerLimitDir).Start()  
    },  
}

Use 这里代表应该在主命令后面写什么才能运行子命令
Short & Long 代表子命令的描述
Run 是真正的代码逻辑，我一般习惯将逻辑写在其他包里面，这里只做命令初始化

参数传递

参数传递非常方便，并且使用 spf13 大神的 pflag 包，长短命令形式都支持

serverCmd.Flags().IntVar(&ServerPort, "port", 8120, "port to listen on")  
serverCmd.Flags().StringVar(&ServerToken, "token", serverToken, "token for authentication")

效果

-h 命令

$ simple-file-sync server -h
A server for simple file sync. For example: simple-file-sync server

Usage:
  simple-file-sync server --port [flags]

Flags:
  -h, --help               help for server
      --limit-dir string   You can’t upload to anything other than the limit-dir folder, default is your home directory (default "/your/homeDir")
      --port int           port to listen on (default 8120)
      --token string       token for authentication (default "kfcvme50")

执行效果：

$ simple-file-sync server   
2024/12/31 10:26:34 Starting server at port 8120...
2024/12/31 10:26:34 Limit directory:  /Users/wudanyang
2024/12/31 10:26:34 Token:  kfcvme50

参考

官方库：spf13/cobra: A Commander for modern Go CLI interactions
cobra 库介绍：Go 每日一库之 cobra - 大俊的博客
 cobra-cli/README.md at main · spf13/cobra-cli

go-时间处理

2025-02-13T05:03:59.000Z

go-时间处理

golang carbon 库的使用

Golang 中的 Carbon 库是一个用于处理日期和时间的强大工具，它提供了丰富的功能来简化时间操作。Carbon 库的设计灵感来源于 PHP 的 Carbon 库，但在 Go 语言中进行了优化和扩展，使其更适合 Go 的编程风格和需求。

首先，Carbon 库可以帮助开发者轻松地解析、格式化和操作日期和时间。例如，你可以使用 carbon.Parse 函数来解析字符串格式的日期，并将其转换为 Carbon 对象。这个对象可以进一步用于计算时间差、添加或减去时间间隔等操作。例如，你可以使用 carbon.Now().AddDays(5) 来获取当前时间五天后的日期。

其次，Carbon 库支持多种时间格式的转换和比较。你可以使用 carbon.Format 函数将时间对象格式化为指定的字符串格式，如 YYYY-MM-DD HH:mm:ss。此外，Carbon 还提供了 carbon.DiffInDays、carbon.DiffInHours 等函数来计算两个时间点之间的差异。例如，你可以轻松计算两个日期之间相差的天数或小时数。

Carbon 库还支持时区处理，这对于处理跨时区的应用程序尤为重要。你可以使用 carbon.SetTimezone 函数来设置时区，确保时间操作在不同时区下保持一致。例如，如果你需要处理一个全球用户的应用程序，Carbon 可以帮助你轻松地将时间转换为用户所在的时区。

此外，Carbon 库还提供了丰富的工具来处理时间的常见操作，如获取当前时间的开始或结束时间、判断某一天是星期几、计算某个月的天数等。例如，你可以使用 carbon.StartOfDay 来获取某一天的开始时间，或者使用 carbon.IsWeekend 来判断某一天是否是周末。

总的来说，Golang 中的 Carbon 库是一个功能强大且易于使用的工具，特别适合需要频繁处理日期和时间的应用程序。无论是简单的日期格式化，还是复杂的时间计算，Carbon 都能提供简洁而高效的解决方案。通过合理使用 Carbon 库，开发者可以显著减少时间处理相关的代码量，并提高代码的可读性和可维护性。

官网的示例也非常丰富

import "github.com/golang-module/carbon/v2"

func main() {
	cTime := carbon.SetTimezone(carbon.Shanghai)  
	// 获取明天凌晨0点的时间戳
	tomorrowUnixTime := cTime.Tomorrow().StartOfDay().Timestamp()  
	// 获取当前时间的时间戳
	currentUnixTime := cTime.Now().Timestamp()  
	fmt.Println(tomorrowUnixTime, currentUnixTime)
}

Reference

https://github.com/golang-module/carbon

go-mod

2024-04-20T14:38:10.000Z

go-mod

module novel-spider  
  
go 1.16  
  
require (  
   github.com/antchfx/xpath latest  
)

replace (
    golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a => github.com/golang/crypto v0.0.0-20190313024323-a1f597ede03a
)

module 当前包的名字

require 指定依赖项，跟 go-import 很像

replace 无法自动获取的资源，可以使用 replace 来用本地资源替代

参考： https://www.jianshu.com/p/760c97ff644c

go mod init [模块名]
go mod tidy

go-gorm-FindInBatches

2024-10-21T04:44:45.000Z

go-gorm-FindInBatches

FindInBatches 用于简化批量操作，防止数据量及过大导致超时

	var accountSlice []ainote.UserOnline
	t.DB.Where("deleted = ?", ainote.UnDeleted).
		Where("status = ?", ainote.Available).
		FindInBatches(&accountSlice, 5, func(tx *gorm.DB, batch int) error {
			resource.LoggerService.Debug(ctx, "debug-wdy", logit.AutoField("data", batch))

			totalCnt += int64(len(accountSlice))
			resource.LoggerService.Debug(ctx, "debug-wdy", logit.AutoField("data", accountSlice))

			// 遍历所有账号，计算其他数据
			for _, v := range accountSlice {
				intervalOfThisAccount := 72000 / v.Bound
				availableUseCnt := (tomorrowUnixTime - currentUnixTime) / int64(intervalOfThisAccount)

				totalRemainCnt += int64(v.Remains)
				AvailableAccountUseCnt += availableUseCnt

				if v.Remains > 0 && v.AvailableTime < tomorrowUnixTime {
					availableAccountCnt++
				}
			}

			return nil
		})

FindInBatches 是 GORM 中的一个函数，用于分批处理记录，避免一次性加载所有数据导致内存占用过高，特别适合处理大数据集。

1 语法：

func (tx *DB) FindInBatches(dest interface{}, batchSize int, fc func(tx *DB, batch int) error) *DB

dest: 目标，查询结果会扫描到这个变量中。
batchSize: 每批处理的记录数量。
fc: 每批处理时执行的回调函数，参数包括当前事务 tx 和当前批次号 batch。

2 示例：

type User struct {
    ID   uint
    Name string
}

var users []User
result := db.Model(&User{}).Where("active = ?", true).FindInBatches(&users, 100, func(tx *gorm.DB, batch int) error {
    fmt.Printf("处理第 %d 批数据\n", batch)
    for _, user := range users {
        // 处理每个用户
    }
    return nil
})

if result.Error != nil {
    fmt.Println(result.Error)
}

3 工作原理：

目标 (users)：查询结果会存储在这个切片中，每批的数据会覆盖前一批的数据。
批量大小 (100)：定义每次处理的记录数量。
处理函数 (func)：这个函数会在每批数据处理时调用，允许你对每批数据进行操作。

这种方式非常适合处理大数据，避免一次性加载过多数据占用内存，并且能够分批次地进行处理。

go-exec

2024-03-13T07:53:18.000Z

go-exec

在Go语言中，exec 包提供了执行外部命令的功能。这个包是标准库的一部分，允许你从Go程序中运行外部的系统命令和程序。使用这个包，你可以执行Shell命令，处理命令的输入输出，以及访问命令的返回状态。

下面是如何使用 exec 包执行Shell命令的一些基本步骤和示例。

1. 导入exec包

在你的Go文件中，首先需要导入os/exec包。

import "os/exec"

2. 创建命令

使用exec.Command函数创建一个新的*exec.Cmd对象，该对象用于执行外部命令。这个函数的第一个参数是命令名称，后续参数是命令需要的参数。

cmd := exec.Command("echo", "Hello, World!")

如果你需要执行的命令需要Shell特性（比如管道、文件重定向等），你可以通过在Shell中执行命令来实现。例如，在Unix系统中，可以使用bash的-c选项。

cmd := exec.Command("bash", "-c", "ls -l | grep .go")

3. 运行命令

有几种方法可以用来运行命令并获取输出。

go-exec-run

Run：运行命令，并等待命令完成。

err := cmd.Run()
if err != nil {
    log.Fatalf("cmd.Run() failed with %s\n", err)
}

Output：运行命令，并收集命令的标准输出。

out, err := cmd.Output()
if err != nil {
    log.Fatal(err)
}
fmt.Printf("The output is %s\n", out)

CombinedOutput：运行命令，并收集标准输出和标准错误。

out, err := cmd.CombinedOutput()
if err != nil {
    log.Fatal(err)
}
fmt.Printf("The combined output is %s\n", out)

Start 和 Wait：Start 开始执行命令但不等待它完成，Wait 等待命令完成。

err := cmd.Start()
if err != nil {
    log.Fatal(err)
}

err = cmd.Wait()
if err != nil {
    log.Fatal(err)
}

4. 处理命令的输入输出

你可以通过设置Cmd结构体的Stdin、Stdout、Stderr属性来处理命令的输入输出。

cmd.Stdin = strings.NewReader("some input")
var out bytes.Buffer
cmd.Stdout = &out
err := cmd.Run()
if err != nil {
    log.Fatal(err)
}
fmt.Printf("The output is %s\n", out.String())

5. 获取命令的返回状态

命令的返回状态可以通过检查Run、Output或CombinedOutput方法返回的错误来获取。如果命令以非零状态退出，这些方法会返回一个*exec.ExitError类型的错误。

if exitErr, ok := err.(*exec.ExitError); ok {
    // 这里可以获取到非零退出状态和更多信息
    fmt.Printf("Command exited with status %d\n", exitErr.ExitCode())
}

总结

通过Go的exec包，你可以方便地执行外部命令和处理Shell命令。这对于需要与系统层面交互的程序来说非常有用。记得总是仔细处理命令的输出和错误，以及考虑安全性，避免执行不受信任的命令。

Reference

go-exec-run

2024-03-22T10:43:31.000Z

go-exec-run

Run 和 Wait 都是 os/exec 包中 Cmd 结构体的方法，用于执行外部命令，但它们在执行方式上有一些关键的区别。

Run 方法

Run 方法会启动外部命令，等待它完成，并返回一个错误值。如果命令成功执行（即退出状态为0），Run 返回 nil。如果命令执行失败（比如命令不存在，或者执行过程中出现了错误），则返回一个非 nil 的错误值。

Run 是一个阻塞调用，意味着它会阻塞当前的 Goroutine 直到外部命令执行完成。它实际上是 Start 和 Wait 方法的组合。首先，Run 调用 Start 方法来启动命令，然后立即调用 Wait 方法等待命令执行结束。

cmd := exec.Command("echo", "Hello, World!")
err := cmd.Run()
if err != nil {
    log.Fatalf("cmd.Run() failed with %s\n", err)
}

Wait 方法

Wait 方法会阻塞调用它的 Goroutine，直到 Cmd 表示的命令执行完成。它必须在 Start 方法之后调用。Start 方法启动命令但不等待它结束，这使得你可以在命令执行的同时做一些其他的事情（比如读取命令的输出）。一旦你准备好等待命令执行完成，就可以调用 Wait 方法。

如果命令成功执行，Wait 返回 nil。如果执行失败，则返回一个非 nil 的错误值。

使用 Start 和 Wait 的组合，你可以更灵活地控制命令的执行过程。

cmd := exec.Command("echo", "Hello, World!")
err := cmd.Start()
if err != nil {
    log.Fatal(err)
}

err = cmd.Wait()
if err != nil {
    log.Fatal(err)
}

区别总结

Run 是一个便利的方法，用于当你只需要简单地执行一个命令并等待它完成时。它是 Start 和 Wait 的组合。
使用 Start 和 Wait 可以让你在命令执行的同时做一些其他的处理，比如并发地处理命令的输出。这提供了更高的灵活性，但也需要你手动管理命令的启动和完成等待。

选择使用哪一个方法取决于你的具体需求和你想要的控制级别。对于大多数简单的用例，Run 方法可能就足够了。但如果你需要更细粒度的控制，比如并发处理命令的输出，那么使用 Start 和 Wait 的组合可能更合适。

Reference

go- make 和 new 关键字的区别

2024-10-12T02:13:32.000Z

go- make 和 new 关键字的区别

1 make 和 new 关键字的区别

1.1 new

Go语言中 new 和 make 是两个内置函数，主要用来创建并分配类型的内存。在我们定义变量的时候，可能会觉得有点迷惑，不知道应该使用哪个函数来声明变量，其实他们的规则很简单，new 只分配内存，而 make 只能用于 slice、map 和 channel 的初始化

// The new built-in function allocates memory. The first argument is a type,
// not a value, and the value returned is a pointer to a newly
// allocated zero value of that type.
func new(Type) *Type

new 关键字分配内存，返回指向此内存的指针，并且内存值为此类型的 零值

这就是 new 函数，它返回的永远是类型的指针，指针指向分配类型的内存地址。

1.2 make

make 也是用于内存分配的，但是和 new 不同，它只用于 chan、map 以及 slice 的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。

Go语言中的 new 和 make 主要区别如下：

make 只能用来分配及初始化类型为 slice、map、chan 的数据。new 可以分配任意类型的数据；
new 分配返回的是指针，即类型 *Type。make 返回引用，即 Type；
new 分配的空间被清零。make 分配空间后，会进行初始化；

go 获取凌晨0点的时间戳

2025-02-18T12:15:16.000Z

go 获取凌晨0点的时间戳

ti := time.Now()  
yy, mm, dd := ti.AddDate(0, 0, 1).Date() // 可选的 
ti = time.Date(yy, mm, dd, 0, 0, 0, 0, ti.Location())
fmt.Println(ti.Unix())

使用 carbon 库

package main

import (
	"fmt"
	"time"

	"github.com/uniplaces/carbon"
)

func main() {
	// 获取当前时间的carbon对象
	now := carbon.Now()

	// 找到今天凌晨0点的时间
	startOfDay := now.StartOfDay()

	// 输出凌晨0点的时间戳
	fmt.Println("Midnight Timestamp:", startOfDay.Unix())
}

202506061308 vscode There is no formatter for 'go' files installed 报错处理

2025-06-06T05:08:59.000Z

202506061308 vscode There is no formatter for 'go' files installed 报错处理

There is no formatter for 'go' files installed.

[!NOTE]
What is the output of go version and go env? Also, can you run the Go: Locate Configured Go Tools command from the Command Palette (Ctrl+Shift+P) and share its output?
The "Error: TypeError: Cannot read property 'lt' of undefined" error might indicate that the extension is not finding your go version.

There is no formatter for 'go' files installed. · Issue #633 · golang/vscode-go

202407251323 go flag 别在init中使用

2024-08-12T06:32:51.000Z

202407251323 go flag 别在init中使用

flag.StringVar(&appConfig, "conf", filepath.Join(env.ConfDir(), "app.toml"), "app config file")
flag.Parse()

flag 别在 init 中使用，否则在 go test 的时候会强制校验入参

参考：
go test flag: flag provided but not defined

flag.Parse() is being called before your flag is defined.
You have to make sure that all flag definitions happen before calling flag.Parse(), usually by defining all flags inside init() functions.

202405061043 go 抽象的一个例子

2024-10-21T08:55:53.000Z

202405061043 go 抽象的一个例子

Go 语言的标准库 database/sql 是一个抽象层的经典例子
虽然关系型数据库的功能相对比较复杂
但是我们仍然可以通过定义一系列构成树形结构的接口提供合理的抽象
这也是我们在编写框架和中间层时应该注意的
即面向接口编程 —— 只依赖抽象的接口，不要依赖具体的实现。

docker 和 Kubernetes 的异同

2024-10-21T08:52:55.000Z

docker 和 Kubernetes 的异同

Docker 和 Kubernetes 是两个不同的技术，但它们可以一起使用来构建和管理容器化应用程序。下面是 Docker 和 Kubernetes 的异同：

异同点：

目的不同：Docker 是一种容器化技术，用于打包和部署应用程序。Kubernetes 是一种容器编排平台，用于管理和编排容器化应用程序。
架构不同：Docker 是一个单节点容器引擎，而 Kubernetes 是一个分布式系统，由多个节点组成。
功能不同：Docker 提供容器的构建、打包、发布和运行等功能。Kubernetes 提供容器编排、自动扩展、负载均衡、服务发现等功能。
使用场景不同：Docker 适用于单个应用程序或微服务的部署。Kubernetes 适用于多个应用程序或微服务的管理和编排。
学习成本不同：Docker 学习成本较低，容易上手。Kubernetes 学习成本较高，需要掌握更多的概念和技术。
部署方式不同：Docker 可以直接在本地或云端部署。Kubernetes 需要在集群中部署，需要更多的配置和管理。
可扩展性不同：Docker 可以扩展到多个节点，但需要手动管理。Kubernetes 可以自动扩展和管理多个节点。

相同点：

都是容器化技术，用于构建和部署应用程序。
都支持多种编程语言和框架，如 Java、Python、Node.js 等。
都可以在本地或云端部署。
都可以提高应用程序的可移植性和可伸缩性。

驾驶证期满换证

2024-11-16T14:48:39.000Z

12123 APP 中申请 期满换证

驾驶证期满换证

http://jtgl.beijing.gov.cn/jgj/lszt/659722/10936724/10936732/10937472/index.html#:~:text=办理渠道：“交管12123”APP&text=如自取，则需,需填写收件地址。&text=取件方式确认后,证业务申请信息提交。

费曼技巧

2024-10-21T11:13:44.000Z

费曼技巧

一种有目标的学习技巧，适用于学习【是什么】这类知识

步骤

确定学习目标
寻找资料（网络、书籍、报刊等）学习"费曼技巧"，直到自己认为已经理解了"费曼技巧"，想象现在要给一个完全没有听说过"费曼技巧"的人，记下来所要讲解的内容。
在记下内容的时候，会发现有很多讲不通的地方，那么需要重复第2步骤直到通顺。
简化自己的描述

原理

温故而知新，可以为师矣
从被动到主动的状态
回忆知识，可以加固神经回路

202408312248 甲沟炎的处理办法

2025-02-08T03:14:51.000Z

202408312248 甲沟炎的处理办法

去修脚店：有的店承诺修好，费用会贵一些，但是后续修就不要钱了，在北京顺义这边大概一只脚趾需要600块钱。我是两个大拇脚趾，当时应该花了1200，后续一两年内去了很多次，没有另收费。在这之前我去过很多次其他的店，每次修脚都需要一二百块钱。
去医院拔掉：去过一次医院，医生不建议拔掉，因为拔掉不能保证以后新长出来的不会出现甲沟炎，并且恢复期很长。医生建议是买点消炎的药，等趾甲顶出来以后就好了。我的趾甲太硬，等了一个月，除了疼之外，没有见半点能顶出来的迹象，所以又去了修脚店清理掉了。
后来突发奇想，在网上买了一个指甲锉，每次疼了就用这个指甲锉磨一磨，竟然神奇的没有再去过修脚店，而且左边的趾甲经过我的良好引导已经不往肉里长了。
有需要的可以试试： https://item.jd.com/100015138940.html

2025-02-08 更新：
2025年春节前，因为某次忘了带指甲锉，便使用普通指甲剪剪了一次，导致春节期间右脚大拇指内侧肿成灯笼。
后来使用指甲锉磨完上了云南白药，几天后消肿了。

获取进程存活时间

2024-04-18T04:54:33.000Z

ps -eo lstart,pid,cmd | grep "php-fpm: pool www" | grep -v 'grep'

要在 Linux 中获取子进程的存活时间（以 Unix 时间戳的形式表示），可以使用以下步骤：

获取子进程的 PID。
访问 /proc/<PID>/stat 文件，其中 <PID> 是子进程的 PID。
从 /proc/<PID>/stat 文件中读取进程的启动时间（start_time），该值以时钟滴答数（clock ticks）的形式存储在第 22 列中。
获取系统的时钟滴答数，可以使用 getconf CLK_TCK 命令。
将进程的启动时间除以时钟滴答数，以获取进程的存活时间（单位为秒），然后将其添加到系统启动时间的 Unix 时间戳（即系统启动的时间，以秒为单位）中，即可得到子进程的存活时间（以 Unix 时间戳的形式表示）。

以下是获取子进程存活时间的 Unix 时间戳的示例命令：
# 获取进程存活时间
PID=<子进程的 PID>

# 获取进程的启动时间（以时钟滴答数的形式存储）
START_TIME=$(awk '{print $22}' /proc/${PID}/stat)

# 获取系统的时钟滴答数
CLK_TCK=$(getconf CLK_TCK)

# 计算进程的存活时间（以秒为单位）
UPTIME=$((($(awk '{print $1}' /proc/uptime) - ${START_TIME} / ${CLK_TCK})))

# 计算子进程的存活时间（以 Unix 时间戳的形式表示）
CHILD_UPTIME=$(( $(date +%s) - ${UPTIME} ))

echo "子进程的存活时间为：${CHILD_UPTIME} 秒（Unix 时间戳形式）"

注意，这个方法获取的存活时间不是绝对准确的，因为在读取进程的启动时间和计算子进程的存活时间期间，进程的存活时间可能会发生变化。

参考

文件描述符

2025-01-28T14:10:23.000Z

文件描述符

对于内核而言，所有打开的文件都通过文件描述符（file descriptor）引用。通常也写作 fd。

文件描述符是一个非负整数。

当打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。

文件描述符是跟进程相关联的。

按照惯例，UNIX 系统将 fd 0 对应进程的标准输入， fd 1 对应进程的标准输出， fd 2 对应进程的标准错误。

系统调用中的文件描述符

UNIX 系统中，一切皆文件，所以一切资源都可以使用文件描述符进程引用。

以 open 系统调用为例

使用 man 2 open 查看系统 man 手册

NAME
     open, openat -- open or create a file for reading or writing

SYNOPSIS
     #include <fcntl.h>

     int
     open(const char *path, int oflag, ...);

     int
     openat(int fd, const char *path, int oflag, ...);

DESCRIPTION
     The file name specified by path is opened for reading and/or writing,
     as specified by the argument oflag; the file descriptor is returned to
     the calling process.

在简介中有一段话：the file descriptor is returned to the calling process.

使用 c 语言打开一个文件

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
	int fd;
	fd = open("tmp.txt", O_RDONLY);
	printf("%d", fd);
	sleep(10);
}

会发现，在进程运行时 fd 目录下，会出现一个描述符 3 指向了打开的文件

$ ll /proc/$(ps aux | grep a.out | grep -v grep | awk '{print $2}')/fd
total 0
lrwx------ 1 ubuntu ubuntu 64 Apr 13 13:48 0 -> /dev/pts/4
lrwx------ 1 ubuntu ubuntu 64 Apr 13 13:48 1 -> /dev/pts/4
lrwx------ 1 ubuntu ubuntu 64 Apr 13 13:48 2 -> /dev/pts/4
lr-x------ 1 ubuntu ubuntu 64 Apr 13 13:48 3 -> /home/ubuntu/mydisk/yangblog/codes/file/tmp.txt

我们可以把这个文件描述符当做参数传递给 read 或者 write 等等系统调用。

使用shell脚本快速并行启动指定数量的进程

2025-02-18T14:06:12.000Z

使用shell脚本快速并行启动指定数量的进程

shell 脚本提升速度

i=0
while true;do
    # 此文件里面可以放同时执行的数量
    mod=$(cat process_count.plain.txt)

    # 并行执行数量, 默认为3个进程执行
    if [ -z "$mod" ]; then
        mod=3
    fi

    if [ $((i % mod)) -eq "0" ]; then
        echo "running $i"
	    # 关键在这里，需要等待上一批脚本执行完成
        wait
    fi
    
    nohup sh your_script.sh >> your_script_${i}.log 2>&1 &

    ((i++))
done

linux-wait

什么是 mdns

2024-10-12T14:56:45.000Z

什么是 mdns

MultiCast Dns 多播 dns 协议
使用 5353 端口进行通信
默认情况下，只解析 .local 顶级域名

参考

在局域网建立.local域名

百度百科-mdns

ubuntu-unminimize

2024-10-19T04:24:31.000Z

ubuntu-unminimize

unminimize 命令可以将 ubuntu 的环境切换成正常的环境，会安装很多软件进去

https://wiki.ubuntu.com/Minimal

The 'unminimize' command will install the standard Ubuntu Server packages if you want to convert a Minimal instance to a standard Server environment for interactive use.

但是这些软件里面没有 ping 、 traceroute 等网络实用工具

shell替换字符串

2024-10-21T08:58:59.000Z

# shell替换字符串
${hellohe/he/ae}

# 全局替换，多了一个斜杠
${hellohe//he/ae}

# sed 命令， 后面修饰的 g 代表全局替换，否则只替换第一个
echo "hellohe" | sed 's/he/ae/g'

#  awk 的函数
echo "hellohe" | awk '{gsub(/he/, "ae"); print $0}'

参考

linux shell 替换字符串的几种方法，变量替换${}，sed，awk_whatday的博客-CSDN博客_shell 字符串替换

替换文本

每一行最后添加一个逗号
sed -e 's/$/,/'

shell-生成随机数

2024-10-20T15:57:33.000Z

shell-生成随机数

变量范围是：[0, 32767] echo $RANDOM

[!NOTE]
RANDOM Each time this parameter is referenced, it expands to a
random integer between 0 and 32767. Assigning a value to
RANDOM initializes (seeds) the sequence of random numbers.
If RANDOM is unset, it loses its special properties, even
if it is subsequently reset.

在 Linux 的 Bash 脚本中，$RANDOM 是一个特殊的变量，它用于生成一个随机整数。每次引用 $RANDOM 时，它都会返回一个介于 0 到 32767 之间的随机数。这个变量是由 Bash 内置的，不需要任何外部程序或模块支持。

以下是一些使用 $RANDOM 的常见方式：

生成随机数：
```
echo $RANDOM
```
这将输出一个 0 到 32767 之间的随机整数。
生成特定范围内的随机数：
如果你想要生成一个在特定范围内的随机数，可以使用算术扩展。例如，生成一个 1 到 10 之间的随机数：
```
echo $((RANDOM % 10 + 1))
```
这里，% 是取模运算符，用于得到除法的余数，+ 1 是为了将范围从 0 到 9 调整为 1 到 10。
在循环中使用：
你可以在循环中使用 $RANDOM 来生成一系列随机数：
```
for i in {1..5}
do
    echo $((RANDOM % 100))
done
```
这将输出 5 个 0 到 99 之间的随机数。
生成随机选择：
你可以通过比较 $RANDOM 和一个上限值来随机选择一个选项：
```
choice=$((RANDOM % 2))
if [ $choice -eq 0 ]; then
    echo "Heads"
else
    echo "Tails"
fi
```
这将随机输出 "Heads" 或 "Tails"。

请注意，虽然 $RANDOM 可以用于简单的随机数生成需求，但它并不适用于需要高质量随机性的场景，比如密码生成或加密应用。对于这些场景，你可能需要使用更专业的随机数生成器，如 /dev/urandom 或 /dev/random 设备，或者使用其他编程语言提供的加密安全的随机数生成函数。

bash(1) - Linux manual page

shell-循环

2024-09-09T05:32:31.000Z

shell-循环

for


# 遍历数字
for i in {0..10}; do
    echo 133
done

# 遍历文件
for file in split_??????; do
    echo ${file}
done

# 数组：
arr=(list0 list1 list2 list3)

# 遍历数组
for list in ${arr[@]}; do
	echo ${list}
done

while

while read line; do
    echo $line
done < file.txt

shell 命令，替换逗号为tab符号

2024-10-21T08:59:49.000Z

shell 命令，替换逗号为tab符号

#shell #linux

cat daily_pushed_data_ori  | grep -v error | sed 's/,/\t/g' > daily_pushed_data

参考：
shell替换字符串

linux-查看内存占用情况

2024-02-02T04:07:52.000Z

linux-查看内存占用情况

ps --no-headers -o "rss,cmd" -A | awk '{print $1/1024"M","\t",$0}' | sort -n -k1

linux-什么是anon_inode

2025-06-21T15:17:40.000Z

无法和文件系统的 inode 关联上的文件描述符，在 /proc 系统中统称为 anon_inode

linux-什么是anon_inode

https://unix.stackexchange.com/questions/463548/what-is-anon-inode-in-the-output-of-ls-l-proc-pid-fd

linux-wrk

2025-03-13T08:47:19.000Z

linux-wrk

wrk 是一个压测工具，底层使用 epoll ，多线程执行，性能非常好

使用说明：

安装：

git clone https://github.com/wg/wrk 

make
cp wrk /usr/local/bin

示例用法：

wrk -t12 -c400 -d30s http://127.0.0.1:8080/index.html

参数含义：

Usage: wrk <options> <url>
  Options:
    -c, --connections <N>  Connections to keep open
    -d, --duration    <T>  Duration of test
    -t, --threads     <N>  Number of threads to use

    -s, --script      <S>  Load Lua script file
    -H, --header      <H>  Add header to request
        --latency          Print latency statistics
        --timeout     <T>  Socket/request timeout
    -v, --version          Print version details

  Numeric arguments may include a SI unit (1k, 1M, 1G)
  Time arguments may include a time unit (2s, 2m, 2h)

示例 lua 脚本文件位置

/workspace/wrk/scripts/*.lua

-- example HTTP POST script which demonstrates setting the
-- HTTP method, body, and adding a header

wrk.method = "POST"
wrk.body   = "foo=bar&baz=quux"
wrk.headers["Content-Type"] = "application/x-www-form-urlencoded"

wrk lua 函数的生命周期

参考

http 性能测试 wrk使用教程

性能测试神器 wrk 使用教程

linux-wait

2025-02-18T14:05:49.000Z

linux-wait

for pid in $(jobs -p); do
    wait $pid
    status=$?
    if [ $status != 0 ]; then
        echo " $pid status is $status have some error!" >> your_log
    else
        echo "$pid status is $status success!" >> your_log
    fi
done

Reference

wait(1p) - Linux manual page

linux-top

2025-01-26T16:00:18.000Z

linux-top

Help for Interactive Commands - procps-ng UNKNOWN
Window 1:Def: Cumulative mode Off.  System: Delay 3.0 secs; Secure mode Off.

  Z,B,E,e   Global: 'Z' colors; 'B' bold; 'E'/'e' summary/task memory scale
  l,t,m     Toggle Summary: 'l' load avg; 't' task/cpu stats; 'm' memory info
  0,1,2,3,I Toggle: '0' zeros; '1/2/3' cpus or numa node views; 'I' Irix mode
  f,F,X     Fields: 'f'/'F' add/remove/order/sort; 'X' increase fixed-width

  L,&,<,> . Locate: 'L'/'&' find/again; Move sort column: '<'/'>' left/right
  R,H,J,C . Toggle: 'R' Sort; 'H' Threads; 'J' Num justify; 'C' Coordinates
  c,i,S,j . Toggle: 'c' Cmd name/line; 'i' Idle; 'S' Time; 'j' Str justify
  x,y     . Toggle highlights: 'x' sort field; 'y' running tasks
  z,b     . Toggle: 'z' color/mono; 'b' bold/reverse (only if 'x' or 'y')
  u,U,o,O . Filter by: 'u'/'U' effective/any user; 'o'/'O' other criteria
  n,#,^O  . Set: 'n'/'#' max tasks displayed; Show: Ctrl+'O' other filter(s)
  V,v     . Toggle: 'V' forest view; 'v' hide/show forest view children

  k,r       Manipulate tasks: 'k' kill; 'r' renice
  d or s    Set update interval
  W,Y       Write configuration file 'W'; Inspect other output 'Y'
  q         Quit
          ( commands shown with '.' require a visible task display window )
Press 'h' or '?' for help with Windows,
Type 'q' or <Esc> to continue

常用指令

m 显示内存信息，可以显示成内存条

x：高亮显示排序字段

z：彩色显示各个区域

R：反向排序

<：排序字段左移

>：排序字段右移

zx 打开高亮显示排序字段

可以看到，默认是按照 cpu 使用率排序的

> 可以移到内存使用率排序

存储到文件

top -c -b -n 10000 -d 3 >>top.txt

字段含义

top 字段的含义
https://www.cnblogs.com/zhoug2020/p/6336453.html

linux-pidstat

2024-10-24T15:44:35.000Z

linux-pidstat

$pidstat 1 5                                                                                                                                                         11:46
Linux 5.4.0-1034-raspi (wdy-ubuntu) 	05/20/21 	_aarch64_	(4 CPU)

11:46:13      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
11:46:14        0      1871    0.00    0.97    0.00    0.00    0.97     3  phtunnel
11:46:14     1000      4506    0.97    0.00    0.00    0.00    0.97     0  gsd-xsettings
11:46:14     1000    115573    0.97    2.91    0.00    0.00    3.88     1  pidstat

11:46:14      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
11:46:15     1000    115573    0.00    4.00    0.00    0.00    4.00     1  pidstat

11:46:15      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
11:46:16     1000      4747    1.00    0.00    0.00    0.00    1.00     2  gnome-software
11:46:16        0    115462    0.00    1.00    0.00    0.00    1.00     2  kworker/2:1-events
11:46:16     1000    115573    1.00    3.00    0.00    0.00    4.00     1  pidstat

11:46:16      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
11:46:17        0     93708    0.00    1.00    0.00    0.00    1.00     2  containerd
11:46:17     1000    115573    1.00    3.00    0.00    0.00    4.00     1  pidstat

11:46:17      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
11:46:18     1000    115573    1.00    2.00    0.00    0.00    3.00     1  pidstat

Average:      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
Average:        0      1871    0.00    0.20    0.00    0.00    0.20     -  phtunnel
Average:     1000      4506    0.20    0.00    0.00    0.00    0.20     -  gsd-xsettings
Average:     1000      4747    0.20    0.00    0.00    0.00    0.20     -  gnome-software
Average:        0     93708    0.00    0.20    0.00    0.00    0.20     -  containerd
Average:        0    115462    0.00    0.20    0.00    0.00    0.20     -  kworker/2:1-events
Average:     1000    115573    0.80    2.98    0.00    0.00    3.78     -  pidstat

pidstat 是 sysstat 工具包的一部分，可以用来监控特定进程的 CPU、内存、I/O 等使用情况。与其他命令不同，pidstat 提供了针对单个进程级别的统计信息，非常适合分析某个进程的性能表现。

1 安装 `pidstat`

pidstat 属于 sysstat 工具包。如果尚未安装，可以使用以下命令进行安装：

sudo apt-get install sysstat  # 对于 Debian/Ubuntu
sudo yum install sysstat      # 对于 CentOS/RHEL

2 使用 `pidstat` 查看 CPU 使用情况

要查看所有进程的 CPU 使用情况，可以使用：

pidstat 1

其中，1 表示每秒刷新一次 CPU 使用情况。输出示例：

Linux 4.15.0-20-generic (hostname)   09/19/2024  _x86_64_  (4 CPU)

09:26:35      PID    %usr %system  %guest   %CPU   CPU  Command
09:26:36     1023    0.00    0.50    0.00    0.50     1  apache2
09:26:36     1234    0.20    0.30    0.00    0.50     0  chrome

输出中的各列解释：

%usr：用户态 CPU 使用率。
%system：系统态 CPU 使用率。
%CPU：总 CPU 使用率。
PID：进程 ID。
Command：进程名称。

3 查看特定进程的 CPU 使用情况

如果想监控某个特定进程，比如 PID 为 1234 的进程，可以使用：

pidstat -p 1234 1

4 查看线程级别的 CPU 使用情况

要查看进程中的每个线程的 CPU 使用情况，可以使用 -t 参数：

pidstat -t 1

这样可以分析多线程程序的性能表现。

5 查看内存和 I/O 使用情况

pidstat 还可以查看进程的内存和 I/O 使用情况：

查看内存使用情况：

pidstat -r 1

查看 I/O 使用情况：

pidstat -d 1

pidstat 是一个强大的工具，适合监控和分析单个进程的资源使用情况。

参考

https://time.geekbang.org/column/article/70476

linux-man命令使用

2024-09-13T12:08:00.000Z

linux-man命令使用

1 - commands（普通的命令）
2 - system calls（系统调用）

3 - library calls（库函数）
4 - special files（特殊文件：/dev下设备文件）
5 - file formats and convertions（文件格式）

6 - games for linux（游戏和娱乐）
7 - macro packages and conventions（杂项）
8 - system management commands（管理员命令）
9 - 其他（Linux特定，用来存放内核例行程序的文档）

可使用 man man 进入此页面

参考

https://blog.csdn.net/zhang_chou_chou/article/details/83589224

在线 man 手册

linux-echo

2024-10-20T15:59:24.000Z

linux-echo

echo "hello"

echo -n "hello" # 这种会去掉换行

sh 不支持这个 -n 参数，很奇怪

$ echo -n "hello"
hello%

使用 -n 参数 zsh 后面会跟着一个百分号

Printf puts a percent sign after everything it prints

This is zsh's way of telling you that the preceding command outputted a partial line and the shell terminated that line to give you a prompt on a new line.

linux-dnsmasq

2024-10-21T08:52:22.000Z

linux-dnsmasq

whatis dnsmasq
dnsmasq (8)          - A lightweight DHCP and caching DNS server.

一个 dns 缓存

Dnsmasq是一个轻量级的、易于配置的DNS转发器和DHCP服务器。它适用于小型网络，可以提供DNS缓存和BOOTP/TFTP服务，以帮助网络引导基于网络的操作系统。

Dnsmasq具有以下主要作用：

DNS 转发与缓存： Dnsmasq可以接受DNS查询并将其转发至网络中配置的真实DNS服务器，同时将查询结果缓存起来，提高网络访问速度。
DHCP 服务器： Dnsmasq可以作为一个DHCP服务器，为网络设备分配IP地址。
TFTP 服务器： Dnsmasq还可以提供TFTP服务，为网络启动的设备提供所需文件。

Dnsmasq的主要应用场景是：

小型网络和家庭网络： 对于小型网络和家庭网络，通常无需专门的DNS和DHCP服务器，Dnsmasq就可以满足需求，省去配置和维护复杂设备的麻烦。
虚拟化和容器环境： 在虚拟机和容器这样的环境中，Dnsmasq可以提供DNS和DHCP服务，使得虚拟机和容器间的通信更容易。
网络引导： 对于依赖于网络引导的系统或者设备，例如网络启动的计算机，Dnsmasq的TFTP服务也非常有用。

Dnsmasq 介绍与使用 | Enki's Notes

linux-command-substitution（命令替换）

2024-10-19T05:52:06.000Z

linux-command-substitution（命令替换）

1 什么是命令替换

在有一下情况的时候，会发生命令替换：

$(command)

或者是反引号
`command`

这个命令会在子shell中执行，使用标准输出替换掉上面的命令文本。并且在管道关闭或者子进程终止前，shell会一直等待。

2 命令替换时为什么把换行变成了空格

shell读取的输出会以空格作为分隔符进行解析。
不过你可以通过从新设定 IFS 字段来重新指定分隔符。

比如说现在有一个文本文件：

wudanyang@dy-turbo-vm:~/workspace$ cat links.txt
123
456
789

把文件内容实用命令替换成一个变量之后，文本输出是以空格分隔的，换行符被替换掉了

wudanyang@dy-turbo-vm:~/workspace$ a=$(cat links.txt)
wudanyang@dy-turbo-vm:~/workspace$ echo $a
123 456 789

但是如果在输出的时候使用双引号括起来，那么换行符就会被保留下来：

wudanyang@dy-turbo-vm:~/workspace$ a=$(cat links.txt)
wudanyang@dy-turbo-vm:~/workspace$ echo "$a"
123
456
789

3 读取文件的时候空格被当成了分隔符

当有这样一个文件：

$ cat links.txt
hello world
today is weekend
so happy

直接输出是这样的：

wudanyang@dy-turbo-vm:~/workspace$ a=$(cat links.txt)
wudanyang@dy-turbo-vm:~/workspace$ echo $a
hello world today is weekend so happy

如果直接读取的话，因为默认空格是分隔符，所以会认为这是很多行

$ for i in $(cat links.txt); do echo $i; done
hello
world
today
is
weekend
so
happy

3.1 使用双引号解决

使用双引号可以解决这个问题，不实用shell的字符处理，而是使用双引号的字符处理逻辑：

for i in "$(cat links.txt)"; do echo "$i"; done
hello world
today is weekend
so happy

3.2 使用 IFS 修改默认分隔符

当然也可以使用 IFS，把默认的分隔符修改掉，但是记得要还原回来，不然可能执行别的程序会有问题

oriIFS=$IFS;IFS=

### 3.3 使用管道+read指令

> The _read_ utility shall read a single logical line from standard input into one or more shell variables.

```bash
cat links.txt | while read i; do echo $i; done
hello world
today is weekend
so happy

4 小结

可以看到命令替换的字符串还是有一些弯弯绕绕的，所以，一般情况下，就不要使用命令替换，而是直接使用管道，或者就不使用shell了

5 参考

命令替换 2.6.3 Command Substitution ： Shell Command Language
shell - 为什么使用命令替换时换行符会丢失？ - Unix 和 Linux 堆栈交换 --- shell - Why do newline characters get lost when using command substitution? - Unix & Linux Stack Exchange

阅读(1p) - Linux 手册页 --- read(1p) - Linux manual page
\n'; for i in $(cat links.txt); do echo $i; d o n e; I F S =$ oriIFS;
hello world
today is weekend
so happy


### 3.3 使用管道+read指令

> The _read_ utility shall read a single logical line from standard input into one or more shell variables.

{{CODE_BLOCK_9}}

## 4 小结

可以看到命令替换的字符串还是有一些弯弯绕绕的，所以，一般情况下，就不要使用命令替换，而是直接使用管道，或者就不使用shell了

## 5 参考

命令替换 2.6.3 Command Substitution ： [Shell Command Language](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_03)
[shell - 为什么使用命令替换时换行符会丢失？ - Unix 和 Linux 堆栈交换 --- shell - Why do newline characters get lost when using command substitution? - Unix & Linux Stack Exchange](https://unix.stackexchange.com/questions/164508/why-do-newline-characters-get-lost-when-using-command-substitution)

[阅读(1p) - Linux 手册页 --- read(1p) - Linux manual page](https://man7.org/linux/man-pages/man1/read.1p.html)

iso-日期表示法

2024-10-12T15:19:09.000Z

国际标准化组织的日期时间表示法

iso-日期表示法

1 零时区

在最后加上大写的 Z
2004-05-03T17:30:08Z

2 其他时区

合并表示时，要在时间前面加一大写字母T，如要表示东八区时间2004年5月3日下午5点30分8秒，可以写成2004-05-03T17:30:08+08:00或20040503T173008+08。

时间点表示法

首字母为 P，其他字母为年月日时分秒，中间加上 T
P1Y3M5DT6H7M30S

时间间隔表示法

1 从一个时间开始，到另一个时间结束

19850412/19860101

2 从指定时间开始持续一段时间

19850412/P6M

循环时间表示法

R【循环次数】【/开始时间】/时间间隔【/结束时间】

从2004年5月6日北京时间下午1点起时间间隔半年零5天3小时循环，且循环3次
R3/20040506T130000+08/P0Y6M5DT3H0M0S。

以1年2个月为循环间隔，无限次循环，最后循环终止于2025年1月1日
R/P1Y2M/20250101

参考

epoll的边缘触发和水平触发

2024-10-12T15:17:29.000Z

epoll的边缘触发和水平触发

epoll 是 Linux 下用于处理大量文件描述符的高效 I/O 多路复用机制。在 epoll 中，有两种触发模式：水平触发（Level-Triggered，简称 LT）和边缘触发（Edge-Triggered，简称 ET）。

水平触发（LT，Level-Triggered）：
- 当文件描述符就绪时，epoll_wait 将立即返回。
- 如果文件描述符的状态发生变化，epoll_wait 会再次通知应用程序。
- 这种模式下，如果文件描述符有数据可读或可写，epoll_wait 将不停地返回通知，直到应用程序处理完数据或者阻塞。
边缘触发（ET，Edge-Triggered）：
- 当文件描述符就绪时，epoll_wait 只会通知一次，直到应用程序处理完数据并清空了文件描述符的缓冲区。
- 如果文件描述符的状态没有变化，epoll_wait 不会重复通知应用程序。
- 这种模式下，应用程序需要注意，在一个事件通知之后，要一直读或写，直到发生 EAGAIN 或 EWOULDBLOCK 错误。

为什么epoll这里要叫做边缘触发和水平触发呢？

这源于通信数字信号处理领域的术语，边缘和水平通常用于描述信号的特性

边缘触发（Edge-Triggered）：
- "边缘" 指的是信号的变化边缘，即信号从一个状态变为另一个状态的瞬间。
- 在数字信号处理中，边缘通常用来表示信号的上升沿或下降沿，即信号从低电平到高电平或从高电平到低电平的瞬间。
水平触发（Level-Triggered）：
- "水平" 指的是信号的水平状态，即信号所处的电平状态。
- 在数字信号处理中，水平触发通常用来描述信号保持在某个电平的状态，而不关心信号的变化瞬间。

1 Reference

https://electronics.stackexchange.com/a/21891

202404142147 如何在shell中遍历数字

2024-04-22T02:49:06.000Z

202404142147 如何在shell中遍历数字

for i in {0..10}; do
    echo ${i}
done

# seq 1 3 10   # 步长3
for i in $(seq 1 10); do
	echo ${i}
done

shell-循环

202103251606 - 如何在 linux 上配置科学上网

2024-04-27T12:32:12.000Z

202103251606 - 如何在 linux 上配置科学上网

我的机器是树莓派，底层架构是 arm 的，所以下载 arm 版本的安装包：
https://github.com/Dreamacro/clash/releases/download/v1.4.2/clash-linux-armv8-v1.4.2.gz

gunzip clash-linux-armv8-v1.4.2.gz
sudo mv clash-linux-armv8-v1.4.2 /usr/bin/clash

# 下载你的配置，这里我是用的是 nsfwcloud.com 的服务
wget -O config.yml "https://rxl-nc.xyz/link/{your.token}?clash=1&log-level=info"

# 后台运行
nohup clash -f config.yml & 

export https_proxy=http://127.0.0.1:7890 http_proxy=http://127.0.0.1:7890 all_proxy=socks5://127.0.0.1:7890

最终效果

如果不想要 info 日志，可以在 config.yml 中将 log-level 修改成 log-level: warning

参考

https://nsfwcloud.com/user/tutorial?os=linux&client=clash##

output

https://www.cnblogs.com/wudanyang/p/15142036.html

202011261547 - 使用base64处理二进制字符串

2024-10-12T08:45:43.000Z

tags: #string

一句话简单描述：使用 base64_encode 将二进制字符串映射成 base64 ，然后在使用的使用 base64_decode 一下

202011261547 - 使用base64处理二进制字符串

二进制字符串不具有可处理性，输出到文件或者屏幕上面显示如下:

上面图片中的字符串很难被处理，因为二进制字符串在

base64_encode 之后，是使用64个字符组成的字符串：

程序中处理的时候使用 base64_decode 一下，赋值给一个变量即可

$originData = base64_deocde($base64Data);

# 下面是你自己的逻辑
......

202506201431 将刚提交的commit回滚

2025-06-23T03:41:30.000Z

202506201431 将刚提交的commit回滚

git reset --soft HEAD

obsidian-things3-today插件

2025-01-22T17:16:54.000Z

obsidian-things3-today插件

插件： Obsidian Plugin - Things3 Today

把之前的插件重新搞了搞，把乱七八糟的东西去掉了，然后提交了obsidian插件库
review 审核通过： https://github.com/obsidianmd/obsidian-releases/pull/2997
新录了一个gif：见github的readme，图中可以看到和things3的Today列表联动还算是顺畅
github - wudanyang6/obsidian-things3-today
跟着操作手册在论坛上面发了分享贴：
- https://forum.obsidian.md/t/new-plugin-things3-today-manage-todays-tasks-with-things3/77916

Things 工作流

2025-02-05T16:38:26.000Z

Things 工作流

有任何事情都记录下来，心中的任何想法都不要放过，使用Things的快速录入功能
定时整理收件箱（需要保证整理完收件箱之后，任务都是可执行的）
1. 如果有事情2分钟就能解决，那么直接去做，属于小事情
2. 如果需要1小时以上，就将任务设置成项目
  1. 做一次任务分解，分解成小任务，小任务以30分钟以内完成最好
  2. 如果分解项目本身也需要很多时间，那么在项目里面加一个【分解任务】的事项
根据时间，选取任务进行处理，打开 Session 软件进行专注于做事，太喜欢 Session 的页面了，从而订阅了 setapp 使用

为了让Things工作流更顺畅，我做了一个obsidian插件：obsidian-things3-today插件

202404191548 GTD的主要思想

CDN 带宽控制

2025-02-12T13:06:38.000Z

CDN 带宽控制

refer 限制，禁用非自身域名
1. 空refer禁用，有一定风险，尽量在站点刚开放时使用此方案
单请求响应限速，百度CDN可以配置
CDN日志回扫分析
1. 删除肉眼可见的违规图片
2. 对图片进行检测，是否包含视频资源（需要策略算法支持）
针对访问量、请求数过高的ip进行封禁
图片与内容关联，在审核内容时，发现图片违禁直接删除内容并删除图片

Home

2024-09-11T09:07:12.000Z

国泰民安、风调雨顺、世界和平
平时要全力以赴的练习，才能在关键时刻派上用场

File	创建时间
202506201431 将刚提交的commit回滚	2025-06-20 14:31:04
202506172251 mac 强制程序使用代理	2025-06-17 22:51:58
202506171613 vscode 如何粘贴文件不覆盖	2025-06-17 16:13:46
202506061308 vscode There is no formatter for 'go' files installed 报错处理	2025-06-06 13:08:31
gunicorn+uvicorn+fastapi 进程模型.excalidraw	2025-05-26 22:26:14
python-Asyncer	2025-04-21 16:03:31
python 虚拟环境	2025-02-26 14:57:27
python fastapi 默认线程数	2025-02-17 23:36:42
网易云音乐mac端回退到2.x版本	2025-02-13 23:05:00
python-为什么 {} 不能作为默认参数？	2025-02-10 14:56:03
如果一生只读6本书，推荐哪几本？	2025-02-06 15:45:15
mermaid 图表自动生成	2025-01-16 11:03:36
ai-动画制作	2025-01-02 00:47:27
golang-cobra	2024-12-20 14:31:47
55. 跳跃游戏	2024-11-13 23:46:30
1143. 最长公共子序列	2024-11-10 19:28:30
59. 螺旋矩阵 II	2024-11-09 18:16:21
239. 滑动窗口最大值	2024-11-09 00:00:13
72. 编辑距离	2024-11-08 01:03:57
leetcode题目难度更新了	2024-11-06 00:26:39
560. 和为 K 的子数组	2024-10-30 23:25:53
54. 螺旋矩阵	2024-10-28 20:39:41

File	更新时间
202506201431 将刚提交的commit回滚	2025-06-23 11:41:30
linux-什么是anon_inode	2025-06-21 23:17:40
python fastapi 默认线程数	2025-06-19 13:34:56
202506171613 vscode 如何粘贴文件不覆盖	2025-06-17 23:07:42
202506172251 mac 强制程序使用代理	2025-06-17 22:53:59
202506061308 vscode There is no formatter for 'go' files installed 报错处理	2025-06-06 13:08:59
ai-动画制作	2025-06-05 20:57:59
gunicorn+uvicorn+fastapi 进程模型.excalidraw	2025-05-27 14:12:43
python 虚拟环境	2025-05-13 22:32:53
python-Asyncer	2025-04-25 19:03:19
linux-wrk	2025-03-13 16:47:19
快速创建一个可访问的服务	2025-02-24 15:29:43
使用shell脚本快速并行启动指定数量的进程	2025-02-18 22:06:12
linux-wait	2025-02-18 22:05:49
202404251145 破解软件的成本如果比较高就不要去花时间破解了	2025-02-18 21:43:13
go 获取凌晨0点的时间戳	2025-02-18 20:15:16
202404171707 当你学不下去的时候	2025-02-14 16:40:58
网易云音乐mac端回退到2.x版本	2025-02-13 23:08:44
Kafka入门	2025-02-13 13:12:00
202012081017 - php8.0 新特性	2025-02-13 13:11:20
go-时间处理	2025-02-13 13:03:59
vscode vim 状态下显示提示	2025-02-13 12:59:33

2024-10-11

2024-11-10T11:43:00.000Z

2024-10-11

换了一个新的工作电脑 Apple M3 16G

新电脑的刘海把很多图标都挡住了，太难受了，看网上教程，找了个软件 Bartender 能够解决

带刘海屏的 Macbook, 状态栏图标多了被刘海挡住看不到了，咋办？ - V2EX: https://v2ex.com/t/1019165#;