Golang 面试题整理

Golang 基础

golang中常量是怎么实现的

从汇编中看是对字符串常量加了一个标号,同时设置为SRODATA,也就是只读,对数字常量直接在代码中作为立即数使用了

协程,线程,进程的区别。

  • 进程

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间,不同进程通过进程间通信来通信。由于进程比较重量,占据独立的内存,所以上下文进程间的切换开销(栈、寄存器、虚拟内存、文件句柄等)比较大,但相对比较稳定安全。

  • 线程

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。线程间通信主要通过共享内存,上下文切换很快,资源开销较少,但相比进程不够稳定容易丢失数据。

  • 协程

协程是一种用户态的轻量级线程,协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈,直接操作栈则基本没有内核切换的开销,可以不加锁的访问全局变量,所以上下文的切换非常快。

golang的make和new的区别是什么

new有点像c++里面的new,用来初始化各种type,然后返回其指针。 只不过由于没有构造函数的存在,所以全部用零值来填充,比较特殊的是slice,map,channel, 它们的零值都是nil。另外由于golang直接可以用&struct{} 形式来初始化,所以平时用到new的机会也比较少。
make是用来初始化map,slice,以及channel的,并且可以指定初始长度, 它返回的不是指针,而是对象本身,并且初始化,并不是像new单纯的置0。另外,make出来的map,slice,channel都是可以直接使用的。

golang 的channel是怎么实现的

golang的channel是个结构体,里面大概包含了三大部分:
a. 指向内容的环形缓存区,及其相关游标
b. 读取和写入的排队goroutine队列
c. 锁
任何操作前都需要获得锁, 当写满或者读空的时候,就将当前goroutine加入到recvq或者sendq中, 并出让cpu(gopark)。

Golang syncmap实现原理

  • 通过 read 和 dirty 两个字段将读写分离,读的数据存在只读字段 read 上,将最新写入的数据则存在 dirty 字段上
  • 读取时会先查询 read,不存在再查询 dirty,写入时则只写入 dirty
  • 读取 read 并不需要加锁,而读或写 dirty 都需要加锁
  • 另外有 misses 字段来统计 read 被穿透的次数(被穿透指需要读 dirty 的情况),超过一定次数则将 dirty 数据同步到 read 上
  • 对于删除数据则直接通过标记来延迟删除

一些观点,当有大量并发读写发生的时候,会有很多的miss导致不断的dirty升级。可能会影响效率

Golang 引用类型

  • golang 有三种引用类型 slice、map、channel
  • Go 中函数传参仅有值传递一种方式;
  • slice能够通过函数传参后,修改对应的数组值,是因为 slice 内部保存了引用数组的指针,并不是因为引用传递。
  • 当对slice 进行 append 操作,当slice 发生扩容的时候,将不会对被引用的变量造成影响

Golang slice 扩容规则

  • 如果切片的容量小于1024个元素,那么扩容的时候slice的cap就翻番,乘以2;一旦元素个数超过1024个元素,增长因子就变成1.25,即每次增加原来容量的四分之一。
  • 如果扩容之后,还没有触及原数组的容量,那么,切片中的指针指向的位置,就还是原数组,如果扩容之后,超过了原数组的容量,那么,Go就会开辟一块新的内存,把原来的值拷贝过来,这种情况丝毫不会影响到原数组。

golang defer 修改返回值

defer 按照定义相反顺序执行,发生在return执行之后,内容返回之前。

考虑defer对返回值修改的影响,需要考虑两种情况:

  1. 当生命了返回函数的名称的函数,返回值变量会再函数开始的时候自动生命,defer可以在函数真正返回之前,对返回值进行修改;
  2. 匿名返回值则相当于,对return的值自动生成了一个变量来存储,defer对返回值的修改不会真正的改变返回值。

uniptr 和 unsafe.pointer 区别

  • unsafe.Pointer只是单纯的通用指针类型,用于转换不同类型指针,它不可以参与指针运算;
  • 而uintptr是用于指针运算的,GC 不把 uintptr 当指针,也就是说 uintptr 无法持有对象, uintptr 类型的目标会被回收;
  • unsafe.Pointer 可以和 普通指针 进行相互转换;
  • unsafe.Pointer 可以和 uintptr 进行相互转换。

context包的用途

Context通常被译作上下文,它是一个比较抽象的概念,其本质,是【上下上下】存在上下层的传递,上会把内容传递给下。在Go语言中,程序单元也就指的是Goroutine

range 数组和切片

在range开始迭代时就浅拷贝了一个副本,对数组来说,相当于拷贝了一个新的数组进行迭代,修改原数组不会影响被迭代数组。而对于切片来说,range拷贝出来的切片与原切片底层是同一个数组,因此对原切片的修改也会影响到被迭代切片

动态遍历

1
2
3
4
5
6
func main() {
v := []int{1, 2, 3}
for i:= range v {
v = append(v, i)
}
}

能够正常结束。循环内改变切片的长度,不影响循环次数,循环次效在循环开始前就已经确定了。

Go中Map的实现原理

什么是Map

key,value存储

最通俗的话说Map是一种通过key来获取value的一个数据结构,其底层存储方式为数组,在存储时key不能重复,当key重复时,value进行覆盖,我们通过key进行hash运算(可以简单理解为把key转化为一个整形数字)然后对数组的长度取余,得到key存储在数组的哪个下标位置,最后将key和value组装为一个结构体,放入数组下标处,看下图:

1
2
3
4
5
length = len(array) = 4
hashkey1 = hash(xiaoming) = 4
index1 = hashkey1% length= 0
hashkey2 = hash(xiaoli) = 6
index2 = hashkey2% length= 2

1592037746323

hash冲突

如上图所示,数组一个下标处只能存储一个元素,也就是说一个数组下标只能存储一对key,value, hashkey(xiaoming)=4占用了下标0的位置,假设我们遇到另一个key,hashkey(xiaowang)也是4,这就是hash冲突(不同的key经过hash之后得到的值一样),那么key=xiaowang的怎么存储?

hash冲突的常见解决方法

开放定址法

也就是说当我们存储一个key,value时,发现hashkey(key)的下标已经被别key占用,那我们在这个数组中空间中重新找一个没被占用的存储这个冲突的key,那么没被占用的有很多,找哪个好呢?常见的有线性探测法,线性补偿探测法,随机探测法,这里我们主要说一下线性探测法

  • 线性探测

    字面意思就是按照顺序来,从冲突的下标处开始往后探测,到达数组末尾时,从数组开始处探测,直到找到一个空位置存储这个key,当数组都找不到的情况下回扩容(事实上当数组容量快满的时候就会扩容了);查找某一个key的时候,找到key对应的下标,比较key是否相等,如果相等直接取出来,否则按照顺寻探测直到碰到一个空位置,说明key不存在。如下图:

1592037761105

​ 首先存储key=xiaoming在下标0处,当存储key=xiaowang时,hash冲突了,按照线性探测,存储在下标1处,(红色的线是冲突或者下标已经被占用 了) 再者key=xiaozhao存储在下标4处,当存储key=xiaoliu是,hash冲突了,按照线性探测,从头开始,存储在下标2处 (黄色的是冲突或者下标已经被占用了)

  • 拉链法

    何为拉链,简单理解为链表,当key的hash冲突时,我们在冲突位置的元素上形成一个链表,通过指针互连接,当查找时,发现key冲突,顺着链表一直往下找,直到链表的尾节点,找不到则返回空,如下图:

    1592037774396

开放定址(线性探测)和拉链的优缺点

  1. 由上面可以看出拉链法比线性探测处理简单
  2. 线性探测查找是会被拉链法会更消耗时间
  3. 线性探测会更加容易导致扩容,而拉链不会
  4. 拉链存储了指针,所以空间上会比线性探测占用多一点
  5. 拉链是动态申请存储空间的,所以更适合链长不确定的

Go中的map实现原理

map的源码位于 src/runtime/map.go中 笔者go的版本是1.12

在go中,map同样也是数组存储的,每个数组下标处存储的是一个bucket,这个bucket的类型见下面代码,每个bucket中可以存储8个kv键值对.。

当每个bucket存储的kv对到达8个之后,会通过overflow指针指向一个新的bucket,从而形成一个链表,看bmap的结构。

我想大家应该很纳闷,没看见kv的结构和overflow指针啊,事实上,这两个结构体并没有显示定义,是通过指针运算进行访问的

1
2
3
4
5
//bucket结构体定义 b就是bucket
type bmap{
//bucketCnt 的初始值是8
tophash [bucketCnt]uint8
}

看上面代码以及注释,我们能得到bucket中存储的kv是这样的,tophash用来快速查找key值是否在该bucket中,而不同每次都通过真值进行比较;

还有kv的存放,为什么不是k1v1,k2v2….. 而是k1k2…v1v2…,我们看上面的注释说的 map[int64]int8,key是int64(8个字节),value是int8(一个字节),kv的长度不同,如果按照kv格式存放,则考虑内存对齐v也会占用int64,而按照后者存储时,8个v刚好占用一个int64,从这个就可以看出go的map设计之巧妙。

1592037797275

最后我们分析一下go的整体内存结构,阅读一下map存储的源码,如下图所示,当往map中存储一个kv对时,通过k获取hash值,hash值的低八位和bucket数组长度取余,定位到在数组中的那个下标,hash值的高八位存储在bucket中的tophash中,用来快速判断key是否存在,key和value的具体值则通过指针运算存储,当一个bucket满时,通过overfolw指针链接到下一个bucket。

1592037810278

###

调度模型

GPM调度模型简介

groutine是通过GPM调度模型实现,下面就来解释下goroutine的调度模型。

1546663603111

Go的调度器内部有四个重要的结构:M,P,S,Sched,如上图所示(Sched未给出)
M:M代表内核级线程,一个M就是一个线程,goroutine就是跑在M之上的;M是一个很大的结构,里面维护小对象内存cache(mcache)、当前执行的goroutine、随机数发生器等等非常多的信息
G:代表一个goroutine,它有自己的栈,instruction pointer和其他信息(正在等待的channel等等),用于调度。
P:P全称是Processor,处理器,它的主要用途就是用来执行goroutine的,所以它也维护了一个goroutine队列,里面存储了所有需要它来执行的goroutine
Sched:代表调度器,它维护有存储M和G的队列以及调度器的一些状态信息等。

调度实现

1546663612721

从上图中看,有2个物理线程M,每一个M都拥有一个处理器P,每一个也都有一个正在运行的goroutine。
P的数量可以通过GOMAXPROCS()来设置,它其实也就代表了真正的并发度,即有多少个goroutine可以同时运行。
图中灰色的那些goroutine并没有运行,而是出于ready的就绪态,正在等待被调度。P维护着这个队列(称之为runqueue),
Go语言里,启动一个goroutine很容易:go function 就行,所以每有一个go语句被执行,runqueue队列就在其末尾加入一个goroutine,在下一个调度点,就从runqueue中取出

当一个OS线程M0陷入阻塞时(例如爬虫或者其他的io操作, 这里就和python的多线程类似)(如下图),P转而在运行M1,图中的M1可能是正被创建,或者从线程缓存中取出。

1546663635363

当MO返回时,它必须尝试取得一个P来运行goroutine,一般情况下,它会从其他的OS线程那里拿一个P过来,
如果没有拿到的话,它就把goroutine放在一个global runqueue里,然后自己睡眠(放入线程缓存里)。所有的P也会周期性的检查global runqueue并运行其中的goroutine,否则global runqueue上的goroutine永远无法执行。

另一种情况是P所分配的任务G很快就执行完了(分配不均),这就导致了这个处理器P很忙,但是其他的P还有任务,此时如果global runqueue没有任务G了,那么P不得不从其他的P里拿一些G来执行。一般来说,如果P从其他的P那里要拿任务的话,一般就拿runqueue的一半,这就确保了每个OS线程都能充分的使用,如下图:

1546663659450

golang 的GC算法

golang 采用的是三色标记法

标记-清除算法:

对象只有黑白两色

  1. stop the world,即停止所有goroutine
  2. 从根对象(全局指针和栈上的对象)出发,把所有能直接或间接访问到的对象标记为黑色,其它所有对象标志为白色
  3. 清除所有白色对象
  4. start the world

三色标记法:

对象有黑白灰三色

  1. stop the world
  2. 将根对象全部标记为灰色
  3. start the world
  4. 在goroutine中进行对灰色对象进行遍历, 将灰色对象引用的每个对象标记为灰色,然后将该灰色对象标记为黑色。
  5. 重复执行4, 直接将所有灰色对象都变成黑色对象。
  6. stop the world,清除所有白色对象

这里4,5是与用户程序是并发执行的,所以stw的时间被大大缩短了。 不过这样做可能会导致新创建的对象被误清除,因此使用了写屏障技术来解决该问题,大体逻辑是当创建新对象时将新对象置为灰色。

Golang的内存模型,为什么小对象多了会造成gc压力。

通常小对象过多会导致GC三色法消耗过多的GPU。优化思路是,减少对象分配.

Golang 并发

Golang 中常用的控制并发的方式?

  • 通过channel通知实现并发控制
  • 通过sync包中的WaitGroup实现并发控制
  • 在Go 1.7 以后引进的强大的Context上下文,实现并发控制

go语言的并发机制以及它所使用的CSP并发模型.

Golang的CSP并发模型,是通过Goroutine和Channel来实现的。

Goroutine 是Go语言中并发的执行单位。有点抽象,其实就是和传统概念上的”线程“类似,可以理解为”线程“。 Channel是Go语言中各个并发结构体(Goroutine)之前的通信机制。通常Channel,是各个Goroutine之间通信的”管道“,有点类似于Linux中的管道。

通信机制channel也很方便,传数据用channel <- data,取数据用<-channel。

在通信过程中,传数据channel <- data和取数据<-channel必然会成对出现,因为这边传,那边取,两个goroutine之间才会实现通信。

而且不管传还是取,必阻塞,直到另外的goroutine传或者取为止。

Golang中除了加Mutex锁以外还有哪些方式安全读写共享变量?

Golang中Goroutine 可以通过 Channel 进行安全读写共享变量。

什么是channel,为什么它可以做到线程安全?

Channel是Go中的一个核心类型,可以把它看成一个管道,通过它并发核心单元就可以发送或者接收数据进行通讯(communication),Channel也可以理解是一个先进先出的队列,通过管道进行通信。

Golang的Channel,发送一个数据到Channel 和 从Channel接收一个数据 都是 原子性的。而且Go的设计思想就是:不要通过共享内存来通信,而是通过通信来共享内存,前者就是传统的加锁,后者就是Channel。也就是说,设计Channel的主要目的就是在多任务间传递数据的,这当然是安全的。

Golang Runtime

runtime 包的方法

  • Gosched:让当前线程让出 cpu 以让其它线程运行,它不会挂起当前线程,因此当前线程未来会继续执行
  • NumCPU:返回当前系统的 CPU 核数量
  • GOMAXPROCS:设置最大的可同时使用的 CPU 核数
  • Goexit:退出当前 goroutine(但是defer语句会照常执行)
  • NumGoroutine:返回正在执行和排队的任务总数
  • GOOS:目标操作系统

反射

什么时候使用反射

有时候你想在运行时使用变量来处理变量,这些变量使用编写程序时不存在的信息。也许你正试图将来自文件或网络请求的数据映射到变量中。也许创建一个适用于不同类型的tool。在这些情况下,你需要使用反射。反射使您能够在运行时检查类型。它还允许您在运行时检查,修改和创建变量,函数和结构。

  • 类型 反射来获取变量的类型: var t := reflect.Typeof(v)。返回值是一个reflect.Type类型
  • Name() 返回类型的名称。 但是像切片或指针是没有类型名称的,只能返回空字符串。
  • Kind() Kind有slice, map , pointer指针,struct, interface, string , Array, Function, int或其他基本类型组成。Kind和Type之前要做好区分。如果你定义一个 type Foo struct {}, 那么Kind就是struct, Type就是Foo。

堆栈

什么是堆栈?

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

type User struct {
ID int64
Name string
Avatar string
}

func GetUserInfo() *User {
return &User{
ID: 666666,
Name: "sim lou",
Avatar: "https://www.baidu.com/avatar/666666",
}
}

func main() {
u := GetUserInfo()
println(u.Name)
}

这里GetUserInfo 函数里面的 User 对象是存储在函数栈上还是堆上?

  • 堆:一般来讲是人为手动进行管理,手动申请、分配、释放。一般所涉及的内存大小并不定,一般会存放较大的对象。另外其分配相对慢,涉及到的指令动作也相对多
  • 栈:由编译器进行管理,自动申请、分配、释放。一般不会太大,我们常见的函数参数(不同平台允许存放的数量不同),局部变量等等都会存放在栈上

内存逃逸

&User 逃到了堆里,也就是分配到堆上了

因为 GetUserInfo() 返回的是指针对象,引用被返回到了方法之外了。因此编译器会把该对象分配到堆上,而不是栈上。否则方法结束之后,局部变量就被回收了,岂不是翻车。所以最终分配到堆上是理所当然的。

逃逸分析

逃逸分析是一种确定指针动态范围的方法,简单来说就是分析在程序的哪些地方可以访问到该指针。通俗地讲,逃逸分析就是确定一个变量要放堆上还是栈上,

  • 是否有在其他地方(非局部)被引用。只要有可能被引用了,那么它一定分配到堆上。否则分配到栈上
  • 即使没有被外部引用,但对象过大,无法存放在栈区上。依然有可能分配到堆上

对此你可以理解为,逃逸分析是编译器用于决定变量分配到堆上还是栈上的一种行为。

go 在编译阶段确立逃逸,注意并不是在运行时

为什么需要逃逸

其实就是为了尽可能在栈上分配内存,我们可以反过来想,如果变量都分配到堆上了会出现什么事情?例如:

  • 垃圾回收(GC)的压力不断增大
  • 申请、分配、回收内存的系统开销增大(相对于栈)
  • 动态分配产生一定量的内存碎片

总的来说,就是频繁申请、分配堆内存是有一定 “代价” 的。会影响应用程序运行的效率,间接影响到整体系统。因此 “按需分配” 最大限度的灵活利用资源,才是正确的治理之道

对象分配到栈上了。很核心的一点就是它有没有被作用域之外所引用,而这里作用域仍然保留在 main 中,因此它没有发生逃逸。

当形参为 interface 类型时,在编译阶段编译器无法确定其具体的类型。因此会产生逃逸,最终分配到堆上

go怎么确定是否逃逸

编译器命令

可以看到详细的逃逸分析过程。而指令集 -gcflags 用于将标识参数传递给 Go 编译器,涉及如下:

  • -m 会打印出逃逸分析的优化策略,实际上最多总共可以用 4 个 -m,但是信息量较大,一般用 1 个就可以了
  • -l 会禁用函数内联,在这里禁用掉 inline 能更好的观察逃逸情况,减少干扰 go build -gcflags '-m -l' main.go
反编译命令查看

go tool compile -S main.go

总结

  • 静态分配到栈上,性能一定比动态分配到堆上好
  • 底层分配到堆,还是栈。实际上对你来说是透明的,不需要过度关心
  • 每个 Go 版本的逃逸分析都会有所不同(会改变,会优化)
  • 直接通过 go build -gcflags ‘-m -l’ 就可以看到逃逸分析的过程和结果
  • 到处都用指针传递并不一定是最好的,要用对。
刘小恺(Kyle) wechat
如有疑问可联系博主