上次说到在Ubuntu系统上安装MySQL8.0之后默认是没有密码的，如果想设置密码需要写成ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'xxx'; 的形式，其实在用这种方式之前，我还使用功能了mysql_secure_installation这个MySQL自带的程序来设置密码，但是没生效，为什么这个看起来很正规的方式不生效的呢？接下来一起找找原因。

使用mysql_secure_installation

使用步骤比较简单，就按照提示来输入就可以了，这是我第二次运行，第一次运行时还要加个 ‘Would you like to setup VALIDATE PASSWORD component?’ 步骤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

root@w-dev:~# mysql_secure_installation

Securing the MySQL server deployment.

Enter password for user root:
The 'validate_password' component is installed on the server.
The subsequent steps will run with the existing configuration
of the component.
Using existing password for root.

Estimated strength of the password: 50
Change the password for root ? ((Press y|Y for Yes, any other key for No) : y

New password:

Re-enter new password:

Estimated strength of the password: 50
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : y
By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.

Remove anonymous users? (Press y|Y for Yes, any other key for No) : y
Success.


Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.

Disallow root login remotely? (Press y|Y for Yes, any other key for No) : y
Success.

By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.


Remove test database and access to it? (Press y|Y for Yes, any other key for No) : y
 - Dropping test database...
Success.

 - Removing privileges on test database...
Success.

Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.

Reload privilege tables now? (Press y|Y for Yes, any other key for No) : y
Success.

All done!

那么这个程序具体干了哪些事呢，下面来解释一下。

mysql_secure_installation 是一个 MySQL 提供的命令行工具，用于帮助加强和改善 MySQL 服务器的安全性。当首次安装 MySQL 后，运行此工具可以执行一系列的操作来提高 MySQL 服务器的安全性，并确保默认设置不会导致潜在的安全漏洞。以下是 mysql_secure_installation 工具执行的主要任务：

设置 root 密码： 如果您在安装 MySQL 时没有为 root 用户设置密码，mysql_secure_installation 会提示您设置 root 密码。设置 root 密码是非常重要的，因为 root 用户具有最高的权限，拥有对 MySQL 服务器的完全控制。

删除匿名用户： mysql_secure_installation 会删除默认情况下存在的匿名用户。匿名用户是指没有用户名和密码就能访问 MySQL 服务器的用户。删除这些用户可以减少潜在的安全风险。

禁止远程 root 登录： 默认情况下，MySQL 允许 root 用户从任何主机登录。mysql_secure_installation 会提示您是否禁止 root 用户从远程主机登录，以减少潜在的远程攻击风险。

删除测试数据库： 默认情况下，MySQL 安装包含一个名为 “test” 的测试数据库，这个数据库可能会成为潜在的攻击目标。mysql_secure_installation 会提示您是否删除测试数据库。

刷新权限： 完成上述任务后，mysql_secure_installation 会刷新 MySQL 权限表，以确保更改生效。

mysql_secure_installation 工具有助于在 MySQL 安装完成后采取一些基本的安全措施，以减少潜在的风险和攻击。然而，这只是开始，为了更好地保护 MySQL 服务器和数据，您还应该采取其他安全措施，如定期备份、限制用户权限、监控数据库活动等。

mysql_secure_installation 为什么设置root密码无效

看上面的描述这个程序挺靠谱的，为啥设置密码不好使呢？遵循着网络大神们的脚本，我找到了一个 mysql_secure_installation.sh脚本，来自[twitter-forks/mysql]开源库，其中包含这样一段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

esc_pass=`basic_single_escape "$password1"`
do_query "UPDATE mysql.user SET Password=PASSWORD('$esc_pass') WHERE User='root';"
if [ $? -eq 0 ]; then
echo "Password updated successfully!"
echo "Reloading privilege tables.."
reload_privilege_tables
if [ $? -eq 1 ]; then
    clean_and_exit
fi
echo
rootpass=$password1
make_config
else
echo "Password update failed!"
clean_and_exit
fi

"UPDATE mysql.user SET Password=PASSWORD('$esc_pass') WHERE User='root';" 这个脚本里居然用了我们之前提到的已经失效的更新方式，但是我发现我在Ubuntu系统下安装的mysql_secure_installation是一个二进制程序，不是shell脚本，所以我又找到了mysql的源码程序，其中包含这样一段：

1
2
3
4
5
6
7
8
9
10
11

  query =
      (char *)my_malloc(PSI_NOT_INSTRUMENTED, password_len + 50, MYF(MY_WME));
  end = my_stpmov(query, "SET PASSWORD=");
  *end++ = '\'';
  end += mysql_real_escape_string_quote(mysql, end, password,
                                        (ulong)password_len, '\'');
  *end++ = '\'';
  if (mysql_real_query(mysql, query, (ulong)(end - query))) {
    my_free(query);
    return false;
}

里面包含了"SET PASSWORD="的字样，看起来不太靠谱的样子，需要注意的是，在 MySQL 5.7 版本之后，SET PASSWORD 命令已被弃用，推荐使用 ALTER USER 命令来修改密码。例如：

1

ALTER USER 'root'@'localhost' IDENTIFIED BY '新密码';

这个命令更加直观，并且与最新版本的 MySQL 兼容。同样，将 '新密码' 替换为您希望设置的新密码。

难道是MySQL 8.0没有更新工具的代码？暂时不得而知，这或许就是mysql_secure_installation设置密码不生效的原因。

ALTER USER再生事端

前文提到了一种更加直观的设置新密码的方式 ALTER USER 'root'@'localhost' IDENTIFIED BY '新密码';，但是在我这行不通，不仅我这行不通，网上也有很多人说设置不了，需要加上插件名称 WITH mysql_native_password，改为 ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '新密码'; 才可以，这又是为什么呢？

执行 select host,user,plugin,authentication_string from mysql.user; 语句查看发现：

1
2
3
4
5
6
7
8
9
10
11

mysql> select host,user,plugin,authentication_string from mysql.user;
+-----------+------------------+-----------------------+------------------------------------------------------------------------+
| host      | user             | plugin                | authentication_string                                                  |
+-----------+------------------+-----------------------+------------------------------------------------------------------------+
| localhost | zone1            | mysql_native_password | *4C7684A2CD28A1C3C55CC832E6O817FCE3C5B5DB                              |
| localhost | mysql.infoschema | caching_sha2_password | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED |
| localhost | mysql.session    | caching_sha2_password | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED |
| localhost | mysql.sys        | caching_sha2_password | $A$005$THISISACOMBINATIONOFINVALIDSALTANDPASSWORDTHATMUSTNEVERBRBEUSED |
| localhost | root             | auth_socket           |                                                                        |
| localhost | admin            | mysql_native_password | *F52COBE5FFB5FFCCD5BFD976OADEB81081AE4787                              |
+-----------+------------------+-----------------------+------------------------------------------------------------------------+

原来每个账户还有默认的不同的密码管理插件，用于验证和管理用户密码，mysql_native_password、auth_socket和caching_sha2_password这三种插件的含义如下：

mysql_native_password

• 加密算法： 使用较旧的哈希算法，如SHA-1或SHA-256，取决于 MySQL 版本。
• 认证方式： 用户密码以哈希形式存储在系统表中，服务器在用户登录时将明文密码哈希并与数据库中存储的哈希进行比较。
• 支持远程登录： 支持远程密码登录，可以从远程主机登录 MySQL。
• 适用场景： 适用于需要与旧版 MySQL 兼容或需要与其他应用程序或系统进行集成的情况。

caching_sha2_password

• 加密算法： 使用 SHA-256 进行加密，提供更高级别的安全性。
• 支持版本： 从 MySQL 5.7.4 开始，caching_sha2_password 成为默认的密码插件。
• 认证方式： 用户密码以加密形式存储在系统表中，并且在用户登录时，服务器将明文密码哈希并与数据库中存储的哈希进行比较。
• 支持远程登录： 支持远程密码登录，可以从远程主机登录 MySQL。

auth_socket

• 认证方式： 不存储密码哈希，而是依赖于操作系统（Linux）的用户认证机制。只有与操作系统用户账户关联的 MySQL 用户可以登录，而不需要密码。
• 适用场景： 通常用于本地连接，因为它要求数据库用户和操作系统用户名称一致。
• 安全性： 提供了一定的安全性，因为不需要存储密码哈希，但需要确保服务器的用户账户和 MySQL 用户账户的一致性。

总结来说，这些密码插件之间的区别主要涉及到加密算法、认证方式以及适用场景。caching_sha2_password 提供更高级别的安全性，而 auth_socket 依赖于操作系统用户认证机制，mysql_native_password 则提供与旧版 MySQL 兼容性。使用前应根据安全性需求、用户管理和应用程序集成的要求来选择合适的密码插件。一般来说，推荐使用较新且安全性更高的密码插件，如caching_sha2_password。

测试后发现，MySQL8.0默认安装后root用户的默认插件是 auth_socket，这种插件没办法设置密码，所以指定插件为 mysql_native_password 时就可以设置密码了，但是根据建议，我们应该选择 caching_sha2_password插件。

肯定好使的MySQL初始化方法

• apt install mysql-server
• mysql
• ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY '新密码';
• flush privileges;
• exit;

总结

• 安装MySQL8.0后使用ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'xxx';设置密码
• mysql_secure_installation工具不好使的原因目前来看是源代码没有工具的源代码没有及时更新，与MySQL版本不匹配
• mysql_secure_installation另外的几项功能，比如删除匿名用户、删除测试数据库、禁止远程登录在安装完貌似都处理好了
• 综上来看，难道mysql_secure_installation工具已经被废弃了？

你们的一切都是我的，只要留心你将获得无穷的助力，很多东西不必从头开始，既然做不成巨人，就从巨人的肩膀上出发吧~

证件照尺寸查询
一寸 295413px | 2535mm
二寸 413579px | 3549mm
小一寸 260378px | 2232mm
大一寸 390567px | 3348mm
小二寸 413531px | 3545mm
大二寸 413626px | 3553mm
三寸 650992px | 5584mm
四寸 8981181px | 76100mm
五寸 10501500px | 89127mm

2023-10-8 20:56:28

源于上一篇中提到了 decltype是一个关键字，所以去查了现有的关键字列表，其实我对C/C++的关键字还停留在上世纪大概30多个的时代，虽然知道C++加了 auto、constexpr 等关键字，但查询过后才发现原来他扩充到了将近100个，而C语言的关键字也扩到了六七十个，有点震惊了。

关键字列表

这份列表来源于cppreference，感兴趣的可以去看原文，下面对这些关键字进行一个简单的介绍，有些还是很陌生的。

关键字含义

总结

• C++关键字从C++11开始快速扩张，到C++20标准已经有100个左右了
• C语言关键字发展到现在也有60多个了
• 像 xor_eq、or_eq 这些关键字就是对原来的运算符号换了个写法，感觉上没有什么用，只是不用敲特殊符号了

好日子都是自己争取来的~

2023-10-7 23:34:23

根据我目前测试的情况来看，这个问题的答案是【确实可以为所欲为】，事情的起因是这样的，一次偶然的机会我发现Ubuntu20.04系统上通过 sudo apt install mysql-server 命令安装的MySQL服务器，使用root账号登录无论输入什么密码都可以成功进入，多次尝试后才知道原来root用户默认没有密码，这可是让我惊呆了，居然还可以这样，为了服务器的安全，我必须给他设置个密码，在不断尝试的过程中引发了标题中的疑问。

修改root密码

修改MySQL用户root密码在网络上充斥着各种各样的版本，最常见的这种在MySQL8.0中已经不生效了，错误示例如下：

1

UPDATE user SET authentication_string = PASSWORD('iL1jfLqUSfmTECXRi4nO') WHERE User = 'root';

目前测试在MySQL8.0版本中可行的设置root密码的方式为：

1
2
3

USE mysql;
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'iL1jfLqUSfmTECXRi4nO';
FLUSH PRIVILEGES;

产生疑问

root用户的密码是设置好了，这么长的密码估计破解个几年也破解不开，但是我发现安装完毕提示了这样一样配置文件 /etc/mysql/debian.cnf，打开文件内容展示如下：

1
2
3
4
5
6
7
8
9
10
11

# Automatically generated for Debian scripts. DO NOT TOUCH!
[client]
host     = localhost
user     = debian-sys-maint
password = xg9vyvjNly3vUSsm
socket   = /var/run/mysqld/mysqld.sock
[mysql_upgrade]
host     = localhost
user     = debian-sys-maint
password = xg9vyvjNly3vUSsm
socket   = /var/run/mysqld/mysqld.sock

居然是一个包含了MySQL用户和密码的未加密的文本文件，这不是在大门口的脚垫底下放上了大门的钥匙吗？关键这个debian-sys-maint虽然设计上是用于数据库维护和管理，但权限上与root几乎相同，通常在 Debian 或基于 Debian 的 Linux 发行版比如Ununtu上安装MySQL就会自动生成这个文件，看起来有点不安全啊？

于是查了相关的处理方法，都说要控制这个文件的权限，只让系统root用户可以访问它，这时我就产生了疑问，这样做安全吗？如果系统root用户被窃取了呢？那是不是完全可以通过这个文件来操控MySQL数据了，答案是很显然的。

渐渐明白

虽然说掌握了root用户就可以任意修改MySQL数据让人难以接受，但是换个角度或许就可以释然了，root可是系统里的上帝啊，控制了root用户可以任意执行 rm -rf /*，如果你知道银行卡密码当然就可以从取款机里取钱，对于操作系统也是一样，既然你是root你就掌控了这个系统里的一切。

即便没有这个/etc/mysql/debian.cnf文件，root用户还可以先关闭MySQL服务，然后通过 sudo mysqld_safe --skip-grant-tables &以跳过授权表的方式启动MySQL，此时允许你在不知道密码的情况下以 root 身份登录 MySQL，这还有什么隐私可言。再换种方式，作为root用户的我从磁盘上把MySQL存储的文件拿到其他MySQL服务器上都是可以的，所以你是防不住root上帝的。

所以刚刚那个【大门口的脚垫底下放上了大门的钥匙】的比喻不太恰当，应该是/etc/mysql/debian.cnf就像屋里的桌子上摆着的保险柜的钥匙，而你要保证大门的钥匙（root密码）不要轻易被人搞到手，像 --skip-grant-tables 这种看起来很像是后门，或者叫应急开关，实际上它的设计就是为了提供一种紧急的修复机制，用于在丧失所有密码或无法登录到 MySQL 数据库时进行数据库恢复和修复，比如紧急恢复、密码重置、修复数据库权限等等

这种设计就像是各司其职，我只负责我数据的管理与权限的分配，而用户需要保证系统很牢固，一旦你的系统被攻破我将束手就擒，做的再多也是徒劳。

总结

• MySQL8.0修改密码的方式ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'xxx';
• 文件/etc/mysql/debian.cnf是Debian系列系统上安装MySQL时自动生成的，其中的用户用于用于数据库维护和管理
• 如果忘了MySQL中root用户的密码可以通过 sudo mysqld_safe --skip-grant-tables & 启动服务来进行免密登录
• 控制了系统的root用户，你就掌控了操作系统的一切

假期归来又看了很多，也不安分了许多，或许只有通过打破常规才能获得额外的收益，否则只能是一直保持饿不死的状态

2023-10-7 20:47:41

在C++中提到推导第一个映入脑海的可能是“模板”，当然有人也可能想到 auto，这些都是和推导相关的语言语法，再比如“完美转发”等等，总是就是他们的类型不用明明白白的写出来，可以利用一种简单的方式来定义，比如 candidates 是一个字符串数组， 如果遍历它我们可以写成 for (auto& skillId : candidates)，而不用将 skillId 变量定义成 const std::string&，这在一定程度上带来了便利，今天的几个东东也是用于推导的，我们一起来看看。

它们是什么

decltype、std::declval 和 std::decay_t 都是 C++ 标准库中的类型相关工具，这些工具在 C++ 编程中提供了强大的类型推导和处理能力，使得代码更加灵活。

• decltype 是一个关键字，用于从一个表达式中推导出其类型。它通常与表达式一起使用，以便在编译时确定表达式的类型。例如：

  1 2	int x = 5; decltype(x) y = 10; // y 的类型将被推导为 int

  decltype 还可以用于推导函数返回类型，以及在泛型编程中处理模板的类型。

• std::declval 是一个函数模板，用于在不实际调用构造函数的情况下生成一个对象引用，以便在类型推导中使用。通常在需要引用某个类型的对象但实际无法创建该对象的上下文中使用，例如在函数返回类型推导中：

  1 2 3 4

  template <typename T> auto createAndProcess() -> decltype(std::declval<T>().process()) { // 此处只是用于类型推导，并不会实际创建 T 的对象 }

  在这个例子中，std::declval<T>().process() 用于推导函数的返回类型，但并不会实际调用 process 函数。

• std::decay_t 是一个类型转换工具模板，用于将给定类型的”衰变”后的类型返回。衰变指的是将类型转换为其”自然”形式，即去掉引用、添加 cv 限定符（const 和 volatile）。例如：

  1 2 3

  using T1 = std::decay_t<int&>; // T1 为 int using T2 = std::decay_t<const int>; // T2 为 int using T3 = std::decay_t<int[]>; // T3 为 int*

  std::decay_t 在模板编程中很有用，因为它可以帮助去除类型的多余限定符，使得函数模板的匹配更加精确。

通俗解释

如果看了上面的例子还是有点迷糊，那我再解释的通俗一点：

• decltype 读音为 “dee-kluh-type”，就是返回一个变量的类型，比如你有一个对象 obj 想要再定义一个和它相同各类型的变量就可以写成 decltype(obj) newObj;

• std::declval 读音为 “standard dee-cl-val”，它能返回类型 T 的右值引用，其实是一个伪实例，不会产生任何临时对象，也不会因为表达式很复杂而发生真实的计算。因为不会真正的进行构造，所以可以实现在元编程时伪构造一个没有定义默认构造函数类，还可以避开纯虚基类不能实例化的问题，说白了它就是假装创建个对象用于推导类型。

• std::decay_t 读音为 “standard dee-kay tee”，有点褪去外表直击内心的意味，就是大家一起褪去花里胡哨的修饰符，获得原始的类型，用于函数模板的匹配更加精确，比如判断类型 T是不是int，if constexpr (std::is_same_v<std::decay_t<T>, int>)

总结

• decltype 是关键字，用于有了值或对象求类型的
• std::declval 是函数模板，用于伪造一个对象但不实际构造的
• std::decay_t 是类模板，用于去除修饰符获取原始类型的
• 没想到decltype 居然是关键字，结果一查发现C++的关键字已经膨胀了，下次总结一下

当身边出现不和谐声音的时候问问自己，是不是你把他们招来的，用实力让他们闭嘴，而不要视图通过语言让他们明白

2023-9-5 21:42:25

编程语言最怕细节，怼着一个点扣能让你怀疑人生，今天就碰到这么一个问题，“C++定义一个返回值为拥有3个元素的 char 数组引用的函数”，不敢说99%的人不会，但我觉得应该有80%的人写不出来吧，要不你来试试。

分解需求

首先得能看出来这是要求定义一个函数，如果这一步就错了，那就没必要往后走了，函数有的参数没有要求，但是返回值得是一个引用，这个引用的原始类型应该为一个拥有3个元素的char类型数组，难道要这样写？

1
2
3
4

char& [3] func()
{
    //...
}

试试吧，肯定编不过的，要是这么容易就哪能让人死去活来，直接给答案了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <iostream>

const char (&getCharArray())[3] {
    static const char charArray[3] = {'A', 'B', 'X'};
    return charArray;
}

int main() {
    const char (&result)[3] = getCharArray();

    for (char c : result) {
        std::cout << c << " ";
    }

    return 0;
}

举一反三

学习要学会举一反三，把题目中的“引用”换成“指针”，再试一下，依葫芦画瓢还是很容易的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <iostream>

char (*getCharArrayPointer())[3] {
    static char charArray[3] = {'A', 'B', 'J'};
    return &charArray;
}

int main() {
    char (*result)[3] = getCharArrayPointer();

    for (int i = 0; i < 3; ++i) {
        std::cout << (*result)[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

仿佛这也不是我们常常见到的形式，对于指针作为返回值，我们常见到的应该是下面这种

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>

char* getCharArrayPointer() {
    static char charArray[10] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l'};
    return charArray;
}

int main() {
    char* result = getCharArrayPointer();

    for (int i = 0; i < 10; ++i) {
        std::cout << result[i];
    }
    std::cout << std::endl;

    return 0;
}

他们有什么区别呢？我们从定义层面来对比一下：

进行对比

• 1 2 3

  - `result` 是一个引用类型变量，被引用的类型为 `char[3]` - `sizeof(result)` == 3 - ```char (*result)[3] = getCharArrayPointer();

  • result 是一个指针类型变量，指向的类型的类型为 char[3]
  • sizeof(result) == 8
  • result++ 先后移动24个字节=8*3
• char* result = getCharArrayPointer();
  • result 是一个指针类型变量，被引用的类型为 char
  • sizeof(result) == 8
  • result++ 先后移动8个字节=8*1

有了上面的对比就可以根据区别来选择定义什么样的返回值，使用引用类型能取到被引用变量的原始大小，使用指针要注意移动的步长。

总结

• 定义一个返回定长数组引用的函数 const char (&getCharArray())[3] { //... }
• 定义一个返回定长数组指针的函数 const char (*getCharArray())[3] { //... }
• 引用不需要内存分配和释放，因为它只是目标对象的别名（存疑，在绝大多数编译器中，引用在底层是通过指针来实现的，但GPT嘴硬说不需要，表示需要继续探索）

引用在底层通过指针实现时，并不需要额外的内存分配。引用被设计为变量的别名，它并不占用额外的内存空间。引用在编译器生成的汇编代码中，会被处理为指向原始对象的指针，但是这个指针对于用户来说是透明的，不需要分配额外的内存来存储引用本身。
引用只是目标对象的别名，与指针不同，它没有自己的内存存储空间。因此，无论引用在底层是通过指针实现还是其他方式实现，都不会导致额外的内存分配。这也是为什么引用在使用上更接近于对变量的直接访问。
需要注意的是，尽管引用不需要额外的内存分配，但指针本身需要存储指向对象的地址，因此指针会占用一定的内存空间。这也是引用和指针之间的一个重要区别。

内练一口气，外练筋骨皮

2023-8-28 22:17:27

程序员真是一个活到老学到老的职业，一天不学习就会掉队，『内存顺序模型』对于我来说就是一个新的世界，虽然之前写过多线程的服务器，也处理过死锁和竞态条件等问题，但是从来没考虑过内存顺序问题，所以当我第一次看到这个概念时，整个人都是懵的，经过一段时间的学习和了解有了初步的认识，所以简单总结下来，以备后续查看，不多写，慢慢总结。

为什么要设计内存顺序模型

内存顺序模型是为了解决多线程程序中的内存一致性和可见性问题而引入的。在多线程环境下，不同线程可能同时访问和修改共享的内存，这会引发一系列并发性问题，如竞态条件、数据竞争等。内存顺序模型的目的是通过定义不同操作之间的执行顺序和可见性规则，来保证多线程程序的正确性和可预测性。主要原因如下：

1. 多线程并发问题： 在多线程程序中，线程之间可能并发地读取和写入共享内存，导致数据不一致和不可预测的行为。

2. 编译器和处理器优化： 编译器和处理器可能会对代码进行优化，例如重排指令以提高性能。这些优化可能会导致操作的执行顺序与代码中的顺序不一致，从而引发问题。

3. 硬件内存模型： 不同的计算机体系结构有不同的硬件内存模型，即不同的读写操作在不同的条件下可能表现出不同的行为。

4. 数据依赖性： 在某些情况下，某个操作的结果可能会影响后续操作的执行。内存顺序模型可以帮助定义这种数据依赖性。

内存顺序模型通过定义不同操作之间的关系，如同步、重排等，来解决上述问题。不同的内存顺序模型提供了不同的可见性和同步保证，开发者可以根据自己的需求选择适当的模型。总之，内存顺序模型是为了在多线程环境下提供一种标准化的方式来处理内存一致性和可见性问题，从而使多线程编程更加可靠和可预测，重点关注下第2点和第4点。

有人可能会说，我可以用锁来保证顺序，为什么还要设计内存顺序模型呢？

虽然锁（比如互斥锁）在多线程编程中是一种常见的同步机制，用于保护共享资源，但锁并不能解决所有的并发性问题，而且在某些情况下使用锁可能会引入性能问题。内存顺序模型的设计是为了在不同线程之间定义操作的执行顺序和可见性规则，以解决锁无法解决的一些问题，同时在一些情况下也可以提高性能。

1. 细粒度同步： 锁通常是用于保护共享资源的，但有时候我们需要更细粒度的同步，比如在不涉及共享资源的情况下也需要保证操作的顺序和可见性。

2. 原子操作： 内存顺序模型通过定义原子操作的执行顺序和可见性，可以在不使用锁的情况下确保操作的正确执行。这在一些场景下可以避免锁带来的性能开销。

3. 锁的开销： 锁在某些情况下可能引入较大的性能开销，特别是在高并发环境中。内存顺序模型提供了一种更轻量级的同步机制，可以在一些情况下取代锁，提高性能。

4. 编译器和处理器优化： 编译器和处理器对代码进行优化时可能会引入指令重排，这可能会导致锁保护下的共享资源出现问题。内存顺序模型通过规定操作的执行顺序，可以避免这种问题。

5. 原子操作的组合： 内存顺序模型的原子操作可以灵活地组合，以实现更复杂的同步和顺序要求，而不必仅仅依赖于锁。

总之，内存顺序模型和锁在多线程编程中都有其适用的场景。锁通常用于保护共享资源的访问，而内存顺序模型则用于定义操作的执行顺序和可见性，以确保多线程程序的正确性。在多线程编程中，根据具体需求和性能要求，可以选择合适的同步机制。

如果想理解内存顺序，首先要理解两个东西：同一线程中，谁先执行，谁后执行；不同线程中，切换内存的时是否会及时的把依赖数据带过去，对另一个线程可见。

常见的内存顺序模型

C++ 标准库中定义了六种内存顺序模型，用于控制多线程程序中不同操作之间的执行顺序和可见性。这些内存顺序模型通过枚举值表示，从“宽松”到“严格”的次序分别是：

1. std::memory_order_relaxed： 这是最轻量级的内存顺序模型。它不会引入任何额外的同步开销，只保证操作在时间上的顺序是正确的。即使没有明确的同步操作，也不会改变其他线程看到的操作结果。

2. std::memory_order_consume： 在 C++11 中引入，但在 C++20 中被弃用。它主要用于处理数据依赖关系，但在实际中难以实现，已经不推荐使用。

3. std::memory_order_acquire： 在执行当前操作之前，确保所有前面的读操作都完成。它提供了一种读操作同步的保证，确保读操作的结果在后续操作中是可见的。

4. std::memory_order_release： 在执行当前操作之后，确保所有后面的写操作都不会重排到当前操作之前。它提供了一种写操作同步的保证，确保写操作的结果对其他线程是可见的。

5. std::memory_order_acq_rel： 是 memory_order_acquire 和 memory_order_release 的组合。它同时提供了读和写操作的同步保证，适用于需要同时保证读写操作同步的情况。

6. std::memory_order_seq_cst： 是最严格的内存顺序模型，提供了全局的、顺序一致的保证。它确保所有操作按照一个全局的顺序执行，不会引入重排，也保证了最高级别的可见性。

根据具体的多线程编程需求，你可以选择适当的内存顺序模型，以确保正确性和性能。不同的内存顺序模型会引入不同程度的同步开销，因此需要根据实际情况权衡选择。了解这些内存顺序模型可以帮助你在多线程编程中更好地控制操作的执行顺序和可见性，每种模型具体的例子我们后面再慢慢总结。

总结

• 常见的内存顺序模型前三种：std::memory_order_relaxed、std::memory_order_acquire、std::memory_order_acquire
• 常见的内存顺序模型后三种：std::memory_order_release、std::memory_order_acq_rel、std::memory_order_seq_cst
• 其中 `std::memory_order_consume`` 在实际中难以实现，已经在 C++20 中被弃用
• 编译器和处理器对代码进行优化时可能会引入指令重排，这可能会导致锁保护下的共享资源出现问题
• 内存顺序模型通过规定操作的执行顺序，可以避免上一个问题
• 内存顺序和原子操作的引入，是为了无锁的并发编程，提高并发编程的效率

或许我就不在你规划的未来
或许她才是你唯一的偏爱
或许我就不该跟你赌未来
或许就不会深陷苦海

2023-8-24 22:57:11

说实话，这是我第一次用Shell来定义函数，之前也写了很多shell脚本，但是体量都不大，所以基本上是按照需求罗列了多个命令来实现的，这次也是一样，但是我发现重复的地方太多了，所以还是要拿出看见本事“抽象函数”来解放我懒惰的手指

具体需求

检测特定名称的进程是否存在，若不存在则重新启动这个进程

仿照着之前的类似的脚本我写出了以下函数 check_and_fix_process，仅有一个需要注意的点就是Shell函数不需要定义参数，如果用到参数直接是用 $1、 $2、 $3……依次来代替就可以了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#!/bin/bash

# 检查并修复进程的函数
function check_and_fix_process() {
        # $1 进程名
        # $2 进程ID列表文件名
        # $3 进程ID列表文件md5值

        datetime=$(date +%y%m%d%H%M%S)
        ps aux |grep "$1" |grep -v grep |awk '{print $15}' |awk -F '=' '{print $2}'|sort -n > ~/tmplist

        a=$(md5sum ~/tmplist |awk '{print $1}')
        b="$3"

        if [[ $a = $b ]]; then
                echo "check [$1 $2 $3] ok"
        else
                tmp=$(diff ~/"$2" ~/tmplist |grep ^\< |awk '{print $2}' > /tmp/tmplist)
                for i in `cat /tmp/tmplist`
                do
                        cd ~/test && grep "ID=$i" start.sh | xargs -I {} sh -c '{}'

                        echo "$datetime $i" >>~/fixtxt
                        python3 ~/send_msg.py -c "process:$i crashed; fixtime:$datetime"
                done
        fi
}

# check all process list
check_and_fix_process "AProcess" "aprocesslist" "a887eedb72472f2ad152e5e91a0727da"
check_and_fix_process "BProcess" "bprocesslist" "a887eedb72472f2ad152e5e91a0727db"

ChatGPT读代码

如果对于这段代码有不理解的地方，可以请ChatGPT来帮忙，以下内容是它的解释，不得不说真是太强大了！身为此段代码的实现者，我都描述不了这么详细

这段代码是一个 Bash 脚本，用于检查指定的进程是否正常运行，并在发现异常时进行修复操作。下面逐行解释代码：

1. function check_and_fix_process() {: 定义了一个名为 check_and_fix_process 的 Bash 函数。

2. # $1 进程名: 这是一个注释，表示函数的第一个参数是进程名。

3. # $2 进程ID列表文件名: 这是一个注释，表示函数的第二个参数是进程ID列表文件的文件名。

4. # $3 进程ID列表文件md5值: 这是一个注释，表示函数的第三个参数是进程ID列表文件的MD5值。

5. datetime=$(date +%y%m%d%H%M%S): 获取当前日期和时间，并将其格式化为”YYMMDDHHMMSS”的形式，存储在变量 datetime 中。

6. ps aux |grep "$1" |grep -v grep |awk '{print $15}' |awk -F '=' '{print $2}'|sort -n > ~/tmplist: 这一行通过一系列的管道命令来查找指定进程名 $1 的进程，提取其中的某个列（可能是进程ID），然后排序，将结果保存到文件 ~/tmplist 中。

7. a=$(md5sum ~/tmplist |awk '{print $1}'): 计算文件 ~/tmplist 的 MD5 值，并将结果保存在变量 a 中。

8. b="$3": 将第三个参数值（进程ID列表文件的MD5值）保存在变量 b 中。

9. if [[ $a = $b ]]; then: 如果变量 a 的值等于变量 b 的值（即进程ID列表文件的MD5值相匹配），则执行下面的代码块。

10. echo "check [$1 $2 $3] ok": 输出一条信息表示检查通过。

11. else: 如果进程ID列表文件的MD5值不匹配，则执行下面的代码块。

12. tmp=$(diff ~/"$2" ~/tmplist |grep ^\< |awk '{print $2}' > /tmp/tmplist): 比较进程ID列表文件（路径为 ~/"$2")和当前的进程ID列表文件 (~/tmplist)，将不匹配的部分提取出来并保存在临时文件 /tmp/tmplist 中。

13. for i in $(cat /tmp/tmplist): 循环遍历临时文件 /tmp/tmplist 中的每一行内容。

14. do: 循环体开始。

15. cd ~/test && grep "ID=$i" start.sh | xargs -I {} sh -c '{}': 这一行的作用是切换到目录 ~/test 并在 start.sh 文件中查找包含字符串 “ID=$i” 的行，然后执行找到的行（通常是一些命令）。

16. echo "$datetime $i" >>~/fixtxt: 将当前日期时间和进程ID添加到文件 ~/fixtxt 中。

17. python3 ~/send_msg.py -c "process:$i crashed; fixtime:$datetime": 调用 Python 脚本 send_msg.py 并传递一条消息，该消息包含进程ID以及修复操作的时间。

18. done: 循环结束。

19. fi: 条件分支结束。

20. }: 函数定义结束。

21. check_and_fix_process "AProcess" "aprocesslist" "a887eedb72472f2ad152e5e91a0727da": 调用 check_and_fix_process 函数，检查名为 “AProcess” 的进程是否正常运行，使用文件 “aprocesslist” 作为进程ID列表文件，并传递预期的MD5值。

22. check_and_fix_process "BProcess" "bprocesslist" "a887eedb72472f2ad152e5e91a0727db": 同上，检查名为 “BProcess” 的进程是否正常运行，使用文件 “bprocesslist” 作为进程ID列表文件，并传递预期的MD5值。

总结

• Shell脚本中的函数不需要定义参数，如果用到参数直接是用 $1、 $2、 $3……依次来代替就可以
• Shell脚本函数中使用 $1 作为参数，并不会与内部命令的 $1 冲突，因为Shell在不同的上下文中，变量的作用域是不同的

看我ge，看我nai，看我jiu，玩的开心吗？

2023-8-15 22:41:32

最近在做压力测试，对磁盘、CPU、内存等指标比较敏感，因为产生了大量的日志文件需要定期删除，于是写了个定时清理磁盘的脚本，今天早上发现内存曲线居然产生了一个漂亮的图形，不知道你们想到了什么？看到这曲线我首先想到的是《编程之美》中那个“让CPU占用率曲线听你指挥” 的面试题，是不是得加一个想内存使用率曲线听你指挥啊？

图形本尊

我所说的漂亮曲线入下图所示，是不是有一种对称美？

搭配这条曲线的还有当时的磁盘占用曲线，两幅图对比基本可以确定这两个指标是相关的

产生的原因

关于实际的原因我不能给出准确的解释，所以跑去问了GPT，它的回答内容如下，如果有不同意的小伙伴欢迎来反驳：

在Ubuntu或其他Linux操作系统中，当你删除大量磁盘文件时，可能会看到内存缓存（cache）降低而”free”（可用内存）升高的情况。这是由于Linux的内存管理机制导致的，这个机制是为了最大程度地提高系统性能。

当你删除文件时，内核会将这些文件从文件系统中删除，但为了提高文件访问的效率，已经读取的数据可能会被保留在内存的缓存中。这样，如果在不久的将来需要访问相同的文件，可以直接从内存缓存中获取，而不必从磁盘读取。这个缓存被称为”page cache”，它占用一部分内存。

当你删除大量文件时，这些文件所占用的内存缓存将被释放，以便更好地利用内存来满足其他正在运行的程序的需求。因此，内存缓存的降低是一个正常现象。

同时，”free”命令在Linux中显示的”free”内存指的是没有被使用的内存，包括未被分配的内存和被内核回收的缓存。因此，当你删除大量文件时，已释放的缓存会被计算在”free”内存中，导致”free”内存升高。

这种行为是Linux内存管理的一部分，它旨在在系统性能和内存使用之间找到平衡。当系统需要更多内存时，它可以释放缓存来满足正在运行的程序的需求。所以，不要担心这种情况，它是Linux操作系统的正常行为。

补一个长周期对比图

总结

• 想要控制好计算机资源产生自定义曲线，控制好“消耗”就可以了，但是如何控制是门学问，需要考虑的各种相关因素
• 为了提高文件访问的效率，已经读取的数据可能会被保留在内存的缓存中，其被称为”page cache”，便于下次访问直接从内存缓存中获取
• 当删除大量文件时，已释放的缓存会被计算在”free”内存中，导致”free”内存升高

风急天高猿啸哀，渚清沙白鸟飞回。无边落木萧萧下，不尽长江滚滚来~

2023-8-12 10:41:18

作为游戏人免不了听到 DAU 、UP值、留存 等名词，并且有些名词听起来还很像，特别是一款上线的游戏，这些游戏运营指标是衡量游戏业务绩效和用户参与度的重要数据，想做一个合格的游戏人得花点时间了解一下，接下来会总结一些常见的游戏运营指标及其简称。

运营指标

• DAU - 日活跃用户 (Daily Active Users)：每日登录游戏的独立用户数量
• MAU - 月活跃用户 (Monthly Active Users)：每月登录游戏的独立用户数量
• ARPU - 平均收入每用户 (Average Revenue Per User)：平均每个用户带来的收入
• ARPDAU - 每日平均收入每用户 (Average Revenue Per Daily Active User)：每日平均每个活跃用户带来的收入
• ARPPU - 平均付费用户收入 (Average Revenue Per Paying User)：平均每个付费用户带来的收入
• Retention Rate - 留存率：测量特定时间段内用户的保留情况，通常以百分比表示
• Churn Rate - 流失率：衡量用户流失的速度，通常以月度或年度为周期
• Conversion Rate - 转化率：衡量用户从免费用户转化为付费用户的比率
• LTV - 用户生命周期价值 (Lifetime Value)：预测一个用户在其使用周期内可能带来的总收入
• CAC - 用户获取成本 (Customer Acquisition Cost)：获取一个新用户所花费的成本
• ROI - 投资回报率 (Return on Investment)：衡量游戏营销和推广活动的效果
• ARPPDAU - 每日平均收入每付费用户 (Average Revenue Per Paying Daily Active User)：每日平均每个付费活跃用户带来的收入。
• ACPU - 平均成本每用户 (Average Cost Per User)：获取每个用户的平均成本
• Conversion Funnel - 转化漏斗：衡量用户从首次接触游戏到最终付费的整个过程
• UGC - 用户生成内容 (User-Generated Content)：用户创造的游戏内容，如自定义角色、地图等，对游戏社区的活跃度有影响

这些指标可以帮助游戏开发者和运营者了解游戏的商业表现和用户行为，从而优化游戏的设计和运营策略。

指标范围参考值

知道了有上述的运营指标，但是一款合格的游戏上述指标应该达到多少呢？

其实每款游戏的合格水平可能会因多种因素而有所不同，包括游戏类型、目标市场、营销策略以及开发成本等，并不是固定的标准，实际情况会受到众多因素的影响，包括游戏的质量、竞争情况、玩家喜好以及运营策略等，下面进给出一些参考值。

• DAU - 日活跃用户：数百到数千，具体取决于游戏的类型和受众规模
• MAU - 月活跃用户：数千到数万，取决于市场规模和竞争状况
• ARPU - 平均收入每用户：几美元到十几美元，视付费玩家比例而定
• ARPDAU - 每日平均收入每用户：几分到几毛美元，视玩家付费情况而定
• ARPPU - 平均付费用户收入：十美元到数十美元，取决于游戏内购的设计和价值
• Retention Rate - 留存率：20%-50% 之间，高于 50% 为很好的表现。
• Churn Rate - 流失率：低于 10% 为很好的表现。
• Conversion Rate - 转化率：2%-5% 之间，高于 5% 为不错的表现。
• LTV - 用户生命周期价值：数十美元到数百美元，取决于玩家的长期付费情况。
• CAC - 用户获取成本：通常 LTV 的 1/3 到 1/2，以确保收益能覆盖用户获取成本。

这些值仅供参考，并不适用于所有情况。游戏开发者和运营者需要根据自己的情况制定合适的目标，并随着游戏的运营进行不断优化。同时，密切关注竞争对手的表现也是非常重要的。

留存指标的意义

留存率是衡量用户参与度和游戏粘性的重要指标之一。它衡量了一段时间内用户的持续参与情况，通常以百分比表示。针对回合制卡牌游戏，留存率的及格线会受到多种因素的影响，包括游戏的类型、受众群体、市场竞争、游戏质量、运营策略等等

• 次日留存率：在 30% - 40% 以上被视为相当不错的表现。这意味着有相当比例的玩家在第一次体验游戏后仍然对游戏感兴趣，并愿意在第二天继续游戏。

• 3日留存率：通常在 20% - 40% 之间被视为良好的表现。这表示在游戏初始安装后的头三天内，有相当比例的玩家愿意继续登录游戏。

• 7日留存率：较高的及格线通常在 15% - 30% 左右。相比于3日留存，7日留存更能体现游戏对玩家的长期吸引力。
• 月留存率：这个指标较难界定“及格线”，但在 10% - 20% 以上的范围内被视为不错的表现。月留存更考验游戏的长期吸引力和社区活跃度。

需要注意的是，这些及格线可能会根据不同的情况有所变化。例如，对于新发布的游戏，初始留存率可能会较高，但随着时间推移，可能会逐渐下降。此外，针对特定类型的玩家群体，留存率也可能有所不同。

这三个留存率指标都有助于了解游戏的玩家保持情况，但值得注意的是，不同类型的游戏可能会有不同的留存率标准，而且这些指标可能会受到市场、竞争、游戏类型以及运营策略的影响。提高留存率是游戏开发者和运营者追求的目标，因为更高的留存率通常意味着更好的长期经营和用户忠诚度。

总结

• DAU - 日活跃用户 (Daily Active Users)：每日登录游戏的独立用户数量
• ARPU - 平均收入每用户 (Average Revenue Per User)：平均每个用户带来的收入
• LTV - 用户生命周期价值 (Lifetime Value)：预测一个用户在其使用周期内可能带来的总收入
• Retention Rate - 留存率：测量特定时间段内用户的保留情况，通常以百分比表示

挥手自兹去，萧萧班马鸣~

2023-8-10 22:34:28

最近遇到的一个问题，在Ubuntu系统下修改/etc/security/limits.conf不生效，查了多种资料都说不用重启，但是我改完就是不生效，多次尝试之后发现Ubuntu系统有毒。

尝试过程

通过 ulimit -n 命令可以查询到当前系统单个进程允许打开的文件描述符：

1
2

$ ulimit -n
1024

才1024个，放到游戏服务器上显然不太够用，于是使用命令 ulimit -n 65535 手动调大了，但是这种方式只能对当前登录session有效，下次新的连接再启动进程数值又回去了，想要一劳永逸，就得修改/etc/security/limits.conf文件，打开文件加入下面的内容：

1
2

* soft nofile 65535
* hard nofile 65535

关闭文件，退出重新登录，运行 ulimit -n 命令发现还是1024，奇怪！

后续有尝试了网络上常常提到的 pam_limits 配置，按步骤修改后不好使，查找 /etc/systemd/user.conf 文件配置也无法对应，最后查到一种解决方式，将 limits.conf 文件中的 * 写成具体的用户名就好了

1
2

root soft nofile 65535
root hard nofile 65535

之前我在CentOS系统上一直是用星号的，每想到在Ubuntu系统上被坑了一次

总结

• ulimit -n 65535 命令可以直接将单个进程打开的文件描述符限制扩大到65535
• 修改 /etc/security/limits.conf 文件不需要重启系统，退出ssh重新登录记录
• 在CentOS中修改 limits.conf 文件中的用户名可以用 *，但是在Ubuntu中需要写具体用户名

高位易跌倒，高位易昏头，面对巨大的诱惑，想要做到不被拉下水是在太难了~

2023-8-10 22:34:28

大雨哗哗哗，叫车无人接，把最近用到的命令总结一下，方便日后的拿来主义。

>/dev/null 2>&1

>/dev/null 2>&1 & 是一个常见的 Shell 命令行用法，用于在 Linux 或类 Unix 系统上运行一个程序并将其输出（标准输出和标准错误输出）重定向到 /dev/null，同时将程序在后台（background）运行。

接下来可以逐步解释下各部分的作用：

• >：重定向符号，用于将输出重定向到指定的文件或设备。

• /dev/null：在 Unix 系统上，/dev/null 是一个特殊的设备文件，它会将所有写入它的内容都丢弃，相当于一个空黑洞。将输出重定向到 /dev/null 就意味着将输出丢弃，不会显示在终端或记录到文件中。

• 2>：重定向标准错误输出的符号。2 表示标准错误流，也称为文件描述符 2。

• &1：将标准错误输出重定向到标准输出的符号。&1 表示文件描述符 1，而标准输出的文件描述符也是 1。这样，就将标准错误输出和标准输出合并到一起，都重定向到了 /dev/null。

• &：在命令行中，& 符号用于将命令置于后台运行，使得当前终端可以继续输入其他命令，而不需要等待前台命令的完成。

综合起来，>/dev/null 2>&1 & 的作用是将某个程序在后台运行，并将其标准输出和标准错误输出都丢弃，不在终端中显示或记录。这样做常常用于运行不需要显示输出的程序或脚本，并且让它在后台运行，不占用终端的输入输出。

去除文件夹下所有文本文件的行末空格

想要达到这个目的有多种实现方式，比如：

1

find . -type f -exec egrep -l " +$" {} \; | grep -v xxx | xargs sed -i 's/[ ]*$//g'

再比如：

1

find xxx -type f -name "*.txt" -exec sed -i 's/[ \t]*$//' {} \;

主要部分的含义：

• -type f：-type f 参数用于限制 find 命令只查找普通文件（非目录、符号链接等）。

• -name "*.txt"：-name "*.txt" 参数用于匹配文件名，这里匹配以 .txt 结尾的文件。您可以根据实际需要修改为其他文件扩展名。

• -exec：-exec 参数用于对找到的每个文件执行后面的命令。

• sed -i 's/[ \t]*$//' {}：sed 命令用于进行文本替换。-i 参数表示直接在原文件上进行修改（in-place），而不是在终端输出。s/[ \t]*$// 是一个替换表达式，用于匹配行末的空格（包括空格和制表符），将其替换为空。

• {}：find 命令中的占位符，代表找到的每个文件名。

• \;：find 命令中的结束符，表示 -exec 参数的结束。

还可以利用管道来实现，使用管道 (Pipeline) 去掉一个文件夹下所有文本文件行末的空格，可以结合 find 命令和 sed 命令来完成。管道允许将一个命令的输出作为另一个命令的输入，以实现更复杂的文本处理，如下：

1

find xxx -type f -name "*.txt" -print0 | xargs -0 sed -i 's/[ \t]*$//'

各部分的含义：

• find xxx -type f -name "*.txt" -print0：find 命令查找指定目录 xxx 下的所有以 .txt 结尾的文本文件，并使用 -print0 参数将文件名以空字符作为分隔符打印出来。这是为了处理文件名中可能包含空格或特殊字符的情况。

• |：管道符号，将 find 命令的输出传递给下一个命令。

• xargs -0：xargs 命令用于接收管道的输入，并将其作为参数传递给后面的命令。-0 参数表示使用空字符作为输入分隔符，与 find 命令的 -print0 参数相对应。

• sed -i 's/[ \t]*$//'：sed 命令用于进行文本替换，同样使用 -i 参数进行直接修改。s/[ \t]*$// 是一个替换表达式，用于去掉行末的空格。

与之前的命令相比，这个命令通过管道一次性处理了多个文件，效率可能会更高一些。

总结

• 将某个程序在后台运行，并将其标准输出和标准错误输出都丢弃，可以在运行命令后加 >/dev/null 2>&1
• 去除文件行末空格 find . -type f -exec egrep -l " +$" {} \; | grep -v xxx | xargs sed -i 's/[ ]*$//g'

机会很重要，选择也很重要，在机会面前做出选择同样很重要，不要过分夸大未选择的那条路，很多时候即使重新选择一次，大部分人的道路不会发生改变，已经定型了…

我也不知道是熬到了司机来，还是把前边排队的人熬走了，现在还有3人排队~

2023-8-1 01:47:54

distcc 是一个用于分布式编译的工具，它可以将编译任务分发到多台计算机上，从而加快代码编译的速度。distcc 允许多台计算机共同参与编译过程，利用分布式系统的优势来并行处理编译任务，从而提高编译速度和性能。

在传统的编译过程中，代码被发送到一台计算机上，然后由该计算机上的编译器进行编译。这种方式在大型项目中可能会消耗大量时间，特别是当项目变得复杂并且代码量增加时，编译时间会显著增加。

distcc 解决了这个问题，它通过在局域网内或远程服务器上设置 distcc 客户端和 distccd 服务器来实现分布式编译。distcc 客户端将编译任务发送到 distccd 服务器，而服务器上的 distccd 守护进程将任务分发给多个可用的编译器进行并行编译。一旦编译完成，编译结果将发送回到 distcc 客户端，然后再进行链接等后续处理。

通过 distcc 的使用，编译过程可以更快地完成，节省了开发人员的时间，并且利用了局域网或网络上的多台计算机的计算资源，提高了编译效率。

distcc支持多种编程语言，包括C，C ++，Objective-C和Fortran。它是一个开源软件，可以在Linux，Unix和Windows等平台上运行。

问题

前面主要简单的叙述了什么是distcc，我遇到的问题就是前几天用的好好的distcc，最近总是报出以下错误：

distcc[18595] (dcc_pump_sendfile) ERROR: sendfile failed: Broken pipe
distcc[18595] (dcc_readx) ERROR: unexpected eof on fd6
distcc[18595] (dcc_r_token_int) ERROR: read failed while waiting for token “DONE”
distcc[18595] (dcc_r_result_header) ERROR: server provided no answer. Is the server configured to allow access from your IP address? Is the server performing authentication and your client isn’t? Does the server have the compiler installed? Is the server configured to access the compiler?
distcc[18595] Warning: failed to distribute /home/demo/workspace/x_server/gameserver/battle/effect/addbuffroundeffectexecutormodule.cpp to 10.12.7.181, running locally instead

先是Google一番没找到解决方案，又去问了ChatGPT，给出的答案偏向于权限问题，这就很奇怪，我之前用的好好的，为啥突然会出现权限问题，他可能是错误描述的影响：

ERROR: server provided no answer. Is the server configured to allow access from your IP address? Is the server performing authentication and your client isn’t? Does the server have the compiler installed? Is the server configured to access the compiler?

解决方案

一开始我也是朝着配置和权限来努力的，可是怎样重启服务或是修改配置都不好使，查了防火墙也没问题，telnet 3262端口也是通的，最终我把目光定位到了sendfile failed: Broken pipe 这句话，不会是磁盘满了吧？df一查还真是，唉，折腾了好久~

-exec command ; 和-exec command {} +区别

这篇内容有点少，补充一个我今天刚学到的知识点吧~

在 find 命令中，-exec command ; 和 -exec command {} + 是两种不同的方式来执行指定的命令。

-exec command ;

这种方式将对 find 命令找到的每个文件依次执行一次指定的命令。每找到一个匹配的文件，都会执行一次该命令。例如：

1

find /path/to/search -type f -name "*.txt" -exec echo {} \;

上述命令会在 /path/to/search 目录及其子目录中搜索所有扩展名为 .txt 的文件，并依次输出每个文件的名称。

-exec command {} +

这种方式也会执行指定的命令，但是它会将多个找到的文件一起传递给命令进行一次执行。这种方式通常比使用 ; 更高效，因为它可以将多个文件组合在一起，减少了命令的调用次数。例如：

1

find /path/to/search -type f -name "*.txt" -exec cat {} +

上述命令会在 /path/to/search 目录及其子目录中搜索所有扩展名为 .txt 的文件，并将它们一起传递给 cat 命令进行合并输出。

如果只需要针对每个文件执行一次命令，可以使用 -exec command ;。如果想要将多个文件组合在一起一次性执行命令，可以使用 -exec command {} +。选择哪种方式取决于具体的需求和效率考虑。

总结

• 当distcc突然不好使并提示sendfile failed: Broken pipe的时候去看看服务器磁盘是不是满了
• 使用 -exec command ; 将对每个匹配的文件分别执行一次命令。
• 使用 -exec command {} + 将多个匹配的文件一起传递给命令执行。

今朝有今朝醉不是一种豁达，或许是一种无可奈何吧~

2023-7-21 22:31:00

每次使用文件拷贝 cp 命令或者同步 rsync 命令时都会有些疑惑，不知道路径末尾的 /需不需要加，隐约感觉到有些不同，但具体的区别却不太清楚，需要实际操作一次才能知道了，下面就来试一试。

rsync 命令的基础格式为 rsync [OPTION...] SRC... [DEST]，可用于本地文件的同步，如果想同步远程文件也可以，将 SRC 或者 DEST 改成带有IP的远程地址就可以了，但是最多支持一个远端地址，不能两个目录都写成remote格式，其实这个命令之前也用过好几次了，比如 《linux环境下利用rsync+find实现同步指定时间段文件》，这次来看看结尾的 / 到底有什么影响。

准备测试环境

测试环境很简单，只要准备源目录和目标目录就可以了，为了测试各种情况，我需要创建一个比较丰富的目录结构，需要测试的情况有原目录A结尾有无 /，目标目录B结尾有无 /，目标目录B中有无同名A文件夹，A文件夹是否为空，目标目录B中有无同名A文件，目标目录不存在，各种情况组合应该是 2 * 2 * 5 = 20种，这不是全部的情况，但已经覆盖大部分想要测试的问题了，因为使用 rsync 通常是同步目录，暂时不考虑源和目标是文件的情况。

测试目录结构如下：

事先说明，以下的每项测试都是在这个原始的基础上进行的，每项测试完成会将目录还原，用以比较不同命令参数下结果的区别，测试选项统一使用 -a --delete。

rsync测试

测试过程

分小组进行，便于对比

1. 源目录和目标目录结尾都没斜杠 SRC DEST
   
   
   
   
   
   这种情况的测试结论为，不论目标目录是否存在（没有就创建），都会将源目录拷贝到目标目录之内形成同名文件夹，如果原来有同名文件或文件夹就覆盖掉，如果不加 --delete 就会合并。

2. 源目录结尾有斜杠而目标目录结尾没斜杠 SRC/ DEST
   
   为了能更快的看到效果，这次我直接一个命令把5种情况都测试了，结论是如果源目录结尾有斜杠，会将源目录中的内容同步到目标目录之内，覆盖掉目标目录之内原有的内容，如果不加 --delete 就会和目标目录合并。

3. 源目录结尾没有斜杠而目标目录结尾有斜杠 SRC DEST/
   
   还是采用了一个命令测试5种情况的方式，与第一组测试结果一致，都是在目标目录下增加了源目录文件夹，内容保持一致。

4. 源目录结尾和目标目录结尾都有斜杠 SRC/ DEST/
   
   测试结果与第二组一致，不再赘述。

   测试结论

在 rsync 中，执行结果只与原始目录结尾有无斜杠有关，如果不传递原始目录（也称为源目录）的末尾斜杠（/），它将尝试在目标目录中创建源目录的副本，而不是将源目录的内容复制到目标目录中。换句话说，如果没有末尾斜杠，rsync 会尝试在目标目录下创建一个与源目录同名的目录，并将源目录的内容复制到这个同名目录中。

可以简单记忆为，如果原始目录没加末尾斜杠，表示将整个目录拷贝到目标文件夹，如果原始目录加了末尾斜杠，表示将原始目录中的内容拷贝到目标文件夹。

cp和mv两个命令测试

看了上面的测试如果你觉得明白了，那么下面的内容可能会让你再次感到混乱，其实每次使用 cp 命令时还不怎么担心，但是使用mv命令时总是害怕把什么东西覆盖了，还是利用上面的目录结构来测试，只是就不贴具体的测试过程了，我把结论写一下。

cp 和 mv 仅考虑参数均为目录的情况，两个命令中无论是原始目录还是目标目录，结尾是否加斜杠 / 没有影响，都表示目录本身。

• cp 的目标目录不存在，则创建一个与原始目录内容一致的目标文件夹
• cp 的目标目录若存在，则会将原始目录拷贝到目标文件夹下，若在目标文件夹下存在同名目录则合并，若在目标文件夹下存在同名文件，则执行失败，报错 cp: cannot overwrite non-directory 'xxx/vvv' with directory 'vvv'
• mv 的目标目录不存在，则创建一个与原始目录内容一致的目标文件夹，并将原始目录移除
• mv 的目标目录若存在，则将原始目录移动到目标文件夹之下，若在目标文件夹下存在同名空目录则移动成功，若存在同名非空目录则执行失败，报错 mv: cannot move 'vvv' to 'zzz/vvv': Directory not empty，若在目标文件夹下存在同名文件，也执行失败，报错 mv: cannot overwrite non-directory 'xxx/vvv' with directory 'vvv'

所以这样看来mv用于目录时也不会覆盖掉原始的内容，以后可以放心大胆的用了

总结

• rsync 命令只有原始目录结尾的斜杠能影响结果，没有斜杠整个原始目录拷贝过去，有斜杠只拷贝原始目录里的内容到目标文件夹
• cp 和 mv 在目标目录不存在是都能执行成功，cp 是复制一份到形成目标目录，mv是将原始目录移动到目标目录
• cp 的目标目录若存在，其中不能包含和原始目录同名的文件，如果文件夹同名会将内容合并
• mv 的目标目录若存在，其中不能包含和原始目录同名的文件或非空同名文件夹，如果存在同名空文件夹则会将内容合并
• mv 命令操作目录时不会随便覆盖，可以放心使用

到底是坚持获得了成功，还是成功之后才能坚持下去，其实要看你怎么定义成功了，不怨我们浮躁，很多先机已经被人家占完了~

2023-7-20 22:32:42

C++中的 i++ 和 ++i 这两种自增运算是不是原子操作，突然被这么一问竟有点不知所措，这么“简单”的操作应该是原子的吧，但是好像有读又有写应该不是原子操作，原子操作就是那种刷一下就能完成的操作，准确来描述就是一个操作不可再分，要完成都完成不能存在中间态，咦？怎么听起来和事务这么像？那么 i++ 和 ++i 是不是原子操作我们看它是否满足不可再分就行了。

原子操作

怎么看是否可再分呢？想到一个办法，看一个操作是否可再分，直接看汇编是不是就行了，比如一个赋值语句：

1
2
3
4
5

int main()
{
    int i = 110;
    return 0;
}

使用 x86-64 gcc 13.1编译后生成的汇编：

1
2
3
4
5
6
7

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 110
        mov     eax, 0
        pop     rbp
        ret

int i = 110; 被汇编成了 mov DWORD PTR [rbp-4], 110 看起来是一句，没啥问题，再看 i++:

1
2
3
4
5
6

int main()
{
    int i = 110;
    i++;
    return 0;
}

1
2
3
4
5
6
7
8

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 110
        add     DWORD PTR [rbp-4], 1
        mov     eax, 0
        pop     rbp
        ret

i++ 也被汇编成了一句 add DWORD PTR [rbp-4], 1，居然也是一句，那么这是原子的吗？我们换个编译器看看，使用 x64 msvc 19.35 生成的汇编如下：

1
2
3
4
5
6
7
8
9
10
11
12

i$ = 0
main    PROC
$LN3:
        sub     rsp, 24
        mov     DWORD PTR i$[rsp], 110                    ; 0000006eH
        mov     eax, DWORD PTR i$[rsp]
        inc     eax
        mov     DWORD PTR i$[rsp], eax
        xor     eax, eax
        add     rsp, 24
        ret     0
main    ENDP

看吧，这里被翻译成了3句，这肯定不是原子操作了，那返回来看在gcc编译时生成 add DWORD PTR [rbp-4], 1的这一句，就是原子操作吗？

准确来表述是这样的 add DWORD PTR [rbp-4], 1这条汇编指令本身是原子的，但是在多线程环境中，对于变量的自增操作需要使用适当的同步机制（如互斥锁、原子类型等）来确保原子性和线程安全性。

如果在单核机器上，上述不加锁不会有问题，但到了多核机器上，这个不加锁同样会带来意外后果，两个CPU可以同时执行这条指令，但是两个执行以后，却可能出现只自加了一次

证明++i不是原子操作的例子

写个简单的例子，两个线程同时执行i++自增操作，看最后的结果是否符合预期：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <iostream>
#include <thread>

int val = 0;

void f1(int n)
{
    for (int i = 0; i < n; ++i) ++val;
}

int main(int argc, char* argv[])
{
    int n = 100000000;
    if (argc > 1) n = atoi(argv[1]);

    std::thread t1(f1, n);
    std::thread t2(f1, n);

    t1.join();
    t2.join();

    std::cout << "The final value is [" << val << "] for 2 threads running [" << n << "] times." << std::endl;

    return 0;
}

执行结果如下：

1
2
3
4
5
6
7
8
9
10
11

$ ./iplusplus 1000
The final value is [2000] for 2 threads running [1000] times.

$ ./iplusplus 10000
The final value is [20000] for 2 threads running [10000] times.

$ ./iplusplus 100000
The final value is [117784] for 2 threads running [100000] times.

$ ./iplusplus 1000000
The final value is [1271769] for 2 threads running [1000000] times.

从运行结果得知，起初1000次和10000次还没出现竞态条件问题，当次数扩大到100000次时，2个线程最终自增的结果只有117784

保证原子操作

还是上面的例子，怎样改成原子操作呢？这时可以利用 std::atomic 模板类，只需将上述例子中的 val 变量修改成 std::atomic<int> val(0); 即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> val(0);

void f1(int n)
{
    for (int i = 0; i < n; ++i) ++val;
}

int main(int argc, char* argv[])
{
    int n = 100000000;
    if (argc > 1) n = atoi(argv[1]);

    std::thread t1(f1, n);
    std::thread t2(f1, n);

    t1.join();
    t2.join();

    std::cout << "The final value is [" << val << "] for 2 threads running [" << n << "] times." << std::endl;

    return 0;
}

再编译运行试试：

1
2
3
4
5
6
7
8
9
10
11

$ ./iplusplus 100
The final value is [200] for 2 threads running [100] times.

$ ./iplusplus 10000
The final value is [20000] for 2 threads running [10000] times.

$ ./iplusplus 1000000
The final value is [2000000] for 2 threads running [1000000] times.

$ ./iplusplus 100000000
The final value is [200000000] for 2 threads running [100000000] times.

这样就解决了i++不是原子操作的问题，这里还可以将 ++val 写成 val.fetch_add(1) 表示原子加，其实 std::atomic 类实现了 operator++ 调用的就是 fetch_add(1)：

1
2
3
4
5
6
7

_GLIBCXX_ALWAYS_INLINE value_type
operator++(int) const noexcept
{ return fetch_add(1); }

value_type
operator++() const noexcept
{ return __atomic_impl::__add_fetch(_M_ptr, value_type(1)); }

总结

• i++ 和 ++i 不是原子操作，执行命令时包含内存读取，变量递增，回写内存三步，所以存在 data race
• 即使被汇编成一句 add DWORD PTR [rbp-4], 1一句代码在多核CPU上也会导致结果的不确定性或错误
• 想要 i++ 变成原子操作只需要定义成 std::atomic 模板类的对象即可，逻辑代码几乎无需修改

我们常常把求之不得的东西称之为理想~

2023-7-4 09:51:32

std::variant（可变体） 是 C++17 中引入的一个新的类模板，提供了一种存储不同类型的值的方式，类似于之前版本中的 union（联合体），但可以存储非 POD 类型和类对象，能够在运行时进行类型检查和转换，但具有更多的功能和更高的类型安全性，今天来看一下存储在std::variant中的数据要怎么读取。

variant的简单使用

可以参考cppreference网站的使用示例，也可以看看下面这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
#include <variant>
#include <string>

int main()
{
    std::variant<int, double, std::string> value;

    value = 110;
    std::cout << "The value is an integer: " << std::get<int>(value) << std::endl;

    value = 0.618;
    std::cout << "The value is a double: " << std::get<double>(value) << std::endl;

    value = "hello world";
    std::cout << "The value is a string: " << std::get<std::string>(value) << std::endl;

    // value = true;        // Compilation error: cannot convert type bool to any of the alternative types
    // std::get<int>(value) // std::bad_variant_access exception: value holds a different type

    return 0;
}

在示例程序中，定义了一个 std::variant 对象 value 来存储整型、浮点型和字符串类型中的任意一种，然后分别将 value 赋值为整型、浮点型和字符串类型，并使用 std::get 来获取对应的值，此时可以正常打印 value 对象中存储的值

当我们试图将 value 赋值为其它未在定义变量时指定的类型时，编译器将会报编译错误，而当我我们试图获取 value 中不存在的类型的值时，程序将会抛出 std::bad_variant_access 异常，可以使用 try-catch 已经捕获。

通过这段代码我们可以得知，使用std::variant可以方便地存储多种类型的数据，并且能够在运行时进行类型检查和转换，这使得代码更加清晰易读，便于维护。

variant相关函数和类

• 成员函数
  • index：返回 variant 中保存用类型的索引下标
  • valueless_by_exception：返回 variant 是否处于因异常导致的无值状态
  • emplace：原位构造 variant 中的值
• 非成员函数
  • visit：通过调用variant保存类型值所提供的函数对象获取具体值
  • holds_alternative：检查某个 variant 是否当前持有某个给定类型
  • std::get：以给定索引或类型读取 variant 的值，错误时抛出异常
  • get_if：以给定索引或类型，获得指向被指向的 variant 的值的指针，错误时返回空指针
• 辅助类
  • monostate：用作非可默认构造类型的 variant 的首个可选项的占位符类型（预防一些类型不提供无参构造函数）
  • bad_variant_access：非法地访问 variant 的值时抛出的异常
  • variant_npos：非法状态的 variant 的下标

访问std::variant数据

从前面提到的例子和函数说明，我们可以看到有多种方式来访问std::variant数据，接一下来一起总结一下：

std::get搭配index函数使用

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
#include <variant>

int main()
{
    std::variant<double, int> value = 119;

    if (1 == value.index())
        std::cout << "The value is: " << std::get<1>(value) << std::endl;

    return 0;
}

先用 index() 查询 variant保存的类型索引，然后在通过 std::get<NUMBER>() 获取其中的值

std::get搭配std::holds_alternative函数使用

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
#include <variant>

int main()
{
    std::variant<double, int> value = 119;

    if (std::holds_alternative<int>(value))
        std::cout << "The value is: " << std::get<int>(value) << std::endl;

    return 0;
}

先通过 std::holds_alternative() 查询 variant保存的类型，然后在通过 std::get<TYPE>() 获取其中的值

std::get_if函数

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
#include <variant>

int main()
{
    std::variant<double, int> value = 119;

    if (auto p = std::get_if<int>(&value))
        std::cout << "The value is: " << *p << std::endl;

    return 0;
}

直接使用 std::get_if 函数获取对应值的指针，如果类型不匹配会返回空指针

std::visit函数

使用函数visit函数访问时，有点像使用std::sort这类函数，可以搭配自定义的结构（排序）重写operator()，让其变成可以被调用的函数对象，也可以定义lambda自带可执行特性。

自定义访问结构的写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>
#include <variant>

int main()
{
    std::variant<double, int> value = 119;

    struct VisitPackage
    {
        auto operator()(const double& v) { std::cout << "The value is: " << v << std::endl; }
        auto operator()(const int& v) { std::cout << "The value is: " << v << std::endl; }
    };

    std::visit(VisitPackage(), value);

    return 0;
}

定义lambda函数组重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>
#include <variant>

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

int main()
{
    std::variant<double, int> value = 119;

    std::visit(overloaded {
      [] (const double& v) { std::cout << "The value is: " << v << std::endl; },
      [] (const int& v) { std::cout << "The value is: " << v << std::endl; }
    }, value);

    return 0;
}

这种方式将多个lambda放到一起形成重载，进而达到了访问variant数据的目的。

overloaded是什么

上文例子中的最后一个中使用到了 overloaded，这令人眼花缭乱的写法着实很诡异，不过我们可以从头来分析一下，最后两个例子中等价的两部分是

1
2
3
4
5
6
7

struct VisitPackage
{
    auto operator()(const double& v) { std::cout << "The value is: " << v << std::endl; }
    auto operator()(const int& v) { std::cout << "The value is: " << v << std::endl; }
};

VisitPackage()

与

1
2
3
4
5
6
7

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

overloaded {
    [] (const double& v) { std::cout << "The value is: " << v << std::endl; },
    [] (const int& v) { std::cout << "The value is: " << v << std::endl; }
}

要想理解它们为什么等价，我们首先的得弄清楚lambda表达式是什么，在剖析lambda之前先来看看 std::visit 函数需要的参数是什么，分析std::visit的参数，先看 struct VisitPackage 结构更容易一些。

std::visit的第一个参数

通俗的来说std::visit的第一个参数需要的是一个可执行的对象，如果对象能被执行就需要实现 operator() 这个操作符，看起来像函数一样，这就是为什么在 struct VisitPackage 中定义了 operator()，并且定义了两个形成了参数不同的静态重载，作用就是为了在访问 variant 对象时适配不同的类型，在访问variant 对象时会选择最匹配的 operator() 函数，进而实现了访问variant中不同类型值行为不同的目的。

那lambda表达式能实现这个目的吗？我们接着往下看

lambda 是什么

自从 C++11 引入lambda之后，对它赞美的声音不绝于耳，那lambda表达式究竟是怎样实现的呢？真的就是一个普通的函数吗？我们看一个小例子：

1
2
3
4
5
6
7
8
9
10
11

int main() {
  int x = 5, y = 6;

  auto func = [&](int n) {
    return x + n;
  };

  func(7);

  return 0;
}

这是一个使用lambda表达式简单的例子，代码中定义了一个int类型参数的返回值也是int的lambda函数，作用就是将外部变量x与函数参数的和返回，我们使用 cppinsights.io 网站来将此段代码展开

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

int main()
{
    int x = 5;
    int y = 6;

    class __lambda_4_15
    {
    public:
        inline /*constexpr */ int operator()(int n) const
        {
            return x + n;
        }

    private:
        int & x;

    public:
        __lambda_4_15(int & _x)
        : x{_x}
        {}
    };

    __lambda_4_15 func = __lambda_4_15{x};
    func.operator()(7);
    return 0;
}

可以发现我们虽然定义了一个lambda函数，但是编译器为它生成了一个类 __lambda_4_15，生成了 int& 类型的构造函数，并实现了 operator操作符，再调用lambda函数时先生成了 __lambda_4_15类的对象，再调用类的 operator()函数 func.operator()(7);，看到这里是不是似曾相识，虽然还不是很明白，但是和struct VisitPackage的定义总是有种说不清道不明的血缘关系。

弄清楚了lambda函数的本质，现在要实现的是怎么把多个lambda函数合成一个对象，并且让他们形成重载，因为lambda函数本质上存在一个类，只需要定义一个子类，继承多个lambda表达式就可以了，其实 overloaded 这个模板类就是为了实现这个目的。

overloaded剖析

1
2

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

一时间看起来很难理解，它来自 en.cppreference.com 中介绍 std::visit 访问 std::variant 的例子，可以换行看得更清楚一点：

1
2
3
4
5
6

// helper type for the visitor #4
template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };
// explicit deduction guide (not needed as of C++20)
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

template struct overloaded : Ts… { using Ts::operator()…; };

这是一个类模板的声明，模板的名字是overloaded

分步拆解来看：

template struct overloaded

表示类的模板参数为可变长的参数包 Ts
假设 Ts 包含 T1, T2, … , TN，那么这一句声明可以展开为：template struct overloaded

struct overloaded : Ts…

表示类的基类为参数包 Ts 内所有的参数类型
假设 Ts 包含 T1, T2, … , TN，那么这一句声明可以展开为：struct overloaded : T1, T2, …, TN

{ using Ts::operator()…; };

这是一个函数体内的变长 using 声明
假设 Ts 包含 T1, T2, … , TN，那么这一句声明可以展开为：{ using T1::operator(), T1::operator(), …, TN::operator(); }
经过这步声明，overloaded 类的参数包 Ts 内所有的参数作为基类的成员函数operator()均被 overloaded 类引入了自己的作用域

template overloaded(Ts…) -> overloaded;

这是一个自动推断向导说明，用于帮助编译器根据 overloaded 构造器参数的类型来推导 overloaded 的模板参数类型，C++17需要，C++20已不必写
它告诉编译器，如果 overloaded 构造器所有参数的类型的集合为Ts，那么 overloaded 的模板参数类型就是 Ts 所包含的所有类型
如果表达式a1, a2, …, an的类型分别为T1, T2, …, TN，那么构造器表达式overloaded x{a1, a2, …, an} 推导出，overloaded的类型就是 overloaded

经过这些解释，我们可以认为在最后一个例子中可能产生了类似这样的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
#include <variant>

class __lambda_12_7
{
public:
    inline /*constexpr */ void operator()(const double & v) const
    {
        std::operator<<(std::cout, "The value is: ").operator<<(v).operator<<(std::endl);
    }
};

class __lambda_13_7
{
public:
    inline /*constexpr */ void operator()(const int & v) const
    {
        std::operator<<(std::cout, "The value is: ").operator<<(v).operator<<(std::endl);
    }
};

template<>
struct overloaded<__lambda_12_7, __lambda_13_7> : public __lambda_12_7, public __lambda_13_7
{
    using __lambda_12_7::operator();
    // inline /*constexpr */ void ::operator()(const double & v) const;

    using __lambda_13_7::operator();
    // inline /*constexpr */ void ::operator()(const int & v) const;
};

int main()
{
    std::variant<double, int> value = std::variant<double, int>(119);

    std::visit(overloaded{__lambda_12_7(__lambda_12_7{}), __lambda_13_7(__lambda_13_7{})}, value);
    return 0;
}

总结

• std::variant 可以存储多个类型的值，并且它会自动处理类型转换和内存分配
• std::variant 可以存储非 POD 类型和类对象，能够在运行时进行类型检查和转换，具有更高的类型安全性
• 可以使用 std::visit 全局函数来访问 std::variant 中存储的值，该函数根据存储的值的类型自动选择调用哪个函数对象
• 可以使用 std::holds_alternative 函数来检查变量中是否存储了特定的类型
• 定义lambda函数时，编译器会为其生成一个类

代码是程序世界的运行规则，一个个字母的敲击正在规定着程序世界的运行秩序，无论代码写的天花乱坠，究其本质还是规定这一步要做什么，下一步继续做什么而已~

2023-6-23 21:13:04

最近看CSDN上线了InsCode这个在线跑项目代码的平台，放在了主菜单主推位置，上次这个位置好像是Gitee，在上次应该是代码片，CSDN 作为我一直使用的产品，最近十年我经历了他所有的变革，就像我刚刚提到的这些主菜单的变化，很多的东西已经被抛弃了，希望这次的InsCode能长久的支持下去。

代码开源平台并不好做，Github最大最活跃但访问并不顺畅，国内最早用的TaoCode在2018年关闭，后来Gitee用的比较多，但审查严格时候有多个开源项目被隐藏，CSDN现在主推的是GitCode，希望也能长久的支持下去，我并不太可能做出轰轰烈烈的开源项目分享，但分享一些代码世界的只言片语也是我的愿望，但愿能帮助一些恰好需要的人。

先了解一下InsCode

InsCode服务是一个在线编程工具，旨在为开发者提供一个便捷的编写、运行和分享代码的环境，让开发者无需在本地搭建编程环境，即可快速编写和运行代码。

InsCode支持多种编程语言，包括Java、Python、C++、JavaScript等代码，支持一些方便的项目模板，但目前还不支持C++模板希望后面能补充上。它提供了完整的运行环境，让代码在网页上直接运行并输出结果，即时调试，方便快捷，并且还提供了现实免费的InsCode AI Chat，帮助我们快速实现功能。同时，Inscode还提供了分享功能，可以轻松地将代码分享给其他人。

写一个Python示例

本来想写一段C++示例的，但是因为目前还不支持C++模板，所以先写个Python的例子展示一下使用方式吧，比如想打印本机IP地址，可以借助 InsCode AI Chat 生成，直接点击插入即可。

直接点击运行按钮查看效果，打印出外网IP是116.198.41.215

整个过程我真的是一行代码都不用写了，最终还可以将作品打包放到博客中展示，因为这个示例项目还在审核中，等审核通过后我会把效果贴上来。

总结

• InsCode服务是一个在线编程工具，旨在为开发者提供一个便捷的编写、运行和分享代码的环境
• InsCode支持多种编程语言，包括Java、Python、C++、JavaScript等代码，并支持一些方便的项目模板
• 使用InsCode真的可以做到不写一行代码来发布自己的产品，虽然不是很完善，但应该会越来越好
• 各大平台都在AI赛道里竞争起来，真正做出相关产品的并不多，我们一起期待吧

三个人确实就比两个人好看，这其中隐含的就是团圆的情感~

2023-06-18 23:26:00

数据监控目前用于各行各业，服务器开发也不例外，进程什么时候被杀死了？内存占用已经达到98%了怎么早点没发现，网络带宽已经占满了怪不得玩家反馈说登录不上去了，这些都是服务器开发人员常常听到的“抱怨”，他们都涉及到服务器资源的使用情况，如果有一种方便的途径可以高效的监控各个服务器的情况就好了，单靠人去各个服务器查看是不现实的，今天就来简单介绍一种我刚刚学到的方案。

原始的监控靠人盯

如果服务器只有一台或者很少，可以每隔一段时间去服务器上看看，top 看一下整体运行情况，free 查一下内存详情，df 看一下硬盘还够不够，iftop 看一下网络带宽情况，不要觉得不可能，有次测试我真的就是开了好几个远程窗口来盯着各个指标，不过人的精力有限，这样做毕竟不是长久之计。

进化的监控靠批处理脚本

随着服务器的增多，靠人盯的方式的已经达不到要求了，看看上面的这些命令都是已知的，并且只需要定期得到这些值就可以了，完全可以使用脚本定期执行来做呀，把上面提到的命令封装成脚本然后定期执行得到结果列表，然后发送到指定的地址，我们就可以只分析这些结果，没必要登录到各个服务器上去查询了。

高端的监控靠完整的可视化解决方案

懒惰是科学发展的推动力，使用脚本收集数据就不用登录服务器去实时查询了，那能不能帮我自动分析结果，或者在异常时直接给出提醒，因为我连分析的操作都不想做，肯定有人这样想当然也有人这样做了，并且形成了成熟的解决方案，我们只需要简单搭建和配置就可以早点下班了，半夜收到服务器报警电话时起来解决就可以了。

Telegraf、InfluxDB和Grafana铁三角

Telegraf是一个用于收集、处理和发送指标数据的代理，它可以与各种数据源和监控系统集成，定期收集数据并将其发送到目标位置。

InfluxDB是一个开源的时间序列数据库，用于存储和查询大量时间序列数据。它被广泛用于存储来自Telegraf等数据收集器的指标数据。

Grafana用于创建交互式仪表板，从各种数据源中提取数据，并将数据以图表、图形和表格等形式展示出来。

通过将Telegraf用作数据收集代理，将数据发送到InfluxDB中存储，然后使用Grafana从InfluxDB中提取数据进行可视化，这个铁三角组合提供了一个强大的监控和数据可视化解决方案。

Telegraf

Telegraf是一个开源的代理程序，用于收集、处理和发送指标数据。它设计用于高效地收集各种类型的数据，并将其发送到不同的目标位置，如时序数据库、消息队列等，具有以下是关键特点和功能：

• 插件架构：Telegraf采用模块化的插件架构，具有丰富的输入和输出插件。它支持多种输入插件，如系统性能指标、日志文件、数据库查询、API调用等，以便从不同的数据源中收集数据。同样，Telegraf还支持多种输出插件，如InfluxDB、Elasticsearch、Kafka等，用于将收集到的数据发送到不同的目标位置。

• 多平台支持：Telegraf可在多个操作系统上运行，包括Linux、Windows和macOS，以适应不同的部署环境和需求。

• 轻量级和高性能：Telegraf被设计为轻量级和高性能的代理程序，可以在资源受限的环境中高效运行。它使用Golang编写，具有低的内存和CPU占用，并能够处理高并发的数据收集和处理任务。

• 数据转换和处理：Telegraf提供了灵活的数据转换和处理功能，可以对收集到的数据进行过滤、转换、聚合等操作。它支持各种数据处理任务，如标签添加、数据格式转换、聚合计算等，以便对数据进行预处理和清洗，使其适应目标存储或分析平台的要求。

• 插件生态系统：Telegraf拥有一个活跃的插件生态系统，用户可以根据自己的需求选择和配置适当的插件。社区提供了大量的插件，覆盖了各种数据源和目标位置，使得Telegraf具备广泛的适用性和灵活性。

InfluxDB

InfluxDB是一个开源的高性能时序数据库，专门用于存储和处理时间序列数据。它被设计为能够高效地处理大规模的时间相关数据，并提供快速的数据插入、查询和聚合能力，具有关键特点和功能：

• 时序数据存储：InfluxDB专注于存储和管理时间序列数据，如传感器数据、监控指标、日志事件等。它使用特定的数据结构和索引机制，以优化对时间序列数据的写入和查询操作。

• 高性能和可扩展性：InfluxDB被设计为具有高吞吐量和低延迟的数据库系统。它采用了一系列的优化策略，包括压缩算法、分片存储、数据分区等，以实现高效的数据处理和查询性能。此外，InfluxDB还支持水平扩展，可以通过添加更多节点来提高性能和容量。

• 查询语言：InfluxDB提供了InfluxQL和Flux两种查询语言。InfluxQL是类似于SQL的查询语言，专门用于时间序列数据的查询和聚合操作。Flux是一种功能更强大和灵活的查询语言，它支持更复杂的数据处理和转换操作，并具有扩展性更好的能力。

• 数据保留策略：InfluxDB允许定义数据保留策略，以指定数据在数据库中的保存期限和存储策略。这样可以根据数据的时效性需求和存储资源限制来管理数据的保留和清理。

• 数据一致性和持久性：InfluxDB采用了写时复制（Write Ahead Log）的机制，确保数据的一致性和持久性。它使用持久化引擎来保证数据在故障情况下的可靠性，同时提供数据备份和恢复的功能。

• 整合生态系统：InfluxDB具有丰富的整合生态系统，可以与各种数据源和工具集成。它支持与Telegraf等数据收集代理的无缝集成，以及与Grafana等数据可视化工具的联合使用，提供完整的监控和数据处理解决方案。

Grafana

Grafana是一个开源的数据可视化和监控平台，用于创建、展示和分析实时指标和数据的交互式仪表板。它提供了丰富的可视化选项和灵活的配置，使用户能够轻松地创建各种类型的仪表板，并实时监控和分析数据，具有以下关键特点和功能：

• 数据源支持：Grafana支持广泛的数据源，包括各种数据库（如MySQL、PostgreSQL、InfluxDB）、时序数据库（如Prometheus、Graphite）、日志文件、API等。它提供了内置的数据源插件和API接口，以便与不同的数据源进行集成和数据获取。

• 丰富的可视化选项：Grafana提供多种可视化选项，如折线图、柱状图、仪表盘、热力图等，可以根据数据的特点选择适合的图表类型。它还支持动态图表、图表注释、数据标记等功能，以增强数据的可视化效果和交互性。

• 交互式仪表板：Grafana的仪表板具有交互式的功能，用户可以自由地缩放、选择时间范围、过滤数据等。它还支持实时数据更新和自动刷新，以确保仪表板上的数据保持最新。

• 告警和通知：Grafana提供了强大的告警功能，用户可以根据自定义的条件设置告警规则，并通过电子邮件、Slack等渠道接收告警通知。这样可以及时发现数据异常或重要指标的变化。

• 用户管理和权限控制：Grafana支持多用户和团队管理，可以设置不同的用户角色和权限，以控制对仪表板和数据的访问和操作。它还提供了LDAP、OAuth等身份验证和单点登录功能，与企业的用户管理系统集成更加便捷。

• 社区支持和插件生态系统：Grafana拥有庞大的开源社区支持和活跃的插件生态系统。用户可以从社区中获取各种主题、模板和插件，以扩展和定制Grafana的功能和外观。

Grafana仪表板展示

说实话第一次看到Grafana仪表板还是挺震撼的，展示的信息很多，可以帮助服务器维护人员分析很多问题，下面来展示一些主要的面板。

服务器资源总览

负载和内存使用

网络带宽

磁盘IO

IO延迟

其他指标

进程信息

总结

• Telegraf、Grafana和InfluxDB通常被称为”铁三角”，因为它们经常一起使用，形成一个完整的监控和数据可视化解决方案
• Telegraf是一个用于收集、处理和发送指标数据的代理，它可以与各种数据源和监控系统集成，定期收集数据并将其发送到目标位置
• InfluxDB是一个开源的时间序列数据库，用于存储和查询大量时间序列数据。它被广泛用于存储来自Telegraf等数据收集器的指标数据
• Grafana用于创建交互式仪表板，从各种数据源中提取数据，并将数据以图表、图形和表格等形式展示出来
• Grafana的仪表板真的挺漂亮的

把烦恼痛了吞了认了算了
不对别人讲
谁还没有辜负几段 昂贵的时光

2023-6-17 19:39:56

sudo命令应该是任何一个服务器使用人员都绕不开的命令，比如那个大名鼎鼎的删库跑路命令 sudo rm -rf /*，虽然经常使用，也知道用它能做一些普通用户无法完成的事情，那么它究竟是什么意思，有什么作用和好处，和超级无敌的 root 用户又有什么关系呢？接下来我们来简单梳理一下。

关于sudo的一些疑问

sudo是什么

sudo 是一种在类 Unix 系统中使用的命令，用于以超级用户（superuser）的身份执行其他命令。它是 “Super User Do” 的缩写。超级用户通常是系统管理员，具有对操作系统的完全控制权。

当你以普通用户的身份登录到系统时，可能没有足够的权限来执行某些敏感的系统操作或访问某些文件。在这种情况下，可以使用 sudo 命令在临时提升权限的情况下执行特定命令。

使用 sudo 命令时，需要输入管理员密码以验证你的身份。一旦验证成功，就可以以超级用户的权限执行命令。这样可以确保系统安全，因为只有经过授权的用户才能执行特权操作。

例如，如果想要安装软件包或修改系统设置，但这些操作需要超级用户权限，你可以在命令前加上 sudo，然后输入密码以执行该命令。

以下是一个sudo命令使用的示例：

1

sudo apt-get install git

这个命令将使用 apt-get 工具安装一个软件包，由于它需要对系统进行修改，所以需要超级用户权限。通过使用 sudo，可以在普通用户的身份下临时获取这些权限来执行该操作。

sudo 和 root 的区别和联系

sudo 和 root 在类 Unix 系统中具有不同的角色和功能。以下是它们之间的区别和联系：

1. 权限级别： root 是超级用户，也称为系统管理员。拥有 root 权限意味着拥有对整个系统的完全控制权，可以执行所有操作并访问所有文件。相比之下，sudo 是一个命令，允许普通用户在需要时以超级用户的身份执行特定的命令。

2. 使用方式： root 用户可以直接登录到系统并拥有持久的超级用户权限。而 sudo 是一种临时提升权限的机制，允许普通用户在需要时以超级用户的身份执行特定命令。普通用户可以使用 sudo 命令来运行特权命令，但在执行时需要输入管理员密码进行身份验证。

3. 安全性： sudo 的使用可以提高系统的安全性。通过限制普通用户的特权，只有在需要执行特定任务时才临时提升权限，可以减少意外或恶意操作造成的潜在风险。相比之下，root 用户拥有系统的完全权限，因此使用 root 用户执行命令时需要格外小心，以免对系统造成损坏。

4. 日常操作： 为了提高系统安全性，通常建议使用 sudo 来执行需要特权的命令，而不是直接使用 root 用户。使用 sudo 可以在普通用户的身份下执行特权命令，并避免了在常规操作中长时间保持 root 权限，从而减少了潜在的错误或安全风险。

总结来说，root 是系统的超级用户，拥有完全的权限，而 sudo 是一种临时提升权限的机制，允许普通用户以超级用户的身份执行特定命令。使用 sudo 可以提高系统的安全性，同时避免在日常操作中过多使用 root 用户带来的潜在风险。

使用 sudo 的好处

使用 sudo 有以下几个好处：

1. 安全性： sudo 增加了系统的安全性。通过限制普通用户的特权，只有在需要执行特定任务时才临时提升权限，可以减少潜在的错误或恶意操作对系统造成的风险。普通用户在执行需要特权的命令时需要输入管理员密码，这种身份验证确保只有经过授权的用户才能执行特权操作。

2. 权限控制： sudo 允许系统管理员细粒度地控制用户对系统资源和命令的访问权限。管理员可以通过配置 sudo 的策略文件，精确地指定哪些用户可以执行哪些命令以及以何种方式执行。这种权限控制有助于实施最小权限原则，即用户只能以最低权限执行任务，从而降低了潜在的安全风险。

3. 审计和日志记录： sudo 提供了审计和日志记录功能，可以记录执行特权操作的用户、时间和执行的命令。这对于追踪系统中的活动、故障排查和安全审计非常有价值。通过审计和日志记录，管理员可以了解特权操作的细节，以及哪些用户在何时执行了哪些命令。

4. 限制特权操作： 使用 sudo 可以限制特权操作的范围。普通用户只有在需要执行特定命令时才能使用 sudo 提升权限。这种限制可以避免用户误操作或滥用超级用户权限，从而减少了对系统的潜在风险。

总而言之，使用 sudo 可以提高系统的安全性、实施最小权限原则、提供审计和日志记录功能，并限制特权操作的范围。这使得系统管理员能够更好地管理用户权限并降低潜在的风险。

怎样查看sudo命令日志

可以使用适当的文本编辑器打开 sudo 日志文件：选择适用于你的系统的文本编辑器（如 nano、vim、或者其他）以超级用户权限打开 sudo 日志文件。日志文件的位置和名称可能会因操作系统的不同而异。下面是一些常见的 sudo 日志文件路径：

• Ubuntu、Debian 等基于 Debian 的系统：

  1	sudo nano /var/log/auth.log

• CentOS、Fedora、Red Hat 等基于 Red Hat 的系统：

  1	sudo nano /var/log/secure

• macOS：

  1	sudo nano /var/log/system.log

查看 sudo 日志文件通常需要管理员或超级用户权限。确保你具有足够的权限才能访问和查看日志文件。此外，一些操作系统可能还提供了特定的命令或工具来查看系统日志，例如 journalctl 命令在某些 Linux 发行版中可用于查看系统日志。你可以根据你的操作系统和日志管理方式来选择适合的方法来查看 sudo 日志。

修改sudo配置

sudo的配置文件是 /etc/sudoers 但是不建议直接用文本工具打开它，一旦修改出错可能导致很多严重问题，可以使用 visudo 命令进行打开编辑，使用 visudo 命令编辑 sudoers 文件时，系统会执行语法检查以确保配置的正确性，以避免可能的权限问题，下面展示一个简单配置样例：

简单样例

1
2
3
4
5
6
7
8
9
10
11

# User privilege specification
root    ALL=(ALL:ALL) ALL

# Allow members of group sudo to execute any command
%sudo   ALL=(ALL:ALL) ALL

# Allow members of group admin to execute any command
%admin  ALL=(ALL:ALL) ALL

# Allow specific user to run specific command as another user
johndoe ALL=(appuser) /usr/local/bin/git

visudo 是一个用于编辑 sudoers 文件的命令，该文件包含了与 sudo（以管理员权限执行命令）相关的配置信息。在 sudoers 文件中，每一行都由多个列组成，其中包含不同的字段和含义。以下是 sudoers 文件中各列的一般含义：

1. 列1：用户列表

   • 该列指定了可以使用 sudo 命令的用户或用户组。
   • 可以是单个用户名，如 “bob”。
   • 可以是用户组前缀 “%” 后跟用户组名，如 “%admin”。

2. 列2：主机列表

   • 该列指定了可以在哪些主机上使用 sudo 命令。
   • 可以是单个主机名，如 “localhost”。
   • 可以是主机名前缀 “ALL”，表示适用于所有主机。

3. 列3：=(运行 as) 列表

   • 该列指定了可以以哪个用户身份来运行命令。
   • 可以是单个用户名，如 “root”。
   • 可以是用户组前缀 “ALL”，表示可以以任何用户身份运行命令。
   • =(ALL:ALL)：表示可以以任何用户身份 (ALL) 在任何终端 (ALL) 上运行命令。

4. 列4：NOPASSWD: 标志

   • 该列指定了是否需要输入密码才能使用 sudo 命令。
   • 如果列中包含 “NOPASSWD:”，则表示不需要密码。
   • 如果列为空或未包含 “NOPASSWD:”，则需要输入密码。

5. 列5及以后：命令列表

   • 该列指定了可以使用 sudo 命令执行的具体命令。
   • 可以是完整的命令路径，如 “/usr/bin/apt-get”。
   • 可以是通配符，如 “/usr/bin/*” 表示该目录下的所有命令。

复杂样例及解释

下面是一个复杂一些的 visudo 配置示例，其中包含了多个用户、用户组和命令的授权规则：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# User privilege specification

## Allow root to run any commands on all hosts
root    ALL=(ALL:ALL) ALL

## Allow members of the admin group to run any commands on all hosts
%admin  ALL=(ALL:ALL) ALL

## Allow specific user to run specific commands as root without password
johndoe ALL=(root) NOPASSWD: /bin/ls, /usr/bin/apt-get

## Allow specific user to run commands in specific directories as another user
johndoe ALL=(appuser) /opt/app/bin/*
johndoe ALL=(backupuser) /var/backup/scripts/*

## Allow specific user to run specific command with arguments as root
johndoe ALL=(root) /usr/sbin/usermod [a-z]*

## Deny specific user to run any command
banneduser ALL=(ALL:ALL) ALL, !/usr/bin/*

## Allow members of the wheel group to run any commands on localhost without password
%wheel  localhost=(ALL:ALL) NOPASSWD: ALL

## Allow users in the developer group to run specific commands with arguments
%developer ALL=(ALL:ALL) /usr/bin/git *, /usr/bin/make clean

## Allow users in the support group to restart specific services
%support ALL=(root) /usr/sbin/service apache2 restart, /usr/sbin/service nginx restart

上述配置说明不考虑注释行，含义如下：

• 第1行表示允许 root 用户在所有主机上以任何用户身份执行任何命令。
• 第3行表示允许 johndoe 用户作为 root 用户以无需密码的方式执行 /bin/ls 和 /usr/bin/apt-get 命令。
• 第4行和第5行表示允许 johndoe 用户作为 appuser 用户或 backupuser 用户在特定目录下执行命令。
• 第6行表示允许 johndoe 用户作为 root 用户执行带有特定参数的 /usr/sbin/usermod 命令。
• 第7行表示禁止 banneduser 用户执行除 /usr/bin/* 之外的所有命令。
• 第8行表示允许 wheel 组的用户在 localhost 主机上以任何用户身份执行任何命令，且无需密码。
• 第9行表示允许 developer 组的用户执行带有特定参数的 /usr/bin/git 和 /usr/bin/make 命令。
• 第10行表示允许 support 组的用户作为 root 用户重启特定服务。

使用sudo用户

创建用户并添加到 sudo 组

在 Linux 上创建用户并将其添加到 sudo 组，可以按照以下步骤进行操作：

1. 打开终端：在操作系统中打开终端或命令行界面。

2. 使用 adduser 命令创建新用户：

   1	sudo adduser newuser

   这将提示你输入新用户的密码和其他详细信息。

3. 将新用户添加到 sudo 组。可以使用 usermod 命令执行此操作：

   1	sudo usermod -aG sudo newuser

   这将将新用户 newuser 添加到 sudo 组中。

4. 验证用户是否成功添加到 sudo 组。你可以通过执行以下命令来检查用户所属的组：

   1	groups newuser

   如果 sudo 组在列表中显示，表示用户已成功添加到 sudo 组。

现在，新创建的用户已经添加到 sudo 组，拥有 sudo 权限。他们可以使用 sudo 命令以管理员权限执行特权操作。请确保将适当的权限授予新用户，以确保系统的安全性和合规性。

查看是否有sudo权限

可以通过id命令查看指定用户是否在 sudo 组内，比如下面的用户就在27(sudo)这个组内：

1
2

root@jenkins1604:~# id gyee
uid=1004(gyee) gid=1004(gyee) groups=1004(gyee),27(sudo)

也可以查看(sudo)组内是否包含当前用户：

1
2

root@jenkins1604:~# getent group sudo
sudo:x:27:admin,gyee

getent 是一个命令行工具，用于从系统数据库（如密码、组、主机、服务等）中获取条目的信息。它可以用于检索和显示与系统用户、组、网络服务和其他系统资源相关的信息 ，getent 命令的基本语法如下：

1

getent database entry

其中，database 表示要查询的数据库，而 entry 则表示要获取的数据库条目。 以下是一些常见的 getent 命令示例：

• 获取系统中所有用户的信息：

  1	getent passwd

• 获取特定用户的信息：

  1	getent passwd <username>

• 获取系统中所有组的信息：

  1	getent group

• 获取特定组的信息：

  1	getent group <groupname>

• 获取系统中所有网络服务的信息（/etc/services 文件中定义的服务）：

  1	getent services

没有sudo权限时执行会被记录

当没有sudo权限时，执行命令会输出以下信息，显示此操作被记录在案：

1
2
3

gyee@jenkins1604:/root$ sudo usermod -aG sudo gyee
[sudo] password for gyee:
gyee is not in the sudoers file.  This incident will be reported.

可以查询系统安全日志

1
2

root@jenkins1604:~# cat /var/log/auth.log | grep gyee
May 26 22:07:13 machine sudo:     gyee : user NOT in sudoers ; TTY=pts/1 ; PWD=/root ; USER=root ; COMMAND=/usr/sbin/usermod -aG sudo gyee

总结

• sudo 是一种在类 Unix 系统中使用的命令，用于以超级用户（superuser）的身份执行其他命令
• root 是超级用户，拥有对整个系统的完全控制权，sudo 是一个允许普通用户在需要时以超级用户的身份执行特定的命令
• adduser 和 useradd 都是在 Linux 系统上用于创建用户的命令，但 adduser命令更方便友好，尤其适用于交互式的用户创建
• getent 是一个命令行工具，用于从系统数据库（如密码、组、主机、服务等）中获取条目的信息

大家所谓的不满，是不满自己没成为人上人吧，至于温饱，很多人已经绰绰有余了~

2023-5-26 22:08:38

daemon进程是后台守护进程，比如linux 下server都是daemon进程，像httpd、sshd等这些服务你肯定听说过，如果我们想写一个后台运行程序应该怎么做呢？其实非常容易，只要添加头文件 #include <unistd.h>，然后在调用 daemon(1, 0)函数即可。

daemon函数说明

1
2
3
4
5

/* Put the program in the background, and dissociate from the controlling
   terminal.  If NOCHDIR is zero, do `chdir ("/")'.  If NOCLOSE is zero,
   redirects stdin, stdout, and stderr to /dev/null.  */
extern int daemon (int __nochdir, int __noclose) __THROW __wur;
#endif /* Use misc.  */

头文件中已经说得很清楚了，当 nochdir为零时，将当前目录变为根目录，否则不变，当 noclose为零时，标准输入、标准输出和错误输出重导向为/dev/null不输出任何信息，否则照样输出。

daemon函数的实现

关于找daemon函数的实现还是费了一些功夫的，我发现我根本不会在github上查代码，一开始以为是linux源码所以去翻了Linus Torvalds的Linux源码结果没找到，最后还是在google收到了一些，整理如下：

安卓源码

https://android.googlesource.com/platform/bionic.git/+/donut-release/libc/unistd/daemon.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
int  daemon( int  nochdir, int  noclose )
{
   pid_t  pid;
   if ( !nochdir && chdir("/") != 0 )
       return -1;

   if ( !noclose )
   {
     int  fd = open("/dev/null", O_RDWR);
     if ( fd < 0 )
      return -1;
     if ( dup2( fd, 0 ) < 0 ||
      dup2( fd, 1 ) < 0 ||
          dup2( fd, 2 ) < 0 )
     {
       close(fd);
      return -1;
     }
     close(fd);
  }

   pid = fork();
   if (pid < 0)
    return -1;
   if (pid > 0)
    _exit(0);
   if ( setsid() < 0 )
     return -1;
   return 0;
}

苹果源码

https://opensource.apple.com/source/Libc/Libc-167/gen.subproj/daemon.c.auto.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <fcntl.h>
#include <paths.h>
#include <unistd.h>

int
daemon(nochdir, noclose)
    int nochdir, noclose;
{
    int fd;

    switch (fork()) {
    case -1:
        return (-1);
    case 0:
        break;
    default:
        _exit(0);
    }

    if (setsid() == -1)
        return (-1);

    if (!nochdir)
        (void)chdir("/");

    if (!noclose && (fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
        (void)dup2(fd, STDIN_FILENO);
        (void)dup2(fd, STDOUT_FILENO);
        (void)dup2(fd, STDERR_FILENO);
        if (fd > 2)
            (void)close (fd);
    }
    return (0);
}

glibc源码

https://elixir.bootlin.com/glibc/glibc-2.37/source/misc/daemon.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)daemon.c    8.1 (Berkeley) 6/4/93";
#endif /* LIBC_SCCS and not lint */

#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <unistd.h>
#include <sys/stat.h>

#include <device-nrs.h>
#include <not-cancel.h>

int
daemon (int nochdir, int noclose)
{
    int fd;

    switch (__fork()) {
    case -1:
        return (-1);
    case 0:
        break;
    default:
        _exit(0);
    }

    if (__setsid() == -1)
        return (-1);

    if (!nochdir)
        (void)__chdir("/");

    if (!noclose) {
        struct __stat64_t64 st;

        if ((fd = __open_nocancel(_PATH_DEVNULL, O_RDWR, 0)) != -1
            && __glibc_likely (__fstat64_time64 (fd, &st) == 0)) {
            if (__builtin_expect (S_ISCHR (st.st_mode), 1) != 0
#if defined DEV_NULL_MAJOR && defined DEV_NULL_MINOR
                && (st.st_rdev
                == makedev (DEV_NULL_MAJOR, DEV_NULL_MINOR))
#endif
                ) {
                (void)__dup2(fd, STDIN_FILENO);
                (void)__dup2(fd, STDOUT_FILENO);
                (void)__dup2(fd, STDERR_FILENO);
                if (fd > 2)
                    (void)__close (fd);
            } else {
                /* We must set an errno value since no
                   function call actually failed.  */
                __close_nocancel_nostatus (fd);
                __set_errno (ENODEV);
                return -1;
            }
        } else {
            __close_nocancel_nostatus (fd);
            return -1;
        }
    }
    return (0);
}

glibc github地址

https://github.com/lattera/glibc/blob/master/misc/daemon.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)daemon.c    8.1 (Berkeley) 6/4/93";
#endif /* LIBC_SCCS and not lint */

#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <unistd.h>
#include <sys/stat.h>

#include <device-nrs.h>
#include <not-cancel.h>

int
daemon (int nochdir, int noclose)
{
    int fd;

    switch (__fork()) {
    case -1:
        return (-1);
    case 0:
        break;
    default:
        _exit(0);
    }

    if (__setsid() == -1)
        return (-1);

    if (!nochdir)
        (void)__chdir("/");

    if (!noclose) {
        struct stat64 st;

        if ((fd = __open_nocancel(_PATH_DEVNULL, O_RDWR, 0)) != -1
            && (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0)
            == 0)) {
            if (__builtin_expect (S_ISCHR (st.st_mode), 1) != 0
#if defined DEV_NULL_MAJOR && defined DEV_NULL_MINOR
                && (st.st_rdev
                == makedev (DEV_NULL_MAJOR, DEV_NULL_MINOR))
#endif
                ) {
                (void)__dup2(fd, STDIN_FILENO);
                (void)__dup2(fd, STDOUT_FILENO);
                (void)__dup2(fd, STDERR_FILENO);
                if (fd > 2)
                    (void)__close (fd);
            } else {
                /* We must set an errno value since no
                   function call actually failed.  */
                __close_nocancel_nostatus (fd);
                __set_errno (ENODEV);
                return -1;
            }
        } else {
            __close_nocancel_nostatus (fd);
            return -1;
        }
    }
    return (0);
}

挺有意思的写法

https://github.com/bmc/daemonize/blob/master/daemon.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

int daemon(int nochdir, int noclose)
{
    int status = 0;

    openlog("daemonize", LOG_PID, LOG_DAEMON);

    /* Fork once to go into the background. */
    if((status = do_fork()) < 0 )
        ;

    /* Create new session */
    else if(setsid() < 0)               /* shouldn't fail */
        status = -1;

    /* Fork again to ensure that daemon never reacquires a control terminal. */
    else if((status = do_fork()) < 0 )
        ;

    else
    {
        /* clear any inherited umask(2) value */

        umask(0);

        /* We're there. */

        if(! nochdir)
        {
            /* Go to a neutral corner. */
            chdir("/");
        }

        if(! noclose)
            redirect_fds();
    }

    return status;
}

nginx中实现

https://github.com/nginx/nginx/blob/master/src/os/unix/ngx_daemon.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

ngx_int_t
ngx_daemon(ngx_log_t *log)
{
    int  fd;

    switch (fork()) {
    case -1:
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "fork() failed");
        return NGX_ERROR;

    case 0:
        break;

    default:
        exit(0);
    }

    ngx_parent = ngx_pid;
    ngx_pid = ngx_getpid();

    if (setsid() == -1) {
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "setsid() failed");
        return NGX_ERROR;
    }

    umask(0);

    fd = open("/dev/null", O_RDWR);
    if (fd == -1) {
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
                      "open(\"/dev/null\") failed");
        return NGX_ERROR;
    }

    if (dup2(fd, STDIN_FILENO) == -1) {
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDIN) failed");
        return NGX_ERROR;
    }

    if (dup2(fd, STDOUT_FILENO) == -1) {
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDOUT) failed");
        return NGX_ERROR;
    }

#if 0
    if (dup2(fd, STDERR_FILENO) == -1) {
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDERR) failed");
        return NGX_ERROR;
    }
#endif

    if (fd > STDERR_FILENO) {
        if (close(fd) == -1) {
            ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "close() failed");
            return NGX_ERROR;
        }
    }

    return NGX_OK;
}

chatgpt生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int daemon(int nochdir, int noclose)
{
    pid_t pid;

    // 创建子进程并退出父进程
    if ((pid = fork()) < 0) {
        return -1;
    } else if (pid != 0) {
        exit(0);
    }

    // 创建新的会话
    if (setsid() < 0) {
        return -1;
    }

    // 忽略 SIGHUP 信号
    signal(SIGHUP, SIG_IGN);

    // 再次创建子进程并退出父进程
    if ((pid = fork()) < 0) {
        return -1;
    } else if (pid != 0) {
        exit(0);
    }

    // 更改当前工作目录
    if (!nochdir) {
        if (chdir("/") < 0) {
            return -1;
        }
    }

    // 关闭文件描述符
    if (!noclose) {
        int fd;

        if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
            dup2(fd, STDIN_FILENO);
            dup2(fd, STDOUT_FILENO);
            dup2(fd, STDERR_FILENO);

            if (fd > STDERR_FILENO) {
                close(fd);
            }
        }
    }

    return 0;
}

daemon函数fork两次的原因

以上这些开源实现中，有的fork一次，有的fork两次，不过fork一次的多一些，对于这个问题我还查了不少资料

http://www.cppblog.com/justin-shi/archive/2014/10/10/208530.html
https://blog.csdn.net/shaoye_csdn1/article/details/94599271
https://m.xp.cn/b.php/75000.html

关于为什么要fork两次，我找到了上面几篇相关的解释，总结如下：

第一次fork使父进程终止，让子进程中进入后台执行，同时保证了会话id与当前子进程id不同，可以调用setsid函数创建新的会话，保证了子进程是会话组长(sid==pid)，也是进程组组长(pgid == pid)。

第二次fork目的是防止进程再次打开一个控制终端，因为打开一个控制终端的前提条件是该进程必须是会话组长，再fork一次可以保证子进程pid != sid（sid是进程父进程的sid），所以也无法打开新的控制终端。

关于第一次fork我是理解的，第二次fork我也做过实验，无论fork一次还是两次，都可以再次打开新的终端，也就是说即使保证了pid != sid，一样可以打开新的终端，而有很多daemon函数的开源的实现中也只是调用了一次fork，包括我使用的Ubuntu20.04实验结果也是调用了一次fork，所以调用两次fork的原因成谜。

https://www.cntofu.com/book/46/linux_system/153.md

而这篇文章总结了两次fork技巧，不过和我们本文中所说的daemon两次fork前提不一样，在父进程不退出时会使用两次fork技巧避免出现僵尸进程，但时在daemon函数中fork只之后的父进程都是直接退出的，所以应该不是这个原因。

关于这个疑问我还专门去ChatGPT上问了一下，它给的答案如下：

在早期的Unix系统中，使用 daemon() 函数通常需要调用两次 fork() 函数，以确保子进程成为孤儿进程（orphan process），即与任何终端无关联，并且不会收到终端信号。孤儿进程通常是由父进程创建的子进程，但父进程已经退出或被杀死。

以下是调用两次 fork() 函数的工作原理：

1. 调用第一次 fork() 函数：创建子进程1。父进程退出，子进程1成为孤儿进程，也就是没有父进程的进程。此时，子进程1仍然与原来的控制终端相关联。
2. 子进程1调用 setsid() 函数创建一个新的会话，并成为新会话的领头进程和新进程组的组长进程。由于孤儿进程已经成为新会话的领头进程，因此它无法再重新关联到终端。此时，子进程1仍然是当前进程组的组长进程，并且与新的控制终端相关联。

3. 调用第二次 fork() 函数：创建子进程2。由于子进程1是新会话的领头进程，因此子进程2不再与任何控制终端相关联。此时，子进程2成为孤儿进程，并与新会话和新进程组分离。

4. 子进程2关闭不需要的文件描述符，改变工作目录和文件掩码，最后运行守护进程。

>

需要注意的是，在现代的Linux系统中，使用 daemon() 函数只需要调用一次 fork() 函数和一些必要的操作（如 setsid()、关闭文件描述符等），就可以将进程变成守护进程，而不需要调用两次 fork() 函数。

自己做实验的代码

自己在测试 daemon 函数的时候写了一些代码，记录一下方便再次拿来用，请原谅我c/c++混用，为了验证某个问题我已经各种尝试了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110