初识

如何退出 Vim？

学习 Vim

当时阅读的笔记：Linux下C编译的步骤_hhmy77的博客-CSDN博客

插入模式 i
退出模式esc
左下上右h j k l
跳转到改行的第一个afa
撤销u
命令编辑模式下：保存并退出:wq 不保存退出:q 在后面加！则强制操作
保存并退出shift+zz 不保存退出shift+zq
普通模式下替换当前字符为ara ，替换字符串R字符串将当前字符变为大写~

普通模式下 当前行右移>>
跳转到行尾$ 行首^

跳转到下一个单词e
复制：
v进入可视模式，然后选择想要复制的语句，按y复制，返回normal模式，按p粘贴

普通模式下输入 / 然后键入需要查找的字符串 按回车后就会进行查找。
？ 与/ 功能相同，只不过 ？ 是向上而 / 是向下查找。
进入查找之后，输入n 和 N 可以继续查找。
n是查找下一个内容,N查找上一个内容。

在当前行下开始插入o
在当前行之前开始插入O

向上移动一行 ctrl+y
向下移动一行ctrl+e
跳转到单词词首、下一单词词尾、前一单词词首web
删除光标开始的单词 dw
删除光标所在的单词daw

删除当前字符x

2.3.3 高级查找

普通模式下输入*寻找游标所在处的单词
普通模式下输入#同上，但 # 是向前（上）找，*则是向后（下）找
普通模式下输入g*同* ，但部分符合该单词即可
普通模式下输入g#同# ，但部分符合该单词即可

一些主流编辑器的学习曲线

持续学习 Vim

人生苦短

Message from the family of Bram Moolenaar (google.com)

R.I.P.！Vim 程式編輯器作者 Bram Moolenaar 享壽 62 歲 - INSIDE Moolenaar 設定 Vim 的使用條款寫到，如果願意支持的話使用者可以捐款給烏干達的兒童，而不是要求捐款給 Moolenaar 自己。 目前 Vim 每年約有 30000 歐元的捐款，這換算下來大約可以資助 50 名烏干達兒童完成從小學到大學的學費。

用途

1. 合并两个集合

2. 判断两个元素是否属于同一集合

朴素并查集

int p[N];

void init()
{
    for (int i = 1; i <= N; i++)
    {
        p[i] = i;
    }
}

// 找到一个节点的祖先节点
int find(int a)
{
    if (p[a] != a)
        p[a] = find(p[a]);
    return p[a];
}

// 合并两个节点所在的集合
void merge(int a, int b)
{
    int x = find(a), y = find(b);
    p[x] = y;
}

// p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量
int p[N], size[N], n;

// 返回x的祖宗节点
int find(int x)
{
    if (p[x] != x)
        p[x] = find(p[x]);
    return p[x];
}

// 初始化，假定节点编号是1~n
void init()
{
    for (int i = 1; i <= n; i++)
    {
        p[i] = i;
        size[i] = 1;
    }
}

// 启发式合并
void merge(int a, int b)
{
    int x = find(a), y = find(b);
    if (x == y)
        return;
    if (size[y] < size[x])
        swap(x, y);
    p[x] = y;
    size[y] += size[x];
}

带权并查集

const int N = 1e5;

int p[N], d[N];
// p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离

// 返回x的祖宗节点
int find(int x)
{
    if (p[x] != x)
    {
        int u = find(p[x]);
        d[x] += d[p[x]];
        p[x] = u;
    }
    return p[x];
}

// 版本2
int find(int x)
{
		if (p[x] != x)
		{
				int u = p[x];
				p[x] = find(p[x]);
				d[x] += d[u];
		}
		return p[x];
}

// 初始化，假定节点编号是1~n
void init()
{
    for (int i = 1; i <= n; i++)
    {
        p[i] = i;
        d[i] = 0;
    }
}

// 合并a和b所在的两个集合：
void merge(int a, int b)
{
		int px = find(a), py = find(b);
    p[px] = py;
    d[px] = distance; // 根据具体问题，初始化find(a)的偏移量
}

带权的合并操作

find函数

// 返回x的祖宗节点
int find(int x)
{
    if (p[x] != x)
    {
				// 寻找祖先节点
        int u = find(p[x]);
        d[x] += d[p[x]]; // 更新到祖先节点的距离
        p[x] = u; // 修改为祖先节点
    }
    return p[x];
}

int find(int x)
{
    if (p[x] != x)
    {
        d[x] += d[p[x]]; // 没有经过路径压缩的 d[p[x]]，只是父节点到其父节点的距离
        p[x] = find(p[x]); 
    }
    return p[x];
}

种类并查集

• 题目有n个元素，有m种类别，则我们需要开n * m的空间

• 1*n, 2*n, 3*n, …, m*n 分别代表不同的类别

• 通过链接不同类别的节点，可以描述某种关系。

复杂度

练习题

银河英雄传说

int find(int x)
{
		if (x != p[x])
		{
				int u = find(p[x]);
				d[x] += d[p[x]]; // 路径压缩，更新d[x]
				p[x] = u;
		}
		return p[x];
}

#include <iostream>
using namespace std;
const int N = 1e4 * 3 + 10;
int p[N], d[N], s[N]; // s表示size，仅有祖先节点才有效
int t, a, b;
char m[2];

void init()
{
    for (int i = 0; i < N; i++)
    {
        p[i] = i;
        s[i] = 1;
    }
}

int find(int x)
{
    if (x != p[x])
    {
        int u = find(p[x]);
        d[x] += d[p[x]];
        p[x] = u;
    }
    return p[x];
}

int merge(int x, int y)
{
    int px = find(x), py = find(y);
    p[px] = py;
    d[px] = s[py]; // 应该设置为y所属集合的节点数
    s[py] += s[px];
}

int query(int x, int y)
{
    int px = find(x), py = find(y);
    if (px != py)
        return -1;
    return max(0, abs(d[x] - d[y]) - 1); // 有可能x = y
}
int main()
{
    init();
    scanf("%d", &t);
    for (int i = 0; i < t; i++)
    {
        scanf("%s%d%d", m, &a, &b);
        if (m[0] == 'M')
        {
            if (find(a) == find(b))
                continue;
            merge(a, b);
        }
        else
        {
            printf("%d\n", query(a, b));
        }
    }
}

食物链

• d[i] = 0 → 和根节点同类

• d[i] = 1 → 吃根节点

• d[i] = 2 → 被根节点吃

• 如果x和y在同一集合
• 如果x和y是同类，那么(d[x] - d[y]) % 3 = 0 成立。
• 这里表示x和y都和根节点是同类，因此x和y是同类
• 如果x吃y，那么(d[x] - d[y] - 1) % 3 = 0 成立
• 这里表示x吃根节点，而y和根节点是同类，因此x吃y
• 如果x被y吃，那么(d[x] - d[y] - 2) % 3 = 0 成立
这里需要取模，是因为d[x]的值很有可能超过3，所以我们用%3来约束d[i]的值域，便于判断。

• 如果x和y不在同一个集合，则需要合并，方便以后判断



比如说上面的情况，给定x和y，以及它们的祖先节点px和py，还有距离d[x]和d[y]，想要合并px到py，那么d[px]应该等于多少呢？
• 如果x和y是同类，那么(d[x] + d[px] - d[y]) % 3 = 0 成立，可以推断出d[px] = (d[y] - d[x]) %3
• 如果x吃y，那么(d[x] + d[px] - d[y] - 1) % 3 = 0 成立，可以推断出d[px] = (d[y] - d[x] + 1) %3

#include <iostream>
using namespace std;
const int N = 50010, M = 1e5 + 10;
int p[N], d[N];
int res;
int n, k;
void init()
{
    for (int i = 0; i < N; i++)
        p[i] = i;
}
int find(int x)
{
    if (x != p[x])
    {
        int u = p[x];
        p[x] = find(p[x]);
        d[x] += d[u];
    }
    return p[x];
}

int main()
{
    init();
    scanf("%d%d", &n, &k);
    int c, x, y;
    while (k--)
    {
        scanf("%d%d%d", &c, &x, &y);
        if (x > n || y > n)
            res++;
        else
        {
            int px = find(x), py = find(y);
            if (c == 1)
            {
                // 如果x和y处于同一集合，且x和y的关系不是同类，那么当前是假话
                if (px == py && (d[x] - d[y]) % 3 != 0)
                    res++;
                else if (px != py) // 如果不是假话，那么我们根据需要来合并
                {
                    // 如果x和y不属于同一个集合，那么合并两个集合
                    p[px] = py;
                    d[px] = (d[y] - d[x]) % 3;
                }
            }
            else
            {
                if (px == py && (d[x] - d[y] - 1) % 3 != 0)
                    res++;
                else if (px != py)
                {
                    // 如果x和y不属于同一个集合，那么合并两个集合
                    p[px] = py;
                    d[px] = (d[y] - d[x] + 1) % 3;
                }
            }
        }
    }
    printf("%d\n", res);
}

#include <iostream>
using namespace std;
const int N = 15 * 1e4 + 10;
int n, k, res;
int p[N];
void init()
{
    for (int i = 1; i <= n * 3; i++)
    {
        p[i] = i;
    }
}
int find(int x)
{
    if (x != p[x])
    {
        p[x] = find(p[x]);
    }
    return p[x];
}

bool query(int x, int y)
{
    return find(x) == find(y);
}

void merge(int x, int y)
{
    int px = find(x), py = find(y);
    p[px] = py;
}

int main()
{
    scanf("%d%d", &n, &k);
    init();
    int c, x, y;
    while (k--)
    {
        scanf("%d%d%d", &c, &x, &y);
        if (x > n || y > n)
            res++;
        else
        {
            if (c == 1)
            {
                // 如果x吃y或者x被y吃，假话
                if (query(x, y + n) || query(x, y + 2 * n))
                    res++;
                else
                {
                    // 否则x和y同类，则x的猎物是y的猎物，x的天敌是y的天敌
                    merge(x, y);
                    merge(x + n, y + n);
                    merge(x + 2 * n, y + 2 * n);
                }
            }
            else if (c == 2)
            {
                // 如果x和y是同类，或者y是x的天敌，假话
                if (query(x, y) || query(x, y + 2 * n))
                    res++;
                else
                {
                    // 否则x吃y是真的
                    merge(x, y + n);         // x吃y
                    merge(x + n, y + 2 * n); // x的猎物吃y的猎物（传递性）
                    merge(x + 2 * n, y);     // y吃x的天敌
                }
            }
        }
    }
    printf("%d\n", res);
}

关押罪犯

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 4 * 1e4 + 10, M = 1e5 + 10;
int p[N];
struct Edge
{
    int x, y, w;
    bool operator<(const Edge &W) const
    {
        return w > W.w;
    }

} edges[M];

int find(int x)
{
    if (x != p[x])
    {
        p[x] = find(p[x]);
    }
    return p[x];
}

bool query(int x, int y)
{
    return find(x) == find(y);
}

void merge(int x, int y)
{
    int px = find(x), py = find(y);
    p[px] = py;
}

int main()
{
    for (int i = 0; i < N; i++)
        p[i] = i;
    int n, m;
    int x, y, w;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++)
    {
        scanf("%d%d%d", &x, &y, &w);
        edges[i] = {x, y, w};
    }
    sort(edges, edges + m);
    for (int i = 0; i < m; i++)
    {
        x = edges[i].x, y = edges[i].y, w = edges[i].w;
        if (query(x, y)) // 试图把处于同一集合的元素分开，矛盾
        {
            // 此时的冲突就是无法避免的，输出
            printf("%d\n", w);
            return 0;
        }
        // 标记敌人关系
        merge(x, y + n);
        merge(x + n, y);
    }
    printf("0\n");
    return 0;
}

#include <cstring>
#include <iostream>
using namespace std;
const int N = 2 * 1e4 + 10, M = 1e5 + 10;
int n, m, x, y, w;
int p[N], d[N];
struct Edge
{
    int x, y, w;
} edges[M];

void init()
{
    memset(d, 0, sizeof d);
    for (int i = 1; i <= n; i++)
        p[i] = i;
}

int find(int x)
{
    if (x != p[x])
    {
        int u = p[x];
        p[x] = find(p[x]);
        d[x] ^= d[u];
    }
    return p[x];
}

bool check(int mid)
{
    init();
    for (int i = 0; i < m; i++)
    {
        x = edges[i].x, y = edges[i].y, w = edges[i].w;
        if (w <= mid)
            continue;
        int px = find(x), py = find(y);
        if (px == py)
            if (!(d[x] ^ d[y])) // xor 结果为0，表示它们属于同一类
                return false;
        if (px != py)
        {
            p[px] = py;
            d[px] = d[x] ^ d[y] ^ 1; // 因为是不同类，所以要 ^ 1
        }
    }
    return true;
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++)
    {
        scanf("%d%d%d", &x, &y, &w);
        edges[i] = {x, y, w};
    }
    int l = 0, r = 1e9;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid))
            r = mid;
        else
            l = mid + 1;
    }
    printf("%d", r);
}

#include <cstring>
#include <iostream>
using namespace std;
const int N = 2 * 1e4 + 10, M = 1e5 + 10;
int n, m, x, y, w;
int p[N * 2];
struct Edge
{
    int x, y, w;
} edges[M];

void init(int n)
{
    for (int i = 1; i <= 2 * n; i++)
        p[i] = i;
}

int find(int x)
{
    if (x != p[x])
    {
        int u = p[x];
        p[x] = find(p[x]);
    }
    return p[x];
}

bool query(int x, int y) { return find(x) == find(y); }

void merge(int x, int y)
{
    int px = find(x), py = find(y);
    p[px] = py;
}

bool check(int mid)
{
    init(n);
    for (int i = 0; i < m; i++)
    {
        x = edges[i].x, y = edges[i].y, w = edges[i].w;
        if (w <= mid)
            continue;
        if (query(x, y))
            return false;
        merge(x, y + n);
        merge(x + n, y);
    }
    return true;
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++)
    {
        scanf("%d%d%d", &x, &y, &w);
        edges[i] = {x, y, w};
    }
    int l = 0, r = 1e9;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid))
            r = mid;
        else
            l = mid + 1;
    }
    printf("%d", r);
}

总结

• 朴素并查集：最常用的一类并查集，用来管理元素的从属关系。

• 带权并查集：在朴素并查集上添加了权重d ，d 可以根据题目的不同来表示不同的含义，使用时需要确定merge和find操作如何更新d

• 种类并查集：一般维护若干个n的区间，每个区间表示不同含义，通过merge不同区间的节点，标识某种关系的存在

Ref

简介

问题分类

1. 单源最短路：求两个点之间的最短路径，一般是 1 到 n 号点

2. 多源汇最短路：求任意两个点之间的最短路径

1. 所有边权都是正数：这种情况是最常见的，用 dijkstra 就能求解

2. 边权存在负数：此时 dijkstra 无法求解，只能使用 BF 或者 SPFA 算法求解

图的存储

邻接矩阵

int g[N][N];

邻接表

// 对于每个点k，开一个单链表，存储k所有可以走到的点。
// h[k]存储这个单链表的头节点
// e 存储 value， ne 存储 next 指针， w 存储边权
int h[N], e[N], ne[N], w[N], idx;

// 添加一条边 a -> b, 边权为 c
void add(int a, int b, int c)
{
		e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
}

// 遍历点t的所有出边
for (int i = h[t]; i != -1; i = ne[i]){
		distance = w[i]; // 边权
		// 具体操作
}

// 初始化
idx = 0;
memset(h, -1, sizeof h);

单源最短路问题算法

dijkstra 算法

dijkstra(){
		// dist[i] 表示从 1 号点出发到点 i 的最短路径
		for 遍历n-1轮：
			// 寻找最近点 O(n)
			for 遍历所有节点 j:
				如果当前点j没有确认最短路，并且距离最小：
					t = j，记录最近点是j
			
			// O(n)
			for 遍历所有点 j:
				// 尝试用 t 去更新其它点的距离，g是邻接矩阵
				// 如果 1 -> j 的距离大于 1 -> t -> j，更新最短路径为 1 -> t -> j 的距离
				dist[j] = min(dist[j], dist[t] + g[t][j]);
			
			标记 t 点已经确认最短路径
}

朴素版 dijkstra

int g[N][N]; // 存储每条边
int dist[N]; // 存储1号点到每个点的最短距离
bool st[N];  // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路，如果不存在则返回-1 
int dijkstra()
{
		// 0x3f3f3f3f 表示无穷大
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < n - 1; i++)
    {
        // 在还未确定最短路的点中，寻找距离最小的点
        int t = -1;
        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        
        // 尝试用t更新其它点
        for (int j = 1; j <= n; j++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f)
        return -1;
    return dist[n];
}

有关时间复杂度的计算可以参考这篇文章： Dijkstra算法时间复杂度分析

堆优化版 dijkstra

  // 在还未确定最短路的点中，寻找距离最小的点
  int t = -1;
  for (int j = 1; j <= n; j++)
      if (!st[j] && (t == -1 || dist[t] > dist[j]))
          t = j;

typedef pair<int, int> PII;
int n;                            // 点的数量
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边, w[i] 是距离
int dist[N];                      // 存储所有点到1号点的距离
bool st[N];                       // 存储每个点的最短距离是否已确定

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1}); // first存储距离，second存储节点编号
    while (heap.size())
    {
				// 弹出距离最近的点，优化它的出边
        auto t = heap.top();
        heap.pop();
        int ver = t.second, distance = t.first;
        if (st[ver])
            continue;

        st[ver] = true;
				// 遍历t的所有出边
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});  // 如果能优化，则放入点
            }
        }
    }
    if (dist[n] == 0x3f3f3f3f)
        return -1;
    return dist[n];
}

BF 算法

for 迭代n次:
	for 所有边 a -> b, 边权 w:
		dist[b] = min(dist[b], dist[a] + w); // 松弛操作

int n, m;
int dist[N];

// 边，a表示出点，b表示入点，w表示边的权重
struct Edge
{
    int a, b, w;
} edges[M];

int bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，
    // 由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            if (dist[b] > dist[a] + w)
                dist[b] = dist[a] + w;
        }
    }
    if (dist[n] > 0x3f3f3f3f / 2)
        return -1;
    return dist[n];
}

SPFA 算法

if (dist[b] > dist[a] + w)
    dist[b] = dist[a] + w;

int n;                            // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N];                      // 存储每个点到1号点的最短距离
bool st[N];                       // 存储每个点是否在队列中

int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    queue<int> q;
    q.push(1);
    st[1] = true;
    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    if (dist[n] == 0x3f3f3f3f)
        return -1;
    return dist[n];

负权回路

int n;                            // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N], cnt[N];              // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N];                       // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点
    // 由抽屉原理一定有两个点相同，所以存在环。

    queue<int> q;
    for (int i = 1; i <= n; i++)
    {
        q.push(i);
        st[i] = true;
    }

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n)
                    return true; // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

对比 SPFA 和堆优化 dijkstra

while (heap.size())
{
		// 弹出距离最近的点，优化它的出边
    auto t = heap.top();
    heap.pop();
    int ver = t.second, distance = t.first;
    if (st[ver])
        continue;

    st[ver] = true;
		// 遍历t的所有出边
    for (int i = h[ver]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (dist[j] > distance + w[i])
        {
            dist[j] = distance + w[i];
            heap.push({dist[j], j});  // 如果能优化，则放入点
        }
    }
}

while (q.size())
{
		// 弹出被更新的点
    auto t = q.front();
    q.pop();

    st[t] = false;
		// 遍历所有出边，尝试优化
    for (int i = h[t]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (dist[j] > dist[t] + w[i])
        {
            dist[j] = dist[t] + w[i];
            if (!st[j])
            {
                q.push(j);
                st[j] = true;
            }
        }
    }
}

Floyd 算法

初始化：
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

// 算法结束后，d[a][b]表示a到b的最短距离
void floyd()
{
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

总结

参考

简介

1. Lock 和 Unlock 没有匹配

2. 不可复制

3. 不可重入

4. 死锁

Lock 和 Unlock 没有匹配

1. 多层 if-else 的复杂嵌套，导致没有在对应的逻辑分支中释放锁

尽量避免超过 3 层以上的嵌套缩进，如果超过了 3 层，或许应该考虑重构这段逻辑 为什么你不应该嵌套代码，Linux之父也在这样做_哔哩哔哩_bilibili

举一个例子

 if check {
		mu.Lock()
		if check {
			// do something ...
			mu.Unlock()
		} else {
			// do something ...
			// doesn't release lock
			return 
		}
	}

上面这段代码在 else 的时候忘记释放锁，直接 return，这种情况下会直接导致死锁。

2. 重构代码的时候错误的删除了 Unlock
由于不熟悉上下文，在我们进行复杂的逻辑改动的时候，很有可能会不小心删除掉 Unlock 相关的代码，比如说重构上面复杂的 if-else，我们可能尝试删减或添加一个分支的时候，把原有的 Unlock 给去掉了，导致死锁
再举一个例子

mu.Lock()
// 新增的 if 逻辑，直接返回并没有释放
if check {
	return
}
mu.Unlock()

3. 没有触发 Unlock 的调用逻辑
原始代码逻辑是在 845 行进行加锁，在接下来的子函数中进行处理，并负责解锁
但是这里有一个弊端，就是子函数如果出现 panic，会直接触发 recover 的逻辑，但是旧的 recover 并没有做锁的释放，那么就会出现死锁了。所以这个 MR 也是修复了这个问题，如果出现了 panic，在 recover 的时候同时释放锁，避免死锁出现。

虽然理想状态下是平级做 Lock/Unlock 的，但是工程规模一旦扩大，就很难达到这种理想的重构，所以只能用这种折中的办法修复问题，虽然不是很优雅，但是能解决问题。

4. 加锁之前解锁

mu := sync.Mutex{}
mu.Unlock()

比如说上面这种情况，会报错

fatal error: sync: unlock of unlocked mutex

这个 fatal error 是没办法 recover 的，它不是 panic，出现这种情况只能修改代码了。

不可复制

type Counter struct {
	sync.Mutex
	Count int
}

func main() {
	var c Counter
	c.Lock()
	defer c.Unlock()
	c.Count++
	foo(c)
}

// 无意间复制了 Mutex
func foo(c Counter) {
	c.Lock()
	defer c.Unlock()
	fmt.Println("in foo")
}

不可重入

死锁

1. 互斥：竞争的资源具有排他性，不能同时被多个线程占有。

2. 请求并保持：每个线程保持了一定的资源，同时还申请新的资源。

3. 不可剥夺：一旦资源分配给线程，就无法从它手中剥夺资源。

4. 循环等待：多个线程处于循环等待状态，都在等待对方释放资源。

扩展

Go 的死锁检查机制

Ref

简介

• 包交换技术

• Delay
使用路由交换技术不可避免的延迟：
• 链接上固定的传播延迟。 Propagation delay along the links (fixed)
• 数据打包的固定延迟。Packetization delay to place packets onto links (fixed)
• 路由器数据包缓冲区中的排队延迟. Queueing delay in the packet buffers of the routers (variable)

• 缓冲区

2 Getting started

3 Putting substrings in sequence

• 接收 substrings，包括了组成 string 的 bytes，还有 string 在 stream 中 的唯一 index。这些数据可能是乱序的，需要我们组装起来

• 使用 ByteStream 作为输出，有序的把 bytes 写入到 ByteStream 中

3.1 What’s the “capacity”?

• 一方面是限制了 ByteStream 的大小

• 另一方面限制了从 substrings 中读取的最大 bytes 数

分析和设计

• 有一个 buffer 帮助我们缓存不能立即放入 ByteStream 的数据

• 一个 ByteStream 供读写

实验结果

1. 检查是否越界



假设 recv_index_ 是期望接收的第一个 index，而 last_store_index_ 是最后不能接收的字符（index = 0，cap = 8 时，last_store_index_ = 8）
那么从图中来看，我们需要丢弃 1 和 5 两种情况

2. 裁剪线段
根据上图，2 和 4 都需要裁剪出处于区间的部分，3不用裁剪
特别的，4 需要我们进行 eof 的判断，如果 4 是 eof 的，那么此时这个 eof 指令是无效的，因为最后的字符被裁剪掉了
另外我们还需要考虑一种完全覆盖区间的情况，即 2 + 3 + 4，这中情况即需要裁剪头部，也需要裁剪尾部，因此我们不能用 if … else … 进行处理

3. 在树中合并
由于最终指向的 bytes 是一致的，我们处理起来的难度大大降低了
现在我们得到了经过裁剪后的 node，我们想要把它插入到树中，保持树中 node 无重叠的性质，那么就需要我们对树的 node 进行合并。
先是向后合并
我们根据lower_bound，找到结构中对应的下一个 node，判断两个 node 的位置关系



由上图我们可以总结出三种类型的位置关系，分别是重叠、不重叠、覆盖
1. case 1，如果不重叠，退出向后合并
2. case 3，如果覆盖，把被覆盖的线段移除，因为当前线段能够表示被覆盖的线段了，继续向后合并
3. case 2，如果重叠，那么合并两条线段，移除下一条线段，继续向后合并
向后合并完毕后，考虑向前合并



情况也是一样的
那么经过最终的前后合并，树中的 node 都是无重叠的了

4. 尝试写入 ByteStream
当我们树中第一个 node 的 index，恰好等于 recv_index_ 的时候，就能进行写入了

5. eof 的处理
我们先考虑一下 eof 什么时候是有效的，当且仅当 eof = true 且 最后一个字符被读入的时候就是有效的。那么回到最原始的这张图

一些容易忽略的点

• 切片表示的最终的 bytes 是一致的

• buffer 中的最好不要存储重叠的子串

• 注意计算 first unassembled 和 first unacceptable

• 有些不确定的地方，看测试用例确定应该怎么处理

总结

• 计算机不会骗人，不要怀着“我的代码没问题啊”这种心态去 debug，不然自己很容易崩溃

• 高效的 debug 工具非常重要，能帮你节省很多时间
• 尽量让自己的工作自动化，能够节省很多时间

• 想办法弄到导致 bug 的数据，如果没办法弄到，观察日志分析走到哪一步导致不符合预期的结果，然后根据调用链跟进

简介

使用通信(channel)来共享内存，而不是通过共享内存来通信

初始化

除了 channel 以外，make 还可以用来初始化 slice、map

ch1 := make(chan int, 3) // 初始化一个大小为 3 的 channel
ch2 := make(chan int)    // 初始化一个无缓冲的 channel

• 队列满时生产者阻塞

• 队列空时消费者阻塞

func TestChannel(t *testing.T) {
	ch2 := make(chan int)
	ch2 <- 1
	fmt.Println(<-ch2)
}

func TestChannel(t *testing.T) {
	ch2 := make(chan int)
	go func() {
		fmt.Println(<-ch2)
	}()
	ch2 <- 1
}

func TestChannel(t *testing.T) {
	ch2 := make(chan int)
	ch2 <- 1 // 提前发送, deadlock
	go func() {
		fmt.Println(<-ch2)
	}()
}

channel 的使用

遍历

func TestFor(t *testing.T) {
	ch1 := make(chan int, 100)
	for i := 0; i < 100; i++ {
		ch1 <- i
	}
	
	// 方式一, 用 for 取出所有元素，建议使用
	for i := range ch1 {
		fmt.Println(i)
	}
	fmt.Println("-")

	// 方式二
	for {
		i, ok := <-ch1 // 通道关闭后再取值ok=false
		if !ok {
			break
		}
		fmt.Println(i)
	}
}

select

func fibonacci(c, quit chan int) {
	x, y := 0, 1
	for {
		select {
		case c <- x:
			x, y = y, x+y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

func TestSelect(t *testing.T) {
	c := make(chan int)
	quit := make(chan int)
	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()
	fibonacci(c, quit)
}
// output:
//0
//1
//1
//2
//3
//5
//8
//13
//21
//34
//quit

func TestTimeout(t *testing.T) {
	c1 := make(chan string, 1)
	go func() {
		time.Sleep(time.Second * 2)
		c1 <- "result 1"
	}()
	select {
	case res := <-c1:
		fmt.Println(res)
	case <-time.After(time.Second * 1):
		fmt.Println("timeout 1")
	}
}
// output:
// timeout 1

func After(d Duration) <-chan Time {
	return NewTimer(d).C
}

通道的限制

func op(writer <-chan int, reader chan<- int) {
	for data := range writer{
		reader <- data
	}
}

通道的关闭和异常

func TestClose(t *testing.T) {
	ch := make(chan int, 10)
	defer func(){
		close(ch)
	}()
	// do something ... 
}

// 无缓冲 channel，读
func TestClose(t *testing.T) {
	ch := make(chan int)
	close(ch)
	fmt.Println(<-ch) // 0
}

// 无缓冲 channel，写
func TestClose(t *testing.T) {
	ch := make(chan int)
	close(ch)
	ch <- 0 // panic: send on closed channel
}

// 有缓冲 channel, 无写入值， 读
func TestClose(t *testing.T) {
	ch := make(chan int, 10)
	close(ch)
	fmt.Println(<-ch) // 0
}

// 有缓冲 channel，有写入值，读
func TestClose(t *testing.T) {
	ch := make(chan int, 10)
	for i := 1; i <= 10; i++ {
		ch <- i
	}
	close(ch)
	for i := range ch {
		fmt.Println(i) // 输出 1 到 10
	}
	fmt.Println(<-ch) // 输出 0
}

// 有缓冲 channel, 写
func TestClose(t *testing.T) {
	ch := make(chan int, 10)
	close(ch)
	ch <- 1 // panic: send on closed channel
}

func TestClose(t *testing.T) {
	ch := make(chan int, 1)
	ch = nil
	fmt.Println(<-ch) // fatal error: all goroutines are asleep - deadlock!
	ch <- 1           // fatal error: all goroutines are asleep - deadlock!
	close(ch)         // panic: close of nil channel
}

源码分析

Ref

简介

环境

apt-get install g++ git clang-tidy clang-format libpcap-dev \
    iptables mininet tcpdump telnet wireshark socat netcat-openbsd \
    doxygen graphviz

2 Networking by hand

• retrieving a web page

• sending an email message

2.1 Fetch a Web page

• 在浏览器中访问 http://cs144.keithw.org/hello，并观察结果

• 输入$ telnet cs144.keithw.org http

GET /hello HTTP/1.1
Host: cs144.keithw.org
Connection: close

• GET /hello HTTP/1.1，告诉 server 我们想要访问的 URL 路径，这里是 /hello

• Host: cs144.keithw.org，告诉 server 我们想要访问的 host，指的是 http:// 到 /hello 中间的数据

• Connection: close，告诉 server，一旦返回结果就可以立即关闭

GET /lab0/1808 HTTP/1.1
Host: cs144.keithw.org
Connection: close

2.2 Send yourself an email

2.3 Listening and connecting

1. 用 netcat -v -l -p 9090 来监听 9090 端口

2. 在另一个 terminal，用 telnet localhost 9090 来链接 9090 端口

3 Writing a network program using an OS stream socket

3.1 Let’s get started —— fetching and building the starter code

3.2 Modern C++: mostly safe but still fast and low-level

• 尽量避免使用成对操作，比如说 malloc/free, new/delete，因为后面的操作可能会因为异常或者提前退出而不能正确执行

• Resource acquisition is initializatio（RAII）风格
c++经验之谈一：RAII原理介绍 - 知乎 (zhihu.com)
具体分为四步
1. 设计一个类封装资源
2. 在构造函数中初始化
3. 在析构函数中执行销毁操作
4. 使用的时候声明一个该对象的类（而不要使用new）

3.3 Reading the Sponge documentation

• FileDescriptor ⇒ Socket ⇒ TCPSocket

• Address 是 Socket 需要绑定的地址类

• 然后看这个 libsponge/util 里面有源码

3.4 Writing webget

void get_URL(const string &host, const string &path) {
    // Your code here.

    // You will need to connect to the "http" service on
    // the computer whose name is in the "host" string,
    // then request the URL path given in the "path" string.
    
    // Then you'll need to print out everything the server sends back,
    // (not just one call to read() -- everything) until you reach
    // the "eof" (end of file).
    
    // cerr << "Function called: get_URL(" << host << ", " << path << ").\n";
    // cerr << "Warning: get_URL() has not been implemented yet.\n";
}

/etc/services 文件包含网络服务和它们映射端口的列表。详细介绍可以看： Services (網路服務設定檔) - 維基百科，自由的百科全書 (wikipedia.org) 技术|理解 Linux 中的 /etc/services 文件

• 用TCPSocket链接指定的host，然后写入相应的请求，并打印返回值

4 An in-memory reliable byte stream

• 长度限制writer写入的数量，但是并不限制整个传输的信号量。

• 当writer写入到limit的时候就不能再写了，只有reader取出数据才能继续写，就像生产者和消费者模型一样。

• reader想要读取的字符长度超过了队列的大小，应该怎么处理，直接报错还是直接读取尽可能大的字符？

• 我写入的字符串大于队列大小，应该丢弃多余的字符，还是保存下来再写入？

• writer在队头写，reader取队尾

• 限制最大存储容量cap，通过队列元素个数和cap计算得到剩余可以写入的元素个数

• eof 表示 reader 是否读取结束，状态由队列当前元素个数和 writer 是否写入结束共同决定

• pop_output 同样也要计算读取个数

总结

• 通过 linux 自带的指令体验了一下 http 请求

• 要求我们自己实现一个简单的 get_URL 函数去发送请求并获取结果，涉及到 Socket 和网络通信的基本知识

• 最后的 An in-memory reliable byte stream 要求我们实现了一个生产者消费者模型，还是比较有意思的

简介

本文是阅读4.2 TCP 重传、滑动窗口、流量控制、拥塞控制 | 小林coding (xiaolincoding.com)的笔记，想要了解更多细节请看原文

• 流量控制：针对发送方和接收方速度不匹配的问题，限制发送方的速度，是端对端的场景

• 拥塞控制：根据整个网络环境来调整发送速度，避免引起网络拥塞导致传输质量下降，是针对整个网络环境而言的

重传机制

针对网络环境不稳定，可能会出现丢包情况设计的补偿机制。一共有四种：超时重传，快速重传，SACK方法，D-SACK方法

• 超时重传：设计一个时间间隔

• 快速重传：重复3次ACK就重传

• SACK 方法：通过额外信息告知发送方如何重传

• Duplicate SACK：告知发送方丢失包的原因

超时重传

• 如果RT0过小的时候，可能会频繁传输已经接受到的数据

• 如果RT0过大，接收方会迟迟收不到丢失的数据包

快速重传

• 重传单个包：重传效率很低，如果ACK3也发生丢失，那么接下来收到3个ACK3，才能重传

• 重传所有包：如果没有发生丢失，会发送大量的重复数据，导致资源浪费

SACK方法

DSACK方法

• 可以让发送方知道重传的原因

• 可以知道哪些数据是被重复接收的。

滑动窗口

在HTTP1.1中，开启管道后也是类似的通信方式，每次都可以发送一批数据

• 已经发送且收到ACK的数据

• 发送窗口：已经发送但未收到ACK的数据

• 可用窗口：未发送但是可以发送的数据

• 未发送且超过接收方处理范围的数据

• SND.WND：表示发送窗口的大小（大小是由接收方指定的）；

• SND.UNA（Send Unacknoleged）：是一个绝对指针，它指向的是已发送但未收到确认的第一个字节的序列号，也就是 #2 的第一个字节。

• SND.NXT：也是一个绝对指针，它指向未发送但可发送范围的第一个字节的序列号，也就是 #3 的第一个字节。

• 指向 #4 的第一个字节是个相对指针，它需要 SND.UNA 指针加上 SND.WND 大小的偏移量，就可以指向 #4 的第一个字节了。

• RCV.WND：表示接收窗口的大小，它会通告给发送方。

• RCV.NXT：是一个指针，它指向期望从发送方发送来的下一个数据字节的序列号，也就是 #3 的第一个字节。

• 指向 #4 的第一个字节是个相对指针，它需要 RCV.NXT 指针加上 RCV.WND 大小的偏移量，就可以指向 #4 的第一个字节了。

流量控制

• 接收方告诉小窗口给发送方

• 发送方可以发送小数据

• 接收方不告知小窗口

• 发送方等待一批数据后再发送

怎么让接收方不通告小窗口呢？

怎么让发送方避免发送小数据呢？

• 条件一：要等到窗口大小 >= MSS 并且 数据大小 >= MSS；

• 条件二：收到之前发送数据的 ack 回包；

if 有数据要发送 {
    if 可用窗口大小 >= MSS and 可发送的数据 >= MSS {
    	立刻发送MSS大小的数据
    } else {
        if 有未确认的数据 {
            将数据放入缓存等待接收ACK
        } else {
            立刻发送数据
        }
    }
}

拥塞控制

什么是拥塞窗口

• rwnd：接收窗口

• swnd：发送窗口

• cwnd：拥塞窗口

• 只要网络中没有出现拥塞，cwnd 就会增大；

• 但网络中出现了拥塞，cwnd 就减少；

• 慢启动

• 拥塞避免

• 拥塞发生

• 快速恢复

慢启动

• 当cwnd < ssthresh，使用慢启动算法

• 当cwnd ≥ ssthresh，使用拥塞避免算法

拥塞避免

• 当 8 个 ACK 应答确认到来时，每个确认增加 1/8，8 个 ACK 确认 cwnd 一共增加 1，于是这一次能够发送 9 个 MSS 大小的数据，变成了线性增长。

拥塞发生算法

• 超时重传

• 快速重传

• ssthresh 设为 cwnd/2，

• cwnd 重置为 1 （是恢复为 cwnd 初始化值，我这里假定 cwnd 初始化值 1）

• cwnd = cwnd/2 ，也就是设置为原来的一半;

• ssthresh = cwnd;

• 进入快速恢复算法

快速恢复

• cwnd = cwnd/2 ，也就是设置为原来的一半;

• ssthresh = cwnd;

• 拥塞窗口 cwnd = ssthresh + 3 （ 3 的意思是确认有 3 个数据包被收到了）；

• 重传丢失的数据包；

• 如果再收到重复的 ACK，那么 cwnd 增加 1；

• 如果收到新数据的 ACK 后，把 cwnd 设置为第一步中的 ssthresh 的值，原因是该 ACK 确认了新的数据，说明从 duplicated ACK 时的数据都已收到，该恢复过程已经结束，可以回到恢复之前的状态了，也即再次进入拥塞避免状态；

1. 在快速恢复的过程中，首先 ssthresh = cwnd/2，然后 cwnd = ssthresh + 3，表示网络可能出现了阻塞，所以需要减小 cwnd 以避免，加 3 代表快速重传时已经确认接收到了 3 个重复的数据包；

2. 随后继续重传丢失的数据包，如果再收到重复的 ACK，那么 cwnd 增加 1。加 1 代表每个收到的重复的 ACK 包，都已经离开了网络。这个过程的目的是尽快将丢失的数据包发给目标。

3. 如果收到新数据的 ACK 后，把 cwnd 设置为第一步中的 ssthresh 的值，恢复过程结束。

• 首先减半cwnd，然后将阈值设置为减半后的cwnd

• 进入恢复阶段，此时的目标是将数据包尽可能的重传给对方，cwnd += 3表示之前接收了3个相同的ACK，然后进入线性增长

• 如果收到新的ACK，表示恢复阶段结束，将cwnd设置回阈值，避免拥塞

Ref

简介

make

func TestMake(t *testing.T) {
	var m1 map[int]string
	fmt.Printf("%#v\n", m1)

	m2 := make(map[int]string)
	fmt.Printf("%#v\n", m2)

	var c1 chan string
	fmt.Printf("%#v\n", c1)

	c2 := make(chan string)
	fmt.Printf("%#v\n", c2)
}

map[int]string(nil)
map[int]string{}
(chan string)(nil)
(chan string)(0x140000c0240)

new

func TestNew(t *testing.T) {
	var p1 *int
	a := 1
	// fmt.Println(*p1) p1 is nil, panic
	p1 = &a
	fmt.Println(*p1)

	p2 := new(int)
	fmt.Println(*p2)
	p2 = &a
	fmt.Println(*p2)
}

1
0
1

func TestNew2(t *testing.T) {
	var car1 *Car
	InnerCar := Car{}
	car1 = &InnerCar

	var car2 *Car = new(Car)

	car3 := &Car{} // 最简洁的方式

	car4 := new(Car)

	fmt.Println(car1.id)
	fmt.Println(car2.id)
	fmt.Println(car3.id)
	fmt.Println(car4.id)
}

0
0
0
0

如果x是指针，&x里面属性集合包含了m，那么x.m和(&x).m是等价的，Go会自动转换

扩展

指针比较原则

• 只有同类型的指针才能比较

./slice_test.go:120:17: invalid operation: p4 == p5 (mismatched types *int and *string)
note: module requires Go 1.18

• 指针指向同一个对象，或者都是nil的时候比较结果是true

• 否则比较结果都是false

func TestNil(t *testing.T) {
	var p1 *int
	var p2 *int
	a := 1
	p3 := new(int)
	p3 = &a
	p4 := &a

	fmt.Println(p1 == p2) // true, p1 and p2 is nil
	fmt.Println(p2 == p3) // false, p2 is nil, p3 non-nil 
	fmt.Println(p4 == p3) // true, p3 and p4 指向同一个对象
}

传引用？还是传值？

• 引用类型：指针、slice、map、channel、接口、函数等

• 非引用类型：int、string、float、bool、数组和struct

func TestModify(t *testing.T) {
	a := 1
	modifyInt(a)
	fmt.Println(a) // 没有改变

	b := make([]int, 3)
	modifySlice(b)
	fmt.Println(b) // 被改变了
}

-1
1
[1 0 0]
[1 0 0]

Ref