图灵已经找到了计算能力的基石，但寻找智慧的基石这项工作，仍然没有见到成功的曙光，世界在等待着下一个“图灵”的出现。

谁会是下一个图灵呢，是奥特曼吗，我们不得而知，GPT的发布如火如荼，吸引了全世界的注意力。

我并不看好目前的AI进展，不管是近十年深度学习的飞速发展，还是Transformer近期的又一次颠覆，这些都不是真正的智能。真正的智能应该不需要训练，具备自主学习能力。就语言能力而言，真正的智能能从零开始自己解析语言，不需要任何数据教他。就像三体中提到的自译解析系统一样。

虽然都声称已经成功开发出了非冯·诺依曼的新型计算机架构，然而就背后对应的非图灵机的新型计算模型而言，仍是毫无头绪。

或许图灵机这个模型就无法实现这样的AI。那么任何冯诺依曼架构的计算机就都无法实现。或许非冯诺依曼架构才有新的可能？当然这都是我的猜想。

伟大的图灵吞食氰化物结束的自己传奇的一生，当时的社会是不够包容的（同性恋难以理解，但我尊重他的选择）。

“伊莉莎效应”（ELIZA Effect），这个词的意思是说人可以过度解读机器的结果，读出原本不具有的意义。

gpt4就是是eliza effect的典型代表，短视频创作者们无所不用其极。

冯诺依曼曾推理出一个智能系统应当包含一个自复制系统，而一个自复制系统应该具备两个能力。

首先，它必须能够构建一个组成元素和结构与自己一致的后代系统，然后它需要能够把对自身的描述传递给这个后代系统。冯·诺依曼把这两个部分分别称作“通用构造器”和“描述器”，而描述器中又包含了一个通用图灵机和保存在通用图灵机器能够读取的介质上的描述信息。这样，只要有合适的原料，通用构造器就可以根据描述器的指示，生产出下一台机器，并且把描述的信息也传递给这台新机器。随后，新机器启动，再进入下一个复制循环。

在当时，没有设计出能够进行自我复制的机器，但是遵循冯诺依曼的思路进行自我复制的软件已经存在：DNA双螺旋结构。

Transformer背景介绍

Transformer指的是一种架构，未来的NLP(自然语言处理)都可以使用此架构。Transformer由编码器、解码器(后面会介绍)等组成，他的输入是向量数组，输出是也是向量数组。

注意：Transformer架构的输出是把向量逐个输出的。

Transformer架构最初只用来做机器翻译，例如将英语翻译成德语。在翻译的过程中待翻译语句作为输入，而翻译结果作为输出。待翻译语句中的每一个Token(词)会被转化为向量作为输入，Transformer的输出向量最终被转化为翻译结果的Token(词)。由于Transformer逐一输出结果的特性，翻译结果是一个Token(词)一个Token(词)逐渐输出的。

Transformer架构不仅仅只可以用与机器翻译，Transformer现在也用于GPT中，就是GPT的最后一个字母T所代表的含义。由于Transformer逐一输出结果的特性，GPT也是一个Token(词)一个Token(词)逐渐输出的。

注意力机制

注意力机制源自做翻译时的技巧，当我们翻译某个词的时候，我们应该注意这个词。例如我们如果要翻译以下句子为中文：

1

Hello World !

假设他的标准答案是：你好，世界！

当我们写下中文你好的时候，我们需要注意单词Hello，因为这个单词将被翻译成你好，当我们写下中文世界的时候，我们需要注意单词World。注意力机制就试图让机器明白以上道理。

更加严谨一点，在训练时，用公式表示即为：假设已知输入为向量数组$K$包含向量$K_1$,$K_2$,$K_3$等。假设预期输出为向量$V$包含向量$V_1$,$V_2$,$V_3$等，已知注意力为$A$，$A_{ij}$代表$V_i$的计算中，$K_{j}$所占的权重。

那么便有了计算公式$V_i=F(f_{i1},f_{i2},f_{i3}…)$,$f_{ij}=f(A_{ij},K_{j})$, 注意其中的$F$函数和$f$函数，如何设定都可以。

在测试时，假设一个测试数据为向量$Q$包含$Q_1Q_2Q_3$, 按照$V$的计算公式，其中只有$A$需要变更，因为$A_{ij}$代表$V_i$(而不是$Q_i$)的计算中，$K_{j}$所占的权重。这里只需要想办法换成想要的注意力即可，方法有很多，主要围绕$Q$和$V$的相似关系来计算，这里不做展开。下文介绍一种使用自注意力机制的方案来计算相似关系。

自注意力机制

自注意力机制源于另一个技巧，当我们翻译某个词的时候，我们应该注意另一个词。例如：

1

The program has a bug

当我们翻译bug的时候，不能把它翻译成虫子。我们需要注意到前面的单词program，因此翻译成问题

因此我们将一份训练数据的输入，即当做$K$,又当做$V$,也当做$Q$。于是就可以训练出前文说的注意力$A$

// TODO

多头自注意力机制

由于自注意力机制可学习的参数较少，多头自注意力机制用来扩充自注意力机制的可学习参数。

多头自注意力机制，将输入投影到$N$个不同的空间，得到$N$个输入，分别做自注意力机制，得到$N$个输出，最终通过全连接层投影回来，得到一个输出。

在这个过程中，产生了投影的参数、全连接的参数，可学习参数就多起来了。

位置编码

自注意力模型，不受位置的影响。考虑一个输入是向量数组，若打乱输入顺序，不影响输出结果，这个是不合适的，可以考虑直接把位置也编码进输入中，方案是使用三角函数给输入向量的每一个维度都加上周期的三角函数值。

为什么是三角函数？这是收到计算机中数字编码的启发。若把计算机中的32位数字的每一个位拿来看，从0到最大值，32位的每一个位都是周期不同的01变换（最低位变换为010101…，次低位是001100110011…，再次为000011110000111100001111…），这其实也是一种三角函数。

Transformer

// TODO

x

这里立Flag，没人看得到，没人看得到的Flag，就是能实现的Flag。

2023，每天读书1.5小时；

2023，周末每天读书6小时。

2023，每个月一篇技术Blog，一篇文学Blog。

2023，变成精致男孩，哈哈哈。

VPN 与 Proxy

VPN 和Proxy有什么区别呢，国内的各大平台极力屏蔽了VPN和Proxy这两个关键字，很多人都分不清他们的关系。

VPN全名虚拟专用网络，Proxy全名代理。

其实，VPN工作于操作系统级别，而Proxy工作在应用级别。如果你配置了VPN，那么所有的应用都进入了虚拟的网络；但如果你配置了代理，只有支持代理的那部分应用才可以进入到虚拟的网络，不支持代理的APP，则无法使用虚拟网络。

VPN原理图

Proxy原理图

总结

上面两张图已经完美诠释了VPN和Proxy的核心区别了。

CPU分类

CPU分两类，精简指令集CPU（RISC）和复杂指令集CPU（CISC）。Intel、AMD厂商主要做复杂指令集CPU；IBM，ARM厂商主要做精简指令集CPU。

精简指令集CPU能耗低，性能相对较弱，常用于移动设备；复杂指令集CPU能耗高，性能强，常用于桌面设备。

CPU架构分类

不同厂商做的CPU，其架构也不尽相同，目前为止，比较多的架构有四种，ARM架构、X86架构、MIPS架构、PowerPC架构。

ARM架构CPU为精简指令集CPU；X86架构CPU为复杂指令集CPU；MIPS架构和PowerPC架构目前用的不太多了。笔者大学期间学习计算机组成原理的时候，学的就是MIPS架构。

以哪个镜像作为基础镜像

centos:centos8

1

docker run -it --rm centos:centos8

换源

阿里源

1
2
3
4
5

sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-* \
&& sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-* \
&& curl https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo -L -o /etc/yum.repos.d/CentOS-Base.repo \
&& yum clean all \
&& yum makecache

安装Git

yum 安装

1

yum install git -y

二进制安装

1

安装Clang

yum安装

1

yum install clang -y

二进制安装

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

```



# 安装SSH

## yum安装

```shell
yum install openssh-server openssh-clients passwd  -y \
&& sed -i "s/^UsePAM yes/UsePAM no/g" /etc/ssh/sshd_config \
&& echo 123456 | passwd root --stdin \
&& ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa \
&& cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys \
&& chmod 0600 ~/.ssh/authorized_keys \
&& ssh-keygen -q -N "" -t rsa -f /etc/ssh/ssh_host_rsa_key \
&& ssh-keygen -q -N "" -t ecdsa -f /etc/ssh/ssh_host_ecdsa_key \
&& ssh-keygen -q -N "" -t ed25519 -f /etc/ssh/ssh_host_ed25519_key

启动

1

/usr/sbin/sshd

1. 总揽

很老的一本书，但是依然有阅读价值。

全书分为4个部分，其中比较重要的应该是第二章和第三章，第二章主要讲解客户端（浏览器）如何保障用户的安全，第三章主要讲解服务端如何保障用户安全。

2. 客户端安全

客户端这边容易受到攻击的主要有三个类型。

第一个是XSS攻击，全名跨站脚本攻击，通常指的是黑客通过某些手段，篡改了用户访问的页面，导致页面上执行了一些恶意的脚本。一个简单的例子：在你登陆淘宝之后，黑客篡改了你的淘宝页面（篡改了用户访问的页面），自动帮你购买了一些奇怪的东西（执行了一些恶意的脚本）。

第二个是CSRF攻击，全名跨站点请求伪造，通常指的是黑客通过某些手段，诱导用户访问某钓鱼页面，在该页面上完成了一些恶意的脚本。一个简单的例子： 在一些诱惑下你点开了一个页面（诱导用户访问某钓鱼页面），尽管你之后什么都没有做，但是你的淘宝购物车被恶意清空了（在该页面上完成了一些恶意的脚本）

第三个是ClickJacking攻击，全名点击劫持攻击，通常指的是黑客通过某些手段，诱导用户访问某钓鱼页面，该页面有个按钮，按钮上悬浮了一个透明的iframe，然后引诱你点击该按钮，当你点击该按钮时触发了iframe中的按钮。一个例子是：在一些诱惑下你点开了一个页面，然后在该页面的诱惑下你点击了一个按钮，结果你的淘宝购物车被恶意清空了。

2.1. XSS

XSS的核心就是篡改用户访问的页面，攻击者是如何来实施篡改的呢？

2.1.1. 评论区XSS

很多博客都有一些评论区，用户可以在其中输入一些文本，然后这些文本会展示在评论区。

部分评论区直接把用户的文本解析为HTML语言，

但如果用户输入了一些别有用心的文本，其中包含了一些可执行的脚本，然后被浏览器执行了，这就是XSS攻击。

2.1.2. 总结

所以实际上XSS的是攻击者利用了系统的漏洞，导致系统没有按照开发者所期望的那样运行导致的。这种情况和SQL注入特别相似。

开发者所需要做的就是不要信任用户的输入，不要执行用户的输入内容即可，对于评论系统，可以只允许用户输入部分带限制的内容，借此来解决这个问题。

2.2. CSRF

CSRF的核心是跨站，很多开发者对跨站请求了解不多，在一些偶然的情况下，允许任何跨域请求来到自己的后台，这其实是非常危险的。

2.2.1. CSRF例子

开发者允许任何域的请求进行跨域，结果攻击者自己做了一个网站，在里面通过跨域调用，删除当前用户的所有数据，

这时候如果一个大冤种来到了这个网站，大冤种的数据就全部被删除了。

2.2.2. 总结

不要允许不可信任的域发起跨域请求就能解决这个问题。当然有些请求不涉及到跨域，比如GET请求，这种就要求开发者不要把一些重要的敏感度高的请求用GET实现。

2.3. ClickJacking

点击劫持，多发生于，iframe页面，这个和iframe有关，这里知道原理就行，就是一个透明的iframe在作妖，具体细节笔者不感兴趣。

3…

后面的内容一般般了，不写了

1. AspectJ

1.1. AspectJ介绍

AspectJ官网^4

AspectJ文档^1

1.1.1. pointcuts

pointcuts指的是程序中的某些链接点（某些时机），例如call(void Point.setX(int))表示：调用类Point的setX(int)方法时

pointcuts可以使用与或非表达式（||,&&,!）连接，比如 call(void Point.setX(int)) || call(void Point.setY(int))

pointcuts可以被定义为变量，如下面代码中的move()

1
2
3
4
5
6

pointcut move():
    call(void FigureElement.setXY(int,int)) ||
    call(void Point.setX(int))              ||
    call(void Point.setY(int))              ||
    call(void Line.setP1(Point))            ||
    call(void Line.setP2(Point));

当然pointcuts定义的时候还可以使用通配符，比如call(void Figure.make*(..))代表Figure的以make开头且返回值为void的方法（不关心参数）调用的时候。比如call(public * Figure.* (..))代表Figure的任何方法（不关心方法名，参数，返回值）调用的时候。

cflow是什么？

1.1.2. advice

pointcuts 指出了一些事件发生的时机，当这些事件真正发生的时候，我们需要advice表示该做些什么。advice如下，advice可以使用before代表在pointcuts发生以前做一些事情,如下

1
2
3

before(): move() {
    System.out.println("before move");
}

使用after代表在pointcuts发生以后做一些事情，如下

1
2
3

after(): move(){
    System.out.println("after move");
}

after还可以加上修饰符returning和throwing，分别表示在正常返回和在异常返回的情况，如下

1
2
3
4
5
6
7

after() returning: move(){
    System.out.println("after move");
}

after() throwing: move(){
    System.out.println("after move");
}

around表示环绕一个方法

1.1.3. aspect

aspect是一个特别的类型，在其中可以定义pointcut和advice，如下

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

aspect MyAspect{

    pointcut move():
        call(void FigureElement.setXY(int,int)) ||
        call(void Point.setX(int))              ||
        call(void Point.setY(int))              ||
        call(void Line.setP1(Point))            ||
        call(void Line.setP2(Point));
    
    after(): move(){
        System.out.println("after move");
    }
}

当然aspect兼容java，你也可以定义各种方法，变量

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

aspect MyAspect{

    private Integer intValue;
    
    public Integer getInt(){
        return intValue;
    }

    pointcut move():
        call(void FigureElement.setXY(int,int)) ||
        call(void Point.setX(int))              ||
        call(void Point.setY(int))              ||
        call(void Line.setP1(Point))            ||
        call(void Line.setP2(Point));
    
    after(): move(){
        System.out.println("after move");
    }
   
}

1.2. 在IntelliJ IDEA上安装AspectJ

1.2.1. 下载并安装AspectJ

在官网^4下载最新版本的jar包，笔者这里的最新版本是aspectj-1.9.6.jar ，下载以后双击运行进行安装。

AspectJ安装

1.2.2. 安装插件

安装AspectJ插件^2即可

1.2.3. 启用AJC编译器

在IDEA的设置中选择AJC编译器，并指定1.2.1中安装的ajctool的位置。

IDEA_Enable_AJC

1.2.4. 给项目添加AJC依赖

把1.2.1中安装的lib包放到项目的依赖中。

Add_AJC_Lib.png

1.3. Hello World

下面是一份Helloworld的代码,源程序只输出+号，但是被aspect所拦截，最终输出了Hello + World!

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

class HelloWorld {

    public void hello(){
        System.out.print("+");
    }

    public static void main(String[] args) {
        new HelloWorld().hello();
    }
}


aspect HelloWorldAspect {
    before(): call(public * HelloWorld.*(..)){
        System.out.print(" Hello ");
    }
    after(): call(public * HelloWorld.*(..)){
        System.out.print(" World! ");
    }
}

1.4. Pointcuts表达式

• 执行一个特定的方法的时候

  1	execution(void Point.setX(int))

  例如下面的代码

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

  class HelloWorld { public void hello(){ System.out.print("+"); } public static void main(String[] args) { new HelloWorld().hello(); } } aspect HelloWorldAspect { before(): execution(public * HelloWorld.hello(..)){ System.out.print(" Hello "); } after(): execution(public * HelloWorld.hello(..)){ System.out.print(" World! "); } }

  被编译为了

  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

  // // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // class HelloWorld { HelloWorld() { } public void hello() { try { HelloWorldAspect.aspectOf().ajc$before$HelloWorldAspect$1$75869607(); System.out.print("+"); } catch (Throwable var2) { HelloWorldAspect.aspectOf().ajc$after$HelloWorldAspect$2$75869607(); throw var2; } HelloWorldAspect.aspectOf().ajc$after$HelloWorldAspect$2$75869607(); } public static void main(String[] args) { (new HelloWorld()).hello(); } }

  代码被直接写入到了hello方法执行的地方。

• 调用一个特定方法的时候

  1	call(void Point.setX(int))

  例如下面的代码

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

  class HelloWorld { public void hello(){ System.out.print("+"); } public static void main(String[] args) { new HelloWorld().hello(); } } aspect HelloWorldAspect { before(): call(public * HelloWorld.*(..)){ System.out.print(" Hello "); } after(): call(public * HelloWorld.*(..)){ System.out.print(" World! "); } }

  被编译为了

  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

  // // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // class HelloWorld { HelloWorld() { } public void hello() { System.out.print("+"); } public static void main(String[] args) { HelloWorld var10000 = new HelloWorld(); try { HelloWorldAspect.aspectOf().ajc$before$HelloWorldAspect$1$cdc2ab29(); var10000.hello(); } catch (Throwable var2) { HelloWorldAspect.aspectOf().ajc$after$HelloWorldAspect$2$cdc2ab29(); throw var2; } HelloWorldAspect.aspectOf().ajc$after$HelloWorldAspect$2$cdc2ab29(); } }

  可以看到，是在调用hello方法的前后增加了一些内容。

• 处理异常的时候

  1	handler(ArrayOutOfBoundsException)

  如下面的代码

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

  class HelloWorld { public void hello() { try { System.out.print("+"); } catch (Exception e) { System.out.print(e.getMessage()); } } public static void main(String[] args) { new HelloWorld().hello(); } } aspect HelloWorldAspect { before(): handler(Exception){ System.out.print(" Hello "); } }

  被编译为了

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

  // // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // class HelloWorld { HelloWorld() { } public void hello() { try { System.out.print("+"); } catch (Exception var3) { HelloWorldAspect.aspectOf().ajc$before$HelloWorldAspect$1$ae9a1a78(); System.out.print(var3.getMessage()); } } public static void main(String[] args) { (new HelloWorld()).hello(); } }

  可以发现就是在catch该exception后的第一步操作

  当然AspectJ还有很多很多可以定义point cut的关键词，笔者这里就不一一列举了，相见文档[^5]即可

1.5. 总结

所以AspectJ其实是对Java语法的拓展，通过特定的编译器，给Java带来了更强大的能力。

2. Spring 对 AspectJ的支持

官方文档^3

Spring支持AspectJ的一个子集,所支持的pointcut如下

Spring AOP supports the following AspectJ pointcut designators (PCD) for use in pointcut expressions:

• execution: For matching method execution join points. This is the primary pointcut designator to use when working with Spring AOP.
• within: Limits matching to join points within certain types (the execution of a method declared within a matching type when using Spring AOP).
• this: Limits matching to join points (the execution of methods when using Spring AOP) where the bean reference (Spring AOP proxy) is an instance of the given type.
• target: Limits matching to join points (the execution of methods when using Spring AOP) where the target object (application object being proxied) is an instance of the given type.
• args: Limits matching to join points (the execution of methods when using Spring AOP) where the arguments are instances of the given types.
• @target: Limits matching to join points (the execution of methods when using Spring AOP) where the class of the executing object has an annotation of the given type.
• @args: Limits matching to join points (the execution of methods when using Spring AOP) where the runtime type of the actual arguments passed have annotations of the given types.
• @within: Limits matching to join points within types that have the given annotation (the execution of methods declared in types with the given annotation when using Spring AOP).
• @annotation: Limits matching to join points where the subject of the join point (the method being run in Spring AOP) has the given annotation.

spring中的aspectJ，并非使用拓展java语法，而是使用注解来拓展，spring中的aspectj也不是使用的aspectj编译器，而是使用的spring aop来完成代理。但spring也支持通过开关使用原生aspectj[^6]。

aspect的类型用注解@Aspect表示

pointcut字段用@Pointcut表示

advice分别用@Before、@After、@Around来表示

3. 引用

[^5]: Aspect pointcut 文档
[^6]: Spring中使用AspectJ编译器

0. 一个错误的概念

1
2
3
4
5
6

int main() {
    int a = 111;
    int &b = a;
    b = 222;
    std::cout<<&a<<&b;
}

我们能看到这里输出的两个值相同。

• 错误1:

  很多人认为这里的b就是a，a就是b，a和b的地址是一样的，如下图。

  

  但是笔者要说，其实这个概念是有问题的，a是a，b是b，a和b并不是同一个地址。

1. 从STD的tie类型说起

笔者在阅读ClickHouse源码的时候发现了有趣的现象，该源码中有如下代码，我们注意第7-9行，可以发现这使用了STD的tie，该类型让C++实现了一次性返回两个值的效果。下面的executeQueryImpl函数返回了两个值，分别写入到了ast和streams中。

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

BlockIO executeQuery(
    const String & query,
    ContextMutablePtr context,
    bool internal,
    QueryProcessingStage::Enum stage)
{
    ASTPtr ast;
    BlockIO streams;
    std::tie(ast, streams) = executeQueryImpl(query.data(), query.data() + query.size(), context, internal, stage, nullptr);

    if (const auto * ast_query_with_output = dynamic_cast<const ASTQueryWithOutput *>(ast.get()))
    {
        String format_name = ast_query_with_output->format
                ? getIdentifierName(ast_query_with_output->format)
                : context->getDefaultFormat();

        if (format_name == "Null")
            streams.null_format = true;
    }

    return streams;
}

2. 如何实现的

实际上C++中可以在结构体中指定一个引用字段，通过构造函数将外界的变量传递进结构体，再通过该结构体的拷贝构造函数实现赋值。

3. 结构体中如何储存引用

结构体如何储存其他值的引用？按照前文的说法，如果引用的地址是一样的，结构体如何储存其他值的引用呢，如下图。

实际上唯一的办法只能使用指针，让变量b指向变量a，当然这里的变量b的类型就是指针类型了，这么说肯定很多人不能接受，我定义的引用类型，怎么就成了指针了。

4. 揭秘结构体中的引用

先来看下面的代码,下面这两个函数，写法不一样，但是被GCC编译器编译以后的结果是一模一样的。

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

struct Ref {
    explicit Ref(int &ref) : ref(ref) {}

    int &ref;
    int value;
};

struct Point {
    explicit Point(int *ref) : ref(ref) {}

    int *ref;
    int value;
};

void ref() {
    int x = 222;
    Ref a(x);
    a.ref = 333;
    a.value = 444;
}

void point() {
    int x = 222;
    Point a(&x);
    *a.ref = 333;
    a.value = 444;
}

int main() {
}

读者可以通过指令 gcc -S -O0 main.cpp来编译该文件。可以看到两个函数都被编译结果为下面的内容，注意14-15行，这里就是ref赋值的地方，我们很容易发现，第一步是把rbp栈寄存器指向的地址偏移24的位置的值放入了寄存器rax中，第二步是将数据333写入rax寄存器所指向的地址。所以引用不过是指针的另一种写法而已。

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

__Z5pointv:                             ## @_Z5pointv
.cfi_startproc
## %bb.0:
pushq%rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq%rsp, %rbp
.cfi_def_cfa_register %rbp
subq$32, %rsp
movl$222, -4(%rbp)
leaq-24(%rbp), %rdi
leaq-4(%rbp), %rsi
callq__ZN5PointC1EPi
movq-24(%rbp), %rax
movl$333, (%rax)                    ## imm = 0x14D
movl$444, -16(%rbp)                 ## imm = 0x1BC
addq$32, %rsp
popq%rbp
retq
.cfi_endproc
                                        ## -- End function
.globl__ZN5PointC1EPi                 ## -- Begin function _ZN5PointC1EPi
.weak_def_can_be_hidden__ZN5PointC1EPi
.p2align4, 0x90

5. 普通引用是如何实现的

我们使用gcc -S -O0 main.cpp编译下面的代码

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

void check() {
    int a = 111;
    int &b = a;
    b = 222;
}

void check2() {
    int a = 111;
    int *b = &a;
    *b = 222;
}

int main() {
}

不难发现两个函数都被编译成了相同的代码,于是乎，现在应该不会再有人认为这里的b就是a，a就是b，a和b的地址是一样的了吧

很明显b就是指针啊，他怎么能是和a的地址相同呢？

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

__Z5checkv:                             ## @_Z5checkv
.cfi_startproc
## %bb.0:
pushq%rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq%rsp, %rbp
.cfi_def_cfa_register %rbp
movl$111, -4(%rbp)
leaq-4(%rbp), %rax
movq%rax, -16(%rbp)
movq-16(%rbp), %rax
movl$222, (%rax)
popq%rbp
retq
.cfi_endproc
                                        ## -- End function
.globl__Z6check2v                     ## -- Begin function _Z6check2v
.p2align4, 0x90

正确的引用图应该是下面这张

1. 对List不能很好的支持

1.1. 核心代码

代码中写的是数组

1
2
3
4
5

/**
 * 用户
 */
@ApiModelProperty(value = "用户",example = "hellowang")
private List<String> user;

1.2. 问题详情

在swagger页面展示的例子是字符串

1
2
3

{
  "user": "hellowang"
}

1.3. 问题讨论

Stackoverflow

Github

1.4. 解决方案

springfox-collection-example-plugin

1. Go 的指针

Go的指针和C的指针很类似，这也是Go被归类于C类语言的原因，Go的指针不支持偏移运算，即不能向C一样让指针+1，-1。

1.1. 正常使用

先来看第一个，符号&即可取到对象的地址。

1
2
3
4
5
6
7

func sample1() {
arr1 := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

fmt.Println(arr1)

fmt.Println(&arr1)
}

1
2

[0 1 2 3 4 5 6 7 8 9]
&[0 1 2 3 4 5 6 7 8 9]

1.2. for循环问题

下面的输出全是9，因为for循环的value是共用一个地址的。

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

func sample2() {
arr1 := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

mp := map[int]*int{}

for i, value := range arr1 {
mp[i] = &value
}


for i, _ := range arr1 {
fmt.Println(*mp[i])
}
}

2. Go 的 new 和 make

参考

new 只分配内存，make不仅分配内存还初始化对象。

slice、chan、map一般可以使用make初始化。

1. Module使用

在文章Go入门-Go语言从入门到进阶实战中，我们介绍了GO项目的结构，但是没有解释其中的一个文件go.mod, 这其实是模块的意思。在go.mod中可以引入go的依赖。

1
2
3
4
5
6

require (
github.com/golang/mock v1.4.4
github.com/golang/protobuf v1.4.3
github.com/patrickmn/go-cache v2.1.0+incompatible
github.com/stretchr/testify v1.6.1
)

这里简单介绍一下，注意到这里是库名加版本号。当我们引入了依赖管理以后，就可以在自己的项目中直接import三方包了。

2. Module 的历史

Go modules 是 Go 语言的依赖解决方案，发布于 Go1.11，Go1.14 上已经明确建议生产上使用了

• 一开始go发布的时候是没有包管理的

• go get命令会根据路径，把相应的模块获取并保存在$GOPATH/src

• 也没有版本的概念，master 就代表稳定的版本

原文： 😊

在Go Module出现以前,我们使用Go Get获取库，库会直接下载到GOPATH目录的src文件夹下，很好用但是有一个问题-版本兼容问题。

当两个库依赖分别同一个库的v1和v2版本的时候，如果v1和v2不兼容，那么会导致这两个库无法同时使用。

后来官方采用了vgo方案来解决GO的依赖管理问题，也就是现在的Go modules。

3. go.mod 与 go.sum

go.mod控制依赖，go.sum校验依赖的完整性与正确性。

4. Go111MODULE参数

• GO111MODULE=off 无模块支持，go 会从 GOPATH 和 vendor 文件夹寻找包。

• GO111MODULE=on 模块支持，go 会忽略 GOPATH 和 vendor 文件夹，只根据 go.mod 下载依赖。

  原文：😊

参考

Golang Package 与 Module 简介

Go Modules 包管理工具的理解与使用

1. Effective GO

https://github.com/bingohuang/effective-go-zh-en

2. 格式化

在最开始学习GO的时候，写了几篇Blog，发现代码里面的对齐都是TAB，这让我很困惑，知道现在才知道，GO语言，默认使用TAB进行对齐。

当然GO还有自己的空格规则x<<8 + y<<16,向这份代码，我们根据空格就能知道计算的优先级了。

3. 注释

3.1. 包注释

Go语言要求package语句前加上注释，来介绍整个包，如果package包含多个文件，则只需要在其中一个文件中标注即可。

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

/*
Package regexp implements a simple library for regular expressions.

The syntax of the regular expressions accepted is:

regexp:
concatenation { '|' concatenation }
concatenation:
{ closure }
closure:
term [ '*' | '+' | '?' ]
term:
'^'
'$'
'.'
character
'[' [ '^' ] character-ranges ']'
'(' regexp ')'
*/
package regexp

需要注意的是，注释不是JavaDoc模式的,下面这种就不对了

1
2
3
4
5
6

/**
 *
 *  main
 *
 */
package main

3.2. 导出注释

在程序中，每个可导出（首字母大写）的名称都应该有文档注释。使用行注释的形式，行注释的第一行要以被导出的内容开头，并总结整个注释，如下，第一行以Compile开头

1
2
3

// Compile parses a regular expression and returns, if successful, a Regexp
// object that can be used to match against text.
func Compile(str string) (regexp *Regexp, err error) {

4. 命名

Go语言默认使用驼峰命名，请不要使用下划线

4.1. 包

包名用小写，不要带下划线，

不要使用import .的语句，很容易冲突

4.2. 字段Getter Setter

Getter方法不需要Get这个前缀,如下

1
2

obj.Owner()
obj.SetOwner(user)

4.3. 接口名

只包含一个方法的接口命名以er结尾。

5. 分号

在Go中，行末，不要加入分号。

分号其实是由词法分析器自动增加的。

6. 控制流

6.1. 变量重新声明

下面的这份代码，注意到其中的err申明了两次，上面这个err声明了两次，但是这并不是错误，编译器会帮忙解决这个问题，实际上err第二次只是被重新赋值而已。

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

package main

import (
"fmt"
"os"
)

func main() {
f1, err := os.Open("file")
fmt.Println(f1,err)

f2, err := os.Open("file2")
fmt.Println(f2,err)
}

当然这样的技巧只能在特殊情况才能生效

• 本次声明与已声明的 v 处于同一作用域中（若 v 已在外层作用域中声明过，则此次声明会创建一个新的变量 §），
• 在初始化中与其类型相应的值才能赋予 v，且
• 在此次声明中至少另有一个变量是新声明的。

7. 函数

7.1. 可命名结果形参

在Go中，可以在函数上声明返回值变量，在返回的时候只需要一个return即可

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

package main

import (
"fmt"
)

func f() (value int, info string) {
value=1
info="hello"
return
}

func main() {
fmt.Println(f())
}

7.2. Defer

defer是一种推迟执行的语法，被该关键词修饰的语句会在函数返回的时候执行

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

package main

import "fmt"

func f1(str string) {
fmt.Println(str)
}

func main() {
f1("hi1")
defer f1("hi5")
defer f1("hi4")
defer f1("hi3")
f1("hi2")
}
// 输出：
//hi1
//hi2
//hi3
//hi4
//hi5
//

8. 初始化

主要是init函数，一个文件可以有多个init函数，他们都会被调用，init函数在包的全局变量初始化以后执行

注意到下面这个代码，先输出abc， 与init的位置无关，init在全局变量之后执行

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

package main

import "fmt"

func p(str string) (int)  {
fmt.Println(str)
return 1;
}

var a = p("a")

func init() {
p("init1")
}

var b = p("b")

func init() {
p("init2")
}

var c = p("c")

func main() {
p("main")
}
/*
输出：
a
b
c
init1
init2
 */

0. 前置知识

需要提前有字典树的知识

1. 双数组字典树介绍

双数组字典树英文名为DoubleArrayTrie，他的特点就是使用两个数组来表示一颗字典树，这里有比较有趣了，两个数组是怎么表达出字典树的呢？

2. 双数组介绍

顾名思义，有两个数组，一个是base，另一个是check。

首先介绍数组的下标，数组的下标代表字典树上节点的编号，一个下标对应一个节点。

其实base数组的作用是用来记录一个基础值，这个值可以是随机值，只要不产生冲突就可以了，所以这个值可以用随机数算法获取，当然这样效率不高，高效的做法应该是使用指针枚举技术，ok，现在你已经明白了，base数组是一个不产生冲突的随机数组。

最后，check数组，check数组与base数组相互照应，如果base[i]=check[j] 则说明j是i的儿子，而且i到j的边权恰好为j-base[i]，也可以写作j-check[j]好好理解这句话

从另一个方面而言，双数组字典树的base数组，应该是一个指针数组，他指向了一个长度为字符集大小的数组的首地址，而check数组是一种hash碰撞思路，由于base数组疯狂指向自己，导致产生了很多碰撞，但是由于字典树是一个稀疏图，导致儿子节点指针利用率低，所以base数组疯狂复用这段空间，最后必须要依赖check来解决冲突，

双数组字典树相比于传统字典树，仅仅只在内存方面于增删改查占有优势，但是唯一不好的地方就是删和改会导致base数组内存分裂，难以回收，删和改如果占大头，那么传统字典树的内存效率更高

由于搜索领域几乎不涉及到删和改，所以这个数据结构很nice，字符集多大，就节省了多少倍的空间

数据结构很棒，但是在现在这个内存不值钱的时代，这些指针的储存用hashmap直接无脑顶掉，空间占用也高不了多少，hashmap顶多浪费两倍空间

两倍的空间算不上啥，除非这是唯一的优化点，否则不会优化到这个数据结构上来

3. 图解双数组字典树

首先我们直接给出一颗双数组字典树，下面是三列，第一列是下标，第二列是base，第三列是check， 我们来根据这个双数组还原那颗字典树

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

index base check
0 1 0
66 2 1
68 3 1
69 5 2
70 6 2
71 7 3
73 8 3
74 10 5
75 11 5
81 12 11
85 9 4
91 4 1

从第一行看起，base[0]=1, check[0]=0 ,这说明根节点是0号节点。

1
2

graph LR
  0

然后我们来找0节点的子节点，只需要哪些check值为base[0]即可，我们发现check[66],check[68],check[91]满足，所以他们都是0号节点的子节点

对于check[66], 边权为66-check[66]=65 ,是字符A

对于check[68], 边权67, 是字符C

对于check[91], 边权90，是字符Z

所以现在图成了

1
2
3
4

graph LR
  0--A-->66
  0--C-->68
  0--Z-->91

接着我们看66号节点，base[66]=2,那么他的子节点为69和70，边权分别为69-check[69]=67,70-check[70]=68,分别是C和D

1
2
3
4
5
6

graph LR
  0--A-->66
  0--C-->68
  0--Z-->91
  66--C-->69
  66--D-->70

69的字节点为74和75， 权重为74-5=69和75-5=70， 分别是E和F

1
2
3
4
5
6
7
8

graph LR
  0--A-->66
  0--C-->68
  0--Z-->91
  66--C-->69
  66--D-->70
  69--E-->74
  69--F-->75

当然，后面的笔者就不进行模拟了，到此为止。

4. 双数组字典树的构建算法

首先算法的第一步是构建一颗字典树，你需要将这颗字典树构建出来。字典树的代码如下,这个不用多说了

1
2
3
4
5
6
7
8
9

void addTire(const char* str, int len) {
    int root = 1;
    for (int i = 0; i < len; i++) {
        if (tire[root][str[i]] == 0) {
            tire[root][str[i]] = ++tireTot;
        }
        root = tire[root][str[i]];
    }
}

第二步，就是在字典树上进行BFS，在BFS过程中增量构建双数组字典树，当我们BFS到某个节点U的时候，便开始寻找，当前还有哪个base值没有被使用，可以使得这个U的子节点的check值均为0， no BB , show code

先找到U的所有子节点

1
2
3
4
5
6
7
8

vector<int> sonTransList;
for (int i = 0;i < maxCharest;i++) {
    if (tire[tireTop][i] != 0) {
        sonTransList.push_back(i);
        tireQ.push(tire[tireTop][i]);
    }
}
cout << "find son: " << sonTransList.size() << endl;;

然后寻找一个合适的base值，这个值储存在变量begin中

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

// find begin
while (true) {
    begin++;
    bool ok = true;
    for (int son : sonTransList) {
        if (check[begin + code[son]] != 0) {
            ok = false;
            break;
        }
    }
    if (ok) {
        break;
    }
}

最后就是赋值就好了.

5. 代码

最后附上一个很丑的代码，第三节中介绍的双数组就来源于这个代码的输出。

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
111
112
113
114
115

// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <queue>
#include <iostream>
#include <string>
using namespace std;

string stringData[] = {
        "AC",
        "ACE",
        "ACFF",
        "AD",
        "CD",
        "CF",
        "ZQ"
};



const int maxCharest = 256;
int tire[1000][maxCharest], tireTot = 1;

void addTire(const char* str, int len) {
    int root = 1;
    for (int i = 0; i < len; i++) {
        if (tire[root][str[i]] == 0) {
            tire[root][str[i]] = ++tireTot;
        }
        root = tire[root][str[i]];
    }
}


int code[maxCharest];

void buildDAT() {
    // init code
    for (int i = 0;i < maxCharest;i++) {
        code[i] = i;
    }
    vector<int> tireState2DatState(1000);

    // TODO vector
    vector<int> check(1000), base(1000);

    // bfs
    queue<int> tireQ;
    tireQ.push(1);
    tireState2DatState[1] = 0;

    int begin = 0;

    while (!tireQ.empty()) {
        int tireTop = tireQ.front();
        tireQ.pop();

        vector<int> sonTransList;
        for (int i = 0;i < maxCharest;i++) {
            if (tire[tireTop][i] != 0) {
                sonTransList.push_back(i);
                tireQ.push(tire[tireTop][i]);
            }
        }
        cout << "find son: " << sonTransList.size() << endl;;

        // find begin
        while (true) {
            begin++;
            bool ok = true;
            for (int son : sonTransList) {
                if (check[begin + code[son]] != 0) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                break;
            }
        }

        base[tireState2DatState[tireTop]] = begin;
        for (int i = 0;i < maxCharest;i++) {
            if (tire[tireTop][i] != 0) {
                int son = i;
                if (check[begin + code[son]] != 0) {
                    exit(-1);
                }
                check[begin + code[son]] = begin;
                tireState2DatState[tire[tireTop][i]] = begin + code[son];
            }
        }
        for (int i = 0;i < 1000;i++) {
            if (check[i] != 0 || base[i] != 0) {
                cout << i << " " << base[i] << " " << check[i] << endl;
            }
        }
        cout <<begin<<"--------" << endl;
    }

  
}


int main() {

    for (int i = 0;i < 7;i++) {
        addTire(stringData[i].data(), stringData[i].size());
    }
    buildDAT();


}

0. 前言

简单介绍Beego和Gin，水一水文章。

1.1. 安装Beego库

1

go get github.com/astaxie/beego

同时安装Bee工具

1

go get github.com/beego/bee

看到如下内容代表安装成功

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

s@HELLOWANG-MB1 ~ % go get github.com/astaxie/beego
go: downloading github.com/astaxie/beego v1.12.3
go: downloading github.com/prometheus/client_golang v1.7.0
go: downloading github.com/hashicorp/golang-lru v0.5.4
go: downloading golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550
go: downloading github.com/shiena/ansicolor v0.0.0-20151119151921-a422bbe96644
go: downloading github.com/prometheus/common v0.10.0
go: downloading github.com/prometheus/client_model v0.2.0
go: downloading github.com/prometheus/procfs v0.1.3
go: downloading github.com/beorn7/perks v1.0.1
go: downloading golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1
go: downloading github.com/cespare/xxhash/v2 v2.1.1
go: downloading github.com/golang/protobuf v1.4.2
go: downloading github.com/matttproud/golang_protobuf_extensions v1.0.1
go: downloading google.golang.org/protobuf v1.23.0
s@HELLOWANG-MB1 ~ % go get github.com/beego/bee
go: downloading github.com/beego/bee v1.12.3
go: downloading github.com/gadelkareem/delve v1.4.2-0.20200619175259-dcd01330766f
go: downloading github.com/gorilla/websocket v1.4.2
go: downloading github.com/lib/pq v1.7.0
go: downloading github.com/flosch/pongo2 v0.0.0-20200529170236-5abacdfa4915
go: downloading github.com/pelletier/go-toml v1.2.0
go: downloading github.com/smartwalle/pongo2render v1.0.1
go: downloading github.com/spf13/viper v1.7.0
go: downloading github.com/astaxie/beego v1.12.1
go: downloading github.com/hashicorp/hcl v1.0.0
go: downloading github.com/magiconair/properties v1.8.1
go: downloading github.com/spf13/afero v1.1.2
go: downloading github.com/spf13/cast v1.3.0
go: downloading github.com/spf13/jwalterweatherman v1.0.0
go: downloading github.com/spf13/pflag v1.0.3
go: downloading github.com/subosito/gotenv v1.2.0
go: downloading gopkg.in/ini.v1 v1.51.0
go: downloading golang.org/x/text v0.3.2
go: downloading github.com/sirupsen/logrus v1.6.0
go: downloading github.com/cosiner/argv v0.1.0
go: downloading github.com/peterh/liner v0.0.0-20170317030525-88609521dc4b
go: downloading github.com/mattn/go-colorable v0.0.9
go: downloading github.com/mattn/go-isatty v0.0.3
go: downloading golang.org/x/arch v0.0.0-20190927153633-4e8777c89be4
go: downloading go.starlark.net v0.0.0-20190702223751-32f345186213
go: downloading github.com/konsorten/go-windows-terminal-sequences v1.0.3
go get: installing executables with 'go get' in module mode is deprecated.
Use 'go install pkg@version' instead.
For more information, see https://golang.org/doc/go-get-install-deprecation
or run 'go help get' or 'go help install'.

注意安装以后对二进制文件在$GOPATH/bin下，所以请确保该路径在你的环境变量下,笔者使用MACOS，在~/.zshrc中使用如下配置

1
2

GOPATH=~/go
PATH=$PATH:~/go/bin

1.2. 创建项目

1.2.1. 创建项目

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

s@HELLOWANG-MB1 src % bee new bee-demo
2021/10/18 17:47:29 INFO     ▶ 0001 generate new project support go modules.
2021/10/18 17:47:29 INFO     ▶ 0002 Creating application...
create /Users/s/src/bee-demo/go.mod
create /Users/s/src/bee-demo/
create /Users/s/src/bee-demo/conf/
create /Users/s/src/bee-demo/controllers/
create /Users/s/src/bee-demo/models/
create /Users/s/src/bee-demo/routers/
create /Users/s/src/bee-demo/tests/
create /Users/s/src/bee-demo/static/
create /Users/s/src/bee-demo/static/js/
create /Users/s/src/bee-demo/static/css/
create /Users/s/src/bee-demo/static/img/
create /Users/s/src/bee-demo/views/
create /Users/s/src/bee-demo/conf/app.conf
create /Users/s/src/bee-demo/controllers/default.go
create /Users/s/src/bee-demo/views/index.tpl
create /Users/s/src/bee-demo/routers/router.go
create /Users/s/src/bee-demo/tests/default_test.go
create /Users/s/src/bee-demo/main.go
2021/10/18 17:47:29 SUCCESS  ▶ 0003 New application successfully created!

1.2.2. 初始化项目

1
2
3
4

s@HELLOWANG-MB1 bee-demo % go get
go: downloading gopkg.in/yaml.v2 v2.2.1
go: downloading github.com/shiena/ansicolor v0.0.0-20200904210342-c7312218db18
go get: added github.com/shiena/ansicolor v0.0.0-20200904210342-c7312218db18

1.2.3. 启动项目

在GoLand IDE中点击▶启动项目，看到如下输出，访问http://localhost:8080/即可看到小蜜蜂

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

GOROOT=/usr/local/Cellar/go/1.17.2/libexec #gosetup
GOPATH=/Users/s/go #gosetup
/usr/local/Cellar/go/1.17.2/libexec/bin/go build -o /private/var/folders/6t/kt2nf9z17cv87lqk842lngj80000gn/T/GoLand/___go_build_bee_demo bee-demo #gosetup
/private/var/folders/6t/kt2nf9z17cv87lqk842lngj80000gn/T/GoLand/___go_build_bee_demo
2021/10/18 18:01:42.769 [I] [asm_amd64.s:1581]  http server Running on http://:8080
2021/10/18 18:04:54.533 [D] [server.go:2878]  |            ::1| 200 |   4.493325ms|   match| GET      /     r:/
2021/10/18 18:04:54.607 [D] [server.go:2878]  |            ::1| 200 |    316.098µs|   match| GET      /static/js/reload.min.js
2021/10/18 18:04:58.868 [D] [server.go:2878]  |            ::1| 200 |    1.40659ms|   match| GET      /     r:/
2021/10/18 18:05:03.305 [D] [server.go:2878]  |            ::1| 200 |   1.215993ms|   match| GET      /     r:/
2021/10/18 18:05:43.326 [D] [server.go:2878]  |            ::1| 200 |   2.620439ms|   match| GET      /     r:/
2021/10/18 18:05:43.381 [D] [server.go:2878]  |            ::1| 200 |     60.791µs|   match| GET      /static/js/reload.min.js
2021/10/18 18:09:39.216 [D] [server.go:2878]  |            ::1| 200 |   2.486943ms|   match| GET      /     r:/
2021/10/18 18:09:39.266 [D] [server.go:2878]  |            ::1| 200 |     66.282µs|   match| GET      /static/js/reload.min.js

1.2.4. Contorller

1.2.4.1 路由

路由在文件routers/router.go中, 在Beego的设计中，路由需要手动添加，即哪个PATH交给哪个Controller来处理。

1
2
3
4
5
6
7
8
9
10
11

package routers

import (
"bee-demo/controllers"
"github.com/astaxie/beego"
)

func init() {
    beego.Router("/", &controllers.MainController{})
}

1.2.4.2. Controller

MainController继承了beego.Controller,所以我们可以复写他的方法，注意到beego.Controller实现了beegoControllerInterface这个接口，里边的方法其实都比较明显了，就是HTTP协议的方法。

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

type ControllerInterface interface {
Init(ct *context.Context, controllerName, actionName string, app interface{})
Prepare()
Get()
Post()
Delete()
Put()
Head()
Patch()
Options()
Trace()
Finish()
Render() error
XSRFToken() string
CheckXSRFCookie() bool
HandlerFunc(fn string) bool
URLMapping()
}

1.2.4.3. 返回JSON数据的Controller

首先编写一个HelloController,然后把它加入到route中，最后访问/hello，就可以看到输出了。

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

package controllers

import (
"github.com/astaxie/beego"
)

type HelloController struct {
beego.Controller
}

type HelloVO struct {
Say1 string `json:"say_1"`
Say2 int    `json:"say_2"`
}

func (c *HelloController) Get() {
c.Data["json"] = &HelloVO{
Say1: "world",
Say2: 9527,
}
c.ServeJSON()
}

1
2
3
4
5

GET /hello
{
  "say_1": "world",
  "say_2": 9527
}

这一块就点到为止了，听说Beego框架不太火，了解了解就好了，笔者也不是文档翻译器，更多更加细节的部分关注这里

2.1. 安装Gin

1

go get github.com/gin-gonic/gin

2.2. 编写Hello World

编写下面的代码，然后直接运行，访问http://localhost:8080/即可看到Hello World

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

package main

import (
"net/http"

"github.com/gin-gonic/gin"
)

func main() {
r := gin.Default()
r.GET("/", func(c *gin.Context) {
c.String(http.StatusOK, "hello World!")
})
r.Run()
}

日志如下

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

GOROOT=/usr/local/Cellar/go/1.17.2/libexec #gosetup
GOPATH=/Users/s/go #gosetup
/usr/local/Cellar/go/1.17.2/libexec/bin/go build -o /private/var/folders/6t/kt2nf9z17cv87lqk842lngj80000gn/T/GoLand/___go_build_gin_demo gin-demo #gosetup
/private/var/folders/6t/kt2nf9z17cv87lqk842lngj80000gn/T/GoLand/___go_build_gin_demo
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /                         --> main.main.func1 (3 handlers)
[GIN-debug] Environment variable PORT is undefined. Using port :8080 by default
[GIN-debug] Listening and serving HTTP on :8080
[GIN] 2021/10/19 - 15:02:00 | 200 |      16.428µs |             ::1 | GET      "/"

更加具体的，参见文档，太没技术的东西笔者不喜欢写。

1. 从协程谈起

很多语言都支持协程，那什么是协程，和线程进程有什么区别呢？这里推荐一篇Blog，笔者直接提取其中最重要的部分

进程、线程 和 协程 之间概念的区别

　　对于 进程、线程，都是有内核进行调度，有 CPU 时间片的概念，进行 抢占式调度（有多种调度算法）

　　对于 协程(用户级线程)，这是对内核透明的，也就是系统并不知道有协程的存在，是完全由用户自己的程序进行调度的，因为是由用户程序自己控制，那么就很难像抢占式调度那样做到强制的 CPU 控制权切换到其他进程/线程，通常只能进行 协作式调度，需要协程自己主动把控制权转让出去之后，其他协程才能被执行到。

　goroutine 和协程区别

　　本质上，goroutine 就是协程。 不同的是，Golang 在 runtime、系统调用等多方面对 goroutine 调度进行了封装和处理，当遇到长时间执行或者进行系统调用时，会主动把当前 goroutine 的CPU (P) 转让出去，让其他 goroutine 能被调度并执行，也就是 Golang 从语言层面支持了协程。Golang 的一大特色就是从语言层面原生支持协程，在函数或者方法前面加 go关键字就可创建一个协程。

操作系统是不知道协程的，那么应用层如何实现协程呢？下面给一些伪代码

1
2
3
4
5
6
7
8

不断循环：
    从任务队列获取任务
    执行任务，如果任务运行结束:
        进行下一轮循环(continue)
    如果任务运行时进入阻塞状态:
        把当前任务放入队列尾部(挂起)
    如果任务主动释放CPU:
        把当前任务放入队列尾部(挂起)

我们可以看到，其实这里正在执行的任务就是协程，这样的线程模型，他的CPU利用率非常高，他的协程切换代价非常低，几乎只需要入队出队而已。

但是这样的模型有一个很大的缺点，那就是CPU的公平性，如果一个协程迟迟不退出，且不进行系统调用，也不主动释放CPU，那么，这个协程将造成队头阻塞现象。

2. Goroutine

想必很多人都知道这个名词，这其实就是Go的协程(coroutine), 相比于普通的协程，Go做了特殊的处理，能够在一些适当的时候，交出CPU控制权，所以Go的调度是公平的。

当然Go关于协程，也有一个Bug，这个Bug在Go1.14的时候被修复了，有兴趣的读者可以自己查看，当然笔者在下文也会通过一个更加简单的例子来复现这个Bug。

3. Bug复现

Bug的复现需要两个版本的Go进行对比才能看出来，笔者建议使用Docker。首先就是给出代码了,下面的代码启用了两个协程，第一个做CPU空轮询，第二个做不间断输出。

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

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {

    runtime.GOMAXPROCS(1)

    go func() {
        fmt.Println("begin1")
        s := 0
        for t := 0; t < 10000; t++ {

            for i := 0; i < 1000000000; i++ {
                s += i
            }
            //fmt.Println(1, "->", s)
        }
        fmt.Println("end1", s)

    }()

    go func() {
        fmt.Println("begin2")
        s := 0
        for t := 0; t < 10; t++ {

            for i := 0; i < 1000000000; i++ {
                s += i
            }
            fmt.Println(2, "->", s)
        }
        fmt.Println("end2", s)
    }()

    time.Sleep(time.Second * 10)
}

3.1. 在Go1.13 中的表现

用docker启动容器，用cat写入代码

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

docker run -it --rm golang:1.13 bash
root@c6921e499184:/go# cat<<EOF>a.go
> package main
>
> import (
>     "fmt"
>     "runtime"
>     "time"
> )
>
> func main() {
>
>     runtime.GOMAXPROCS(1)
>
>     go func() {
>         fmt.Println("begin1")
>         s := 0
>         for t := 0; t < 10000; t++ {
>
>             for i := 0; i < 1000000000; i++ {
>                 s += i
>             }
>             //fmt.Println(1, "->", s)
>         }
>         fmt.Println("end1", s)
>
>     }()
>
>     go func() {
>         fmt.Println("begin2")
>         s := 0
>         for t := 0; t < 10; t++ {
>
>             for i := 0; i < 1000000000; i++ {
>                 s += i
>             }
>             fmt.Println(2, "->", s)
>         }
>         fmt.Println("end2", s)
>     }()
>
>     time.Sleep(time.Second * 10)
> }
> EOF

然后运行

1

go run a.go

读者可以很容易地发现，这份代码只会输出一个begin1

3.2. 在Go1.14 中的表现

这次，进入docker的指令换成下面这条就行了

1

docker run -it --rm golang:1.14 bash

在1.14中，会输出如下内容

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

begin2
begin1
2 -> 499999999500000000
2 -> 999999999000000000
2 -> 1499999998500000000
2 -> 1999999998000000000
2 -> 2499999997500000000
2 -> 2999999997000000000
2 -> 3499999996500000000
2 -> 3999999996000000000
2 -> 4499999995500000000
2 -> 4999999995000000000
end2 4999999995000000000

由此可见，Go1.14解决了for循环长时间占用CPU的问题。

4. 如何主动释放CPU

要注意释放的时机，函数调用、for循环中都可以，但是要注意控制释放的频率，不能太频繁，也不能太不频繁。

1. 开始学习Go

从一本书开始，这本书叫做《Go语言从入门到进阶实战（视频教学版）》,当然这篇Blog并不是所有的内容都来自这本书，毕竟书中也有不足之处。

2. Hello World

学啥语言的第一步都是Hello World, 第一步是搭建开发环境，直接下载Goland，创建一个新的工程，点击create

建好项目以后，项目应该是下面这个样子的，当然我们不用关注这个go.mod是干什么的，我们只是利用IDE编写代码，使用命令行运行。

1
2
3
4
5
6

s@HELLOWANG-MB1 go-study % tree
.
`-- go.mod

0 directories, 1 file

然后新建一个main.go的文件，其内容如下

1
2
3
4
5

package main
import "fmt"
func main() {
    fmt.Println("hello world")
}

最后运行该文件

1
2

s@HELLOWANG-MB1 go-study % go run main.go
hello world

我们也可以编译为二进制文件，然后运行

1
2
3
4
5

s@HELLOWANG-MB1 go-study % go build main.go
s@HELLOWANG-MB1 go-study % ls
go.mod  main    main.go
s@HELLOWANG-MB1 go-study % ./main
hello world

3. Go的变量声明

变量的声明方式为var <变量名> <变量类型>

例如下面的程序

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
    var a int // 定义一个整形
    fmt.Println(a)
}

经过了命令行运行以后，可以转而使用IDE集成开发，点击按钮▶️

当然，还有更多的声明方式

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

package main

import "fmt"

func main() {
    var a int // 定义一个整形
    fmt.Println(a)

    var b int = 1 // 定义并赋值
    fmt.Println(b)

    var c = 2 // 编译器自动推导
    fmt.Println(c)

    d := 3 // 精简写法
    fmt.Println(d)
}

最后还有一个小技巧，即函数返回可以是多个变量，用逗号分隔, _表示匿名变量，即忽略该位置的值。

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

package main

import "fmt"

func main() {
    a := 1
    b := 2
    a, b = b, a
    c, _ := a, b
    _, d := a, b
    fmt.Println(a, b, c, d)
}

4. Go 的基础数据类型

4.1. 整形

有符号整型: int8 int16 int32 int64

无符号整型: uint8 uint16 uint32 uint64

平台自适应整形: int uint(自动根据平台决定整形的长度)

4.2. 浮点数

float32 float64

1
2
3
4
5
6
7
8
9
10

package main

import "fmt"

func main() {
    var a float32 = 1.5
    var b float64 = 1.5
    fmt.Println(a, b)
}

4.3. 布尔型

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
    var a bool = true
    fmt.Println(a)
}

4.4. 字符串

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
    var a string = "123"
    fmt.Println(a)
}

多行字符串

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

package main

import "fmt"

func main() {
    var a string = `  123你好
    abcsdaf
aslfnskflasjlfjoiwn
    `
    fmt.Println(a)
}

5. Go的控制流

5.1. 循环

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

package main

import "fmt"

func main() {

    // 类似与C的while
    a := 1
    for a <= 3 {
        fmt.Println(a)
        a++
    }

    // 类似与C的while(true)
    for {
        fmt.Println("break")
        break
    }

    // 类似于C的for
    for i := 0; i < 3; i++ {
        fmt.Println("hello")
    }

}

5.2. 条件判断

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

package main

import "fmt"

func main() {

    if 1+1 == 2 {
        fmt.Println("1+1=2")
    } else {
        fmt.Println("1+1!=2")
    }

}

5.3. switch

需要注意的是Go的switch自带break，下面的程序只会输出3

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

package main

import "fmt"

func main() {

    switch 3 {
    case 3:
        fmt.Println(3)
    case 2:
        fmt.Println(2)
    case 1:
        fmt.Println(1)
    }

}

6. Go的容器/集合

6.1. Map

注意map需要指定key和value 的类型

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

package main

import "fmt"

func main() {
    mp := make(map[string]int)
    mp["k1"] = 1
    mp["k2"] = 2
    fmt.Println(mp)

    delete(mp,"k1")
    fmt.Println(mp)
    
}

6.2. 数组

数组长度固定, 创建数组也有很多种写法

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

package main

import "fmt"

func main() {
    var arr1 []int = make([]int, 3)
    arr1[0] = 1

    arr2 := [3]int{1, 2}
    arr3 := [...]int{1, 2}

    fmt.Println(arr1, arr2, arr3)
}
// [1 0 0] [1 2 0] [1 2]

注意对于由字面量组成的数组，如果长度小于等于4，那么它将直接被分配到栈上，否则分配到静态区

6.3. 切片

切片的创建可以是数组的一部分，也可以直接创建，切片可扩容

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

package main

import "fmt"

func main() {
    var arr1 []int = make([]int, 3) // 数组

    slice1 := arr1[1:2]
    slice2 := []int{1, 2, 3}
    slice3 := make([]int, 3)

    fmt.Println(slice1, slice2, slice3)
}

// [0] [1 2 3] [0 0 0]

那么切片和数组有什么区别呢？其实切片只是数组的一个引用，任何一个切片，其背后一定有一个数组，当切片进行扩容的时候，会根据数组的剩余空间大小来决定附身到新的数组上，或者直接在原数组上扩容切片。

具体表现如下, 输出就在注释里面。

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

package main

import "fmt"

func main() {
    arr1 := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

    slice1 := arr1[2:5]
    slice2 := arr1[3:6]

    fmt.Println(slice1, slice2)
    arr1[4]=0
    fmt.Println(slice1, slice2)
}

// [2 3 4] [3 4 5]
// [2 3 0] [3 0 5]

6.3. 列表

列表可以自动伸缩

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

package main

import (
    "container/list"
    "fmt"
)

func main() {
    ls := list.New()
    ls.PushBack(1)
    ls.PushBack(2)
    fmt.Println(ls)
}

7. Go的函数

返回值写在参数后面

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

package main

import "fmt"

func plus(a int, b int) int {
    return a + b
}

func main() {
    a := 1
    b := 1
    fmt.Println(plus(a, b))
}

还可以选择返回多个值

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

package main

import "fmt"

func swap(a int, b int) (int, int) {
    return b, a
}

func main() {
    a := 1
    b := 2
    fmt.Println(swap(a, b))
}

变长的参数

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

package main

import "fmt"

func sum(a ...int) int {
    s := 0
    for i := 0; i < len(a); i++ {
        s += a[i]
    }
    return s
}

func main() {
    fmt.Println(sum(1, 2, 3))

    nums := []int{1, 2, 3, 4}
    fmt.Println(sum(nums...))
}

返回一个函数

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