好未来面经详解

昨天分享了腾讯大厂的后端面经，今天来分享互联网中厂的面经，面试难度也是介于小厂和大厂之间。

这次分享的是好未来的实习转正岗位面经，大家看看难度如何？考察的知识点：

• Go基础：slice，GMP模型，函数执行
• MySQL：引擎，聚簇索引，主从复制

面试题详解

详解slice

slice数据结构

array指针指向底层数组，len表示切片长度，cap表示底层数组容量

type slice struct {
 array unsafe.Pointer //切片底层数组的起始位置
 len int              //切片长度
 cap int     //切片容量
}

slice初始化的方法

1. 变量声明（与所有类型变量一样，变量声明后变量值为0，对于切片来讲，0值为nil）
2. 字面量（声明长度为0的切片时推荐使用变量声明的方式获得一个nil切片，因为nil切片不需要分配内存）
3. 内置函数make() （切片元素均初始化为相应类型的零值）
4. 适用于任意类型的内置函数new()（此时创建的切片值为nil）

var s []int//变量声明 nil切片，不需要分配内存
s1 := []int{}//长度为0的切片，空切片，指长度为空，其值并不是nil
s2 := []int{1,2,3}//长度为3的切片
fmt.Println(s)   //[]
fmt.Println(s1)  //[]
fmt.Println(s2)  //[1 2 3]
fmt.Println(s==nil) //true
fmt.Println(s1==nil) //false
 
s3 := make([]int, 12) //指定长度
s4 := make([]int, 10, 100) //推荐指定长度和预估空间，可以有效减小切片扩容时内存分配及拷贝次数
fmt.Println(s3)  //[0 0 0 0 0 0 0 0 0 0 0 0]
fmt.Println(s4)  //[0 0 0 0 0 0 0 0 0 0]
 
slice := *new([]int)
fmt.Println(slice)  //[]
fmt.Println(slice==nil) //true

slice切取

1. 切片可以基于数组和切片创建，切片与原数组或切片共享底层空间，修改切片会影响原数组或切片。
2. 切片表达式[low : high]表示的是左闭右开的区间，切取的长度为high-low。

array := [5]int{1,2,3,4,5}
s5 := array[0:2] //从数组中切取
s6 := s5[0:1]    //从切片中切取
fmt.Println(s5)  //[1 2]
fmt.Println(s6)  //[1]

slice的扩容机制

Go1.18之前切片的扩容是以容量1024为临界点，当旧容量 < 1024个元素,扩容变成2倍；当旧容量 > 1024个元素，那么会进入一个循环，每次增加25%直到大于期望容量。

Go1.18不再以1024为临界点，而是设定了一个值为256的threshold，以256为临界点； 超过256，不再是每次扩容1/4，而是每次增加（旧容量+3*256）/4；

• 当新切片需要的容量cap大于两倍扩容的容量，则直接按照新切片需要的容量扩容；
• 当原 slice 容量 < threshold 的时候，新 slice 容量变成原来的 2 倍；
• 当原 slice 容量 > threshold，进入一个循环，每次容量增加（旧容量+3*threshold）/4。

GMP模型

Golang的一大特色就是Goroutine。Goroutine是Golang支持高并发的重要保障。Golang可以创建成千上万个Goroutine来处理任务，将这些Goroutine分配、负载、调度到处理器上采用的是G-M-P模型。

什么是Goroutine

Goroutine = Golang + Coroutine。Goroutine是golang实现的协程，是用户级线程。Goroutine具有以下特点：

• 相比线程，其启动的代价很小，以很小栈空间启动（2Kb左右）
• 能够动态地伸缩栈的大小，最大可以支持到Gb级别
• 工作在用户态，切换成很小
• 与线程关系是n:m，即可以在n个系统线程上多工调度m个Goroutine

模型概览

G-M-P分别代表：

• G - Goroutine，Go协程，是参与调度与执行的最小单位
• M - Machine，指的是系统级线程
• P - Processor，指的是逻辑处理器，P关联了的本地可运行G的队列(也称为LRQ)，最多可存放256个G。

GMP调度流程大致如下

• 线程M想运行任务就需得获取 P，即与P关联。
• 然后从 P 的本地队列(LRQ)获取 G
• 若LRQ中没有可运行的G，M 会尝试从全局队列(GRQ)拿一批G放到P的本地队列，
• 若全局队列也未找到可运行的G时候，M会随机从其他 P 的本地队列偷一半放到自己 P 的本地队列。
• 拿到可运行的G之后，M 运行 G，G 执行之后，M 会从 P 获取下一个 G，不断重复下去。

调度的生命周期

• M0 是启动程序后的编号为 0 的主线程，这个 M 对应的实例会在全局变量 runtime.m0 中，不需要在 heap 上分配，M0 负责执行初始化操作和启动第一个 G， 在之后 M0 就和其他的 M 一样了
• G0 是每次启动一个 M 都会第一个创建的 gourtine，G0 仅用于负责调度的 G，G0 不指向任何可执行的函数，每个 M 都会有一个自己的 G0。在调度或系统调用时会使用 G0 的栈空间，全局变量的 G0 是 M0 的 G0

G-M-P的数量

G 的数量：

理论上没有数量上限限制的。查看当前G的数量可以使用runtime. NumGoroutine()

P 的数量：

由启动时环境变量 GOMAXPROCS 个 goroutine 在同时运行。

M 的数量:

go 语言本身的限制：go 程序启动时，会设置 M 的最大数量，默认 10000. 但是内核很难支持这么多的线程数，所以这个限制可以忽略。runtime/debug 中的 SetMaxThreads 函数，设置 M 的最大数量 一个 M 阻塞了，会创建新的 M。M 与 P 的数量没有绝对关系，一个 M 阻塞，P 就会去创建或者切换另一个 M，所以，即使 P 的默认数量是 1，也有可能会创建很多个 M 出来。

main函数结束，里面的go fun()会停止，还是继续运行

其实这个问题很简单，如果在mian中启动一个协程，如果main结束的时候，这个协程还有结束的话，系统也会强制关闭这个协程

最简单的例子如下：

func main() {
 go func() {
  time.Sleep(time.Second)
  fmt.Println("THIS IS KID")
 }()

 fmt.Println("THIS IS MAIN")
}

输出：
THIS IS MAIN

但是这里我想进行一个问题的深究：

假如你有一个非main的函数，里面也启动了一个协程，如果这个非main结束的话，里面的那个子协程会结束吗？

写代码验证一下：

func test() int {
 go func() { //子协程
  time.Sleep(time.Second*2)
  fmt.Println("非main函数的子协程结束")
 }()
 fmt.Println("非main函数结束")
 return 1
}
func main() {
 fmt.Println("非main函数返回值为", test())
 time.Sleep(time.Second*5)
 fmt.Println("main函数结束")
}

输出：
非main函数结束
非main函数返回值为 1
非main函数的子协程结束
main函数结束

由此可以得出结论：非main函数退出后，其子协程是不会退出的。

所以这里的重点就是：主main退出，全部的协程才都会退出。

MySQL引擎

MySQL中常用的四种存储引擎分别是：MyISAM、InnoDB、MEMORY、ARCHIVE。MySQL 5.5版本后默认的存储引擎为InnoDB。

1、InnoDB存储引擎

InnoDB是MySQL默认的事务型存储引擎，使用最广泛，基于聚簇索引建立的。InnoDB内部做了很多优化，如能够自动在内存中创建自适应hash索引，以加速读操作。

优点：支持事务和崩溃修复能力；引入了行级锁和外键约束。

缺点：占用的数据空间相对较大。

适用场景：需要事务支持，并且有较高的并发读写频率。

2、MyISAM存储引擎

数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，可以使用MyISAM引擎。MyISAM会将表存储在两个文件中，数据文件.MYD和索引文件.MYI。

优点：访问速度快。

缺点：MyISAM不支持事务和行级锁，不支持崩溃后的安全恢复，也不支持外键。

适用场景：对事务完整性没有要求；表的数据都会只读的。

3、MEMORY存储引擎

MEMORY引擎将数据全部放在内存中，访问速度较快，但是一旦系统奔溃的话，数据都会丢失。

MEMORY引擎默认使用哈希索引，将键的哈希值和指向数据行的指针保存在哈希索引中。

优点：访问速度较快。

缺点：

• 哈希索引数据不是按照索引值顺序存储，无法用于排序。
• 不支持部分索引匹配查找，因为哈希索引是使用索引列的全部内容来计算哈希值的。
• 只支持等值比较，不支持范围查询。
• 当出现哈希冲突时，存储引擎需要遍历链表中所有的行指针，逐行进行比较，直到找到符合条件的行。

4、ARCHIVE存储引擎

ARCHIVE存储引擎非常适合存储大量独立的、作为历史记录的数据。ARCHIVE提供了压缩功能，拥有高效的插入速度，但是这种引擎不支持索引，所以查询性能较差。

聚簇索引

数据库的索引从不同的角度可以划分成不同的类型，聚簇索引便是其中一种。

聚簇索引英文是 Clustered Index，有时候小伙伴们可能也会看到有人将之称为聚集索引等，与之相对的是非聚簇索引或者二级索引。

聚簇索引并不是一种单独的索引类型，而是一种数据的存储方式。在 MySQL 的 InnoDB 存储引擎中，所谓的聚簇索引实际上就是在同一个 B+Tree 中保存了索引和数据行：此时，数据放在叶子结点中，聚簇聚簇，意思就是说数据行和对应的键值紧凑的存在一起。

假如我有以下数据：

那么它的聚簇索引大概就是这个样子：

那么大家可以看到，叶子上既有主键值（索引）又有数据行，节点上则只有主键值（索引）。

小伙伴们想想，MySQL 表中的数据在磁盘中只可能保存一份，不可能保存两份，所以，在一个表中，聚簇索引只可能有一个，不可能有多个。

聚簇索引优缺点

优点：

• 相互关联的数据我们可以将之保存在一起。例如有一个用户订单表，我们可以根据 用户 ID + 订单 ID 来聚集所有数据，用户 ID 可能会重复，订单 ID 则不会重复，这样我们就能够将一个用户相关的订单数据都保存在一起，如果需要查询一个用户的所有订单，就会非常快，只需要少量的磁盘 IO 就可以做到。
• 不需要回表，因此数据访问速度更快。在聚簇索引中，索引和数据都在同一棵 B+Tree 上，因此从聚簇索引中获取到的数据比从非聚簇索引上获取数据更快（非聚簇索引需要回表）。
• 对于第一点的案例，如果我们想根据用户 ID 查询到这个用户所有的订单 ID，那么此时都不用去到叶子结点了，因为支节点上就有我们需要的数据，所以直接利用覆盖索引的特性，就可以读取到需要的数据。

缺点：

• 聚簇索引的优势主要是聚簇索引减少了 IO 次数，从而提高了数据库的性能，但是有的 IO 密集型应用，可能直接上一个足够大的内存，把数据都读取到内存中操作，此时聚簇索引就没有啥优势了。
• 随机主键会导致页分裂问题，主键顺序插入的话，相对来说效率会高一些，因为在 B+Tree 中只需要不断往后面追加即可；但是主键如果是非顺序插入的话，效率就会低很多，因为可能会涉及到页分裂问题。以上面那张图为例，假设每个节点可以保存三条数据，现在我们要插入一个主键是 4.5 的记录，那么就需要把主键为 5 的值往后移动，进而导致主键为 8 的节点也要往后移动。页分裂会导致数据插入效率降低并且占用更多的存储空间。
• 非聚簇索引（二级索引）查询的时候需要回表。因为一个索引就是一棵索引树，数据都在聚簇索引上，所以如果使用非聚簇索引进行搜索，非聚簇索引的叶子上存储的是主键值，先找到主键值，然后拿着主键值再来聚簇索引上搜索，这样一共就查询了两棵索引树，这就是回表。

数据库主从复制

MySQL 主从复制是指数据可以从一个MySQL数据库服务器主节点复制到一个或多个从节点。MySQL 默认采用异步复制方式，这样从节点不用一直访问主服务器来更新自己的数据，数据的更新可以在远程连接上进行，从节点可以复制主数据库中的所有数据库或者特定的数据库，或者特定的表。

为什么需要主从复制？

1. 在业务复杂的系统中，有这么一个情景，有一句sql语句需要锁表，导致暂时不能使用读的服务，那么就很影响运行中的业务，使用主从复制，让主库负责写，从库负责读，这样，即使主库出现了锁表的情景，通过读从库也可以保证业务的正常运作。
2. 做数据的热备
3. 架构的扩展。业务量越来越大，I/O访问频率过高，单机无法满足，此时做多库的存储，降低磁盘I/O访问的频率，提高单个机器的I/O性能。

复制原理

原理：

（1）master服务器将数据的改变记录二进制binlog日志，当master上的数据发生改变时，则将其改变写入二进制日志中；

（2）slave服务器会在一定时间间隔内对master二进制日志进行探测其是否发生改变，如果发生改变，则开始一个I/OThread请求master二进制事件

（3）同时主节点为每个I/O线程启动一个dump线程，用于向其发送二进制事件，并保存至从节点本地的中继日志中，从节点将启动SQL线程从中继日志中读取二进制日志，在本地重放，使得其数据和主节点的保持一致，最后I/OThread和SQLThread将进入睡眠状态，等待下一次被唤醒。

也就是说：

从库会生成两个线程,一个I/O线程,一个SQL线程; I/O线程会去请求主库的binlog,并将得到的binlog写到本地的relay-log(中继日志)文件中;

主库会生成一个log dump线程,用来给从库I/O线程传binlog;

SQL线程,会读取relay log文件中的日志,并解析成sql语句逐一执行;

注意：

1--master将操作语句记录到binlog日志中，然后授予slave远程连接的权限（master一定要开启binlog二进制日志功能；通常为了数据安全考虑，slave也开启binlog功能）。

2--slave开启两个线程：IO线程和SQL线程。其中：IO线程负责读取master的binlog内容到中继日志relay log里；SQL线程负责从relay log日志里读出binlog内容，并更新到slave的数据库里，这样就能保证slave数据和master数据保持一致了。

3--Mysql复制至少需要两个Mysql的服务，当然Mysql服务可以分布在不同的服务器上，也可以在一台服务器上启动多个服务。

4--Mysql复制最好确保master和slave服务器上的Mysql版本相同（如果不能满足版本一致，那么要保证master主节点的版本低于slave从节点的版本）

5--master和slave两节点间时间需同步

如何确保数据一致

1. 确保同步状态正常

主从数据库的同步状态正常是保证主从数据一致性的前提，需要定期监控主从同步状态，并及时处理同步异常情况。

2. 配置和参数设置保持一致

主从数据库的配置和参数设置必须一致，否则可能导致主从数据不一致问题。可以通过检查my.cnf文件、SHOW VARIABLES命令等方式来确认配置和参数是否一致。

3. 定期备份和比对数据

定期备份主从数据库数据，并进行比对，查看是否有差异。可以使用mysqldump工具或者其他自动化备份工具进行备份，并使用比对工具进行数据检查。

4. 选择合适的数据同步方式

使用适当的数据同步方式能够更好地保证主从数据的一致性。例如，使用基于GTID或binlog格式的数据同步方式，可确保主从数据的同步流程更为精确和可靠。

早日上岸！

我们搞了一个免费的面试真题共享群，互通有无，一起刷题进步。

没准能让你能刷到自己意向公司的最新面试题呢。

感兴趣的朋友们可以加我微信：wangzhongyang1993，备注：面试群。

点击下方文章，看看他们是怎么找到好工作的！

还有最新鲜的腾讯面经，不要错过哦！