第一期学习总结

傷城~ 2022-05-03 14:57 273阅读 0赞

在工作的过程中，不断听到新名词，新概念，新方法。觉得是时候总结一波知识点记录下来，促进深入了解的同时，便于以后复习。非常喜欢阮老师的每周分享，但是做不到像他一样每周去浏览那么多东西，而且总能发现很有趣的知识点。现在期望可以做到双月一总结，有些知识点可能还是没有那么深入理解，希望能坚持下来，在工作的同时慢慢进步，也是相当不错了。原本于国庆前就有此计划，并写好了初稿，中间各种原因，又推迟了一个月。= =

# 1、什么是kafka rebalance？ #

在Consumer Group中的若干Consumer，会按照一定规则（均匀）分配同一个topic下的所有partition，各自在相应partition上执行sub工作。当一个Group中有Consumer退出时，Group中的其他Consumer会对topic下的partition进行重新分配，并基于重新分配的结果继续执行sub工作。这个重新分配的过程被称为Rebalance。

分配算法如下：

1. 将目标 topic 下的所有 partirtion 排序，存于PT
    2. 对某 consumer group 下所有 consumer 排序，存于 CG，第 i 个consumer 记为 Ci
    3. N=size(PT)/size(CG)，向上取整
    4. 解除 Ci 对原来分配的 partition 的消费权（i从0开始）
    5. 将第i*N到（i+1）*N-1个 partition 分配给 Ci

参考文档：

（1）如何利用磁盘顺序读写快于内存随机读写这一现象？

[https://www.zhihu.com/question/48794778][https_www.zhihu.com_question_48794778]

（2）kafka之Group状态变化分析及Rebalance过程

[http://matt33.com/2017/01/16/kafka-group/][http_matt33.com_2017_01_16_kafka-group]

（3）Kafka Consumer Rebalance的演进

[http://lday.me/2017/07/24/0011\_kafka\_consumer\_rebalance\_evolution/][http_lday.me_2017_07_24_0011_kafka_consumer_rebalance_evolution]

# 2、Mock功能 #

经常听到在测试的时候说mock一下，什么是mock？目前一个产品开发都是分前后端，并行开发的时候有可能后端先做完了，然而前端还没有做完，联调前需要自己做测试。有些接口无法得到响应回来的数据，功能没法测怎么办？所谓的mock就是指根据事先定义好的接口信息如协议、URL、接口名、请求头、请求参数、返回数据等对接口自动生成模拟数据。创建者可以自由构造需要的数据进行测试。

**一句话总结：mock（模拟）是在项目测试中，对项目外部或不容易获取的对象/接口，用一个虚拟的对象/接口来模拟，以便测试。**

参考文档：

（1）为什么你需要一个mock server

[https://juejin.im/entry/57bd37c2c4c9710061606b38][https_juejin.im_entry_57bd37c2c4c9710061606b38]

#  #

# 3、JSON Schema #

JSON Schema（JSON模式），是一种基于JSON格式定义JSON数据结构的规范。目的：

（1）描述现有数据格式

（2）干净的人类和机器可读的文档

（3）完整的结构验证，有利于自动化测试，可用于验证客户端提交的数据

举个栗子：

我们现在有JSON数据（1），现在需要用JSON数据（2）来描述（1）的结构。这时的JSON数据（2）就是JSON数据（1）的JSON Schema，用来描述并且验证JSON数据（1）

JSON数据（1）：

{
        "name": "sunwukong",
        "age": 24,
        "gender": "male"
    }

JSON数据（2）：

{
        "type": "object",
        "properties": {
            "name": {
                "type": "string",
                "minLength": 4
            },
            "age": {
                "type": "integer",
                "minimum": 0,
                "maximum": 130
            },
            "gender": {
                "type": "string",
                "enum": [
                    "male",
                    "female"
                ]
            }
        }
    }

由JSON数据（2）我们可以知道JSON数据（1）：

*  是一个json对象，有三个属性：name、age和gender
 *  name属性的值类型是一个字符串，最小长度4
 *  age属性的值类型是一个整形，最小值是0，最大值是130
 *  gender属性的值类型是一个字符串，只能取"male"或者"female"

参考文档：

（1）JSON Schema参考书

[http://imweb.io/topic/57b5f69373ac222929653f23][http_imweb.io_topic_57b5f69373ac222929653f23]

（2）JSON Schema快速入门

[https://www.jianshu.com/p/8278eb2458c4][https_www.jianshu.com_p_8278eb2458c4]

#  #

# 4、传值还是传指针？ #

在实际开发中，前人写的函数传入的都是指针，特别是在struct中喜欢用指针。一直不理解为什么，直到要自己去定义一些变量和结构时，觉得是时候深入理解一下。

两篇参考文档已经写的非常详细了。总结一下：Go里面所有传参都是传值，都是一个副本，一个拷贝。如果传入的是一个值，那么就是传入了值的拷贝，如果传入的是一个指针，那么就是传入了指针的拷贝。因为拷贝的内容有时候是非引用类型（int、string、struct等这些），这样就在函数中无法修改原内容数据。有的是引用类型（指针、map、slice、chan等这些），这样就可以修改原内容数据。

是否可以修改原内容数据，和传值、传引用没有必然的关系。在c++中，传引用肯定是可以修改原内容数据的，在Go语言里，虽然只有传值，但是我们也可以修改原内容数据，因为参数是引用类型。注意：引用类型和传引用是两个概念。Go里只有传值（值传递）

参考文档：

（1）全面分析Go语言中的类型和类型指针的抉择

[https://colobu.com/2017/01/05/-T-or-T-it-s-a-question/][https_colobu.com_2017_01_05_-T-or-T-it-s-a-question]

（2）Go语言参数传递是传值还是传引用

[http://www.flysnow.org/2018/02/24/golang-function-parameters-passed-by-value.html][http_www.flysnow.org_2018_02_24_golang-function-parameters-passed-by-value.html]

# 5、golang的内存分配 #

关于栈区和堆区的区别，以c++为例一般认为

栈区：由编译器自动分配释放，存放函数的参数值，局部变量的值等。

堆区：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。比如new，malloc等申请的内存就在堆区。

在栈区分配的代价要远小于在堆上进行分配。因为有垃圾回收机制。所以要避免内存逃逸。

内存逃逸：原本在栈上分配内存的对象，逃逸到了堆上进行分配。如果无法在编译期确定变量的作用域和占用内存大小，则会逃逸到堆上。

**（1）指针**

在函数传参时，一般都认为传递指针可以减少底层值的拷贝，提高效率。一般情况下亦是如此，但是如果拷贝的是少量的数据，那么传递指针效率不一定会高于值拷贝。指针是间接访址，所指向的地址大多保存在堆上，因此考虑到GC，指针不一定是高效的。

**（2）切片**

如果编译期无法确定切片的大小或者切片大小过大，超出栈大小限制，或者在append时候会导致重新分配内存，这时候很可能会分配到堆上。

**（3）interface**

参考文档

（1）深入理解GO语言之内存详解

[https://juejin.im/post/59f2e19f5188253d6816d504][https_juejin.im_post_59f2e19f5188253d6816d504]

# 6、GC机制 #

GC是指垃圾回收。有三种经典的GC算法：引用计数（reference counting）、标记-清扫（mark & sweep）、节点复制（Copying Garbage Collection），分代收集（Generational Garbage Collection）。文档（2）中有每一步的图文解说。

参考文档：

（1）Golang垃圾回收剖析

[http://legendtkl.com/2017/04/28/golang-gc/][http_legendtkl.com_2017_04_28_golang-gc]

（2）Go语言的实时GC-理论与实践

[https://segmentfault.com/a/1190000010753702][https_segmentfault.com_a_1190000010753702]

# 7、innodb类的数据库的删除是软删除 #

就是说会有一个标志位表示当前数据已被删除，但是不会真的删除。这样数据只会越来越多，所以最好的做法是更新，而不是删除。

# 8、MYSQL prepare预编译 #

prepare语法：

MySQL prepare语法：
    PREPARE statement_name FROM preparable_SQL_statement;  /*定义*/
    EXECUTE statement_name [USING @var_name...];   /*执行预处理语句*/
    {DEALLOCATE | DROP} PREPARE statement_name;  /*删除定义*/

PREPARE语句用于预备一个语句，并指定名称statement\_name，以后引用该语句。语句名称对大小写不敏感。

例子：

select * from t_test where id=1 or 1=1;

-- 正常查询
    prepare sel from 'select * from t_test where value = ?';
    set @v1='abc';
    execute sel using @v1;
    -- 注入
    set @v1='abc' or 1=1;
    execute sel using @v1;
    -- 后台查询查询语句变成 select * from t_test where value = 1

通常情况下，一条sql语句在db接收到最终执行完毕返回可以分为三步：

（1）语法和语义解析

（2）优化sql语句，制定执行计划

（3）执行并返回结果

有时候，一条sql需要反复执行，或者只是个别的值不同（比如update的set子句值不同）。如果每次都需要经过上面的语法语义解析、语句优化、制定执行计划等。则效率就明显不同了。

所谓预编译语句是指将这类语句中的值用占位符替代，可以视为将sql语句模板化或者说参数化，一般称这类语句叫Prepared Statements或者Parameterized Statements。

预编译语句优点：一次编译、多次运行、省去了解析优化等过程，此外预编译语句能防止sql注入。

参考文档：

（1）预编译语句（Prepared Statements）介绍，以MySQL为例

[https://www.cnblogs.com/micrari/p/7112781.html][https_www.cnblogs.com_micrari_p_7112781.html]

（2）mysql预编译-Prepared-Statements

[http://yihengliu.com/2018/06/04/mysql%E9%A2%84%E7%BC%96%E8%AF%91-Prepared-Statements/][http_yihengliu.com_2018_06_04_mysql_E9_A2_84_E7_BC_96_E8_AF_91-Prepared-Statements]

# 9、slice和数组（Array）的区别 #

例子：

a := []int{1}  //[]中没有固定长度的就是slice
    b := [2]int{1, 2} //固定了长度的是数组array

Array是值类型，固定长度，大小是类型的一部分，当一个数组变量被赋值或者被传递的时候，实际上会复制整个数组。而Slice在新元素加入的时候可以增加长度（增长到容量的上限）。array的长度也是Type的一部分，这样就说明\[10\]int和\[20\]int是不一样的。

Slice一个切片是一个数组片段的描述。它包含了指向数组的指针，片段的长度和容量（底层数组的长度）。slice是一个引用类型，是一个动态的指向数组切片的指针，是一个不定长的，总是指向底层的数组array的数据结构。

参考文档：

（1）golang slice和array区别

[https://segmentfault.com/a/1190000013148775][https_segmentfault.com_a_1190000013148775]

# 10、pb数据格式 #

pb（Protocol Buffers）是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。很适合做数据存储或RPC数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。

pb提供了一种灵活，高效，自动序列化结构数据的机制，可以联想XML，但是比XML更小，更快，更简单。仅需要自定义一次你所需的数据格式，然后用户就可以使用Protocol Buffers自动生成的特定的源码，方便的读写用户自定义的格式化的数据。不限语言，不限平台。还可以在不破坏元数据格式的基础上，依据老的数据格式，更新现有的数据格式。

# 11、GO语言中for循环里的变量地址复用 #

for \_, op := range ops中op的地址是复用的

例子：

package main
    
    import(
       "fmt"
    )
    
    type data struct{
       age int
       name string
    }
    
    func main() {
       testStrs := []string{"hello", "world", "yes", "no"}
    
       for index, s := range testStrs{
          fmt.Println("index:", index)
          fmt.Println("打印s的地址", &s)
          fmt.Println("s的值", s)
       }
    
       for i:=0;i<len(testStrs);i++{
          fmt.Println("i:", i)
          fmt.Println("打印testStrs[i]的地址:", &testStrs[i])
          fmt.Println("testStrs[i]的值:", testStrs[i])
       }
    
    }

打印结果：

index: 0
    打印s的地址 0xc42000e1e0
    s的值 hello
    index: 1
    打印s的地址 0xc42000e1e0
    s的值 world
    index: 2
    打印s的地址 0xc42000e1e0
    s的值 yes
    index: 3
    打印s的地址 0xc42000e1e0
    s的值 no
    i: 0
    打印testStrs[i]的地址: 0xc4200560c0
    testStrs[i]的值: hello
    i: 1
    打印testStrs[i]的地址: 0xc4200560d0
    testStrs[i]的值: world
    i: 2
    打印testStrs[i]的地址: 0xc4200560e0
    testStrs[i]的值: yes
    i: 3
    打印testStrs[i]的地址: 0xc4200560f0
    testStrs[i]的值: no

# 12、Go语言中多个Recover存在时会怎么样？ #

例子：

package main
    
    import(
       "fmt"
    )
    
    func main(){
       defer func(){
          //第一层defer
          fmt.Println("进入第一层defer")
    
          if err := recover(); err != nil {
             fmt.Println("进入第一层的recover逻辑中")
             fmt.Printf("%s\n", err)
          }
       }()
    
       a := 1
       b := 2
    
       defer func(){
          //第二层defer
          fmt.Println("进入第二层defer")
    
          if err := recover(); err != nil {
             fmt.Println("进入第二层的recover逻辑中")
             fmt.Printf("%s\n", err)
          }
       }()
    
       fmt.Println(a, b)
       panic("出错啦")
    }

打印结果：

1 2
    进入第二层defer
    进入第二层的recover逻辑中
    出错啦
    进入第一层defer

[https_www.zhihu.com_question_48794778]: https://www.zhihu.com/question/48794778
[http_matt33.com_2017_01_16_kafka-group]: http://matt33.com/2017/01/16/kafka-group/
[http_lday.me_2017_07_24_0011_kafka_consumer_rebalance_evolution]: http://lday.me/2017/07/24/0011_kafka_consumer_rebalance_evolution/
[https_juejin.im_entry_57bd37c2c4c9710061606b38]: https://juejin.im/entry/57bd37c2c4c9710061606b38
[http_imweb.io_topic_57b5f69373ac222929653f23]: http://imweb.io/topic/57b5f69373ac222929653f23
[https_www.jianshu.com_p_8278eb2458c4]: https://www.jianshu.com/p/8278eb2458c4
[https_colobu.com_2017_01_05_-T-or-T-it-s-a-question]: https://colobu.com/2017/01/05/-T-or-T-it-s-a-question/
[http_www.flysnow.org_2018_02_24_golang-function-parameters-passed-by-value.html]: http://www.flysnow.org/2018/02/24/golang-function-parameters-passed-by-value.html
[https_juejin.im_post_59f2e19f5188253d6816d504]: https://juejin.im/post/59f2e19f5188253d6816d504
[http_legendtkl.com_2017_04_28_golang-gc]: http://legendtkl.com/2017/04/28/golang-gc/
[https_segmentfault.com_a_1190000010753702]: https://segmentfault.com/a/1190000010753702
[https_www.cnblogs.com_micrari_p_7112781.html]: https://www.cnblogs.com/micrari/p/7112781.html
[http_yihengliu.com_2018_06_04_mysql_E9_A2_84_E7_BC_96_E8_AF_91-Prepared-Statements]: http://yihengliu.com/2018/06/04/mysql%E9%A2%84%E7%BC%96%E8%AF%91-Prepared-Statements/
[https_segmentfault.com_a_1190000013148775]: https://segmentfault.com/a/1190000013148775