1、Go语言的数据类型
基本数据类型
1 整形
int8 int16 int32 int64 uint8 uint16 uint32 uint64
int uint uintptr int和uint在32位机器上4字节，在64位机器上8字节
math.MaxInt32 math.MaxInt64 math.MinInt32 math.MinInt64
math.MaxInt math.MinInt
2 浮点型 float32 float64
3 复数 （1+2i） complex32 complex64
4 布尔值 （1字节）bool (true false)
5 字符
byte uint8 一个ASCII码字符
rune int32 一个UTF-8字符
6 字符串 string
注意：只有整形和浮点型，字符串和切片能够强制转换
其他类型
1 数组
2 slice
3 map
4 channel
5 struct
6 func()
7 interface
2、GMP模型？进程、线程、协程的区别？
进程和线程是操作系统创建的，而协程是用户创建的。
协程是用户态的线程，比线程更加的轻量级，操作系统对其没有感知，
之所以没有感知是由于协程处于线程的用户栈能感知的范围，
是由用户创建的而非操作系统。
G：Goroutine，每个goroutine都有自己的栈空间，定时器，初始化的栈空间在2k左右，空间会随着需求增长。
M：内核线程，记录内核线程栈信息，当goroutine调度到线程时，使用该goroutine自己的栈信息。
P：处理器，负责调度goroutine，维护一个本地goroutine队列，M从P上获得goroutine并执行。
M代表一个内核线程，在M上有一个P和G，P是绑定到M上的，G是通过P的调度获取的，在某一时刻，一个M上只有一个G。
在P上拥有一个G队列，里面是已经就绪的G，是可以被调度到线程栈上执行的协程，称为运行队列。
P有2种类型的队列：
本地队列：本地的队列是无锁的，没有数据竞争问题，处理速度比较高。
全局队列：是用来平衡不同的P的任务数量，所有的M共享P的全局队列。
调度策略是为了尽可能地复用线程，避免频繁地创建，销毁线程。
当M没有运行的G时，从其他P的队列上获得G
当M阻塞时，将P转移到其他空闲的M。
3 、了解Golang的GC吗？
常见的GC
引用计数：对每个对象维护一个引用计数，当引用该对象的对象被销毁或更新时，被引用对象的引用计数自动减一，当被引用对象被创建或被赋值给其他对象时引用计数自动加一。当引用计数为0时则立即回收对象。
标记-清除：首先标记所有的可达对象为”被引用”，标记完成后进行清除操作，对没有标记过的内存进行回收（回收同时可能伴有碎片整理操作）。
1.3 以前，使用的是Mark-Sweep 算法，即标记-清理算法
1.3 版本进行了一下改进，把 Sweep 改为了并行操作。
1.5 版本进行了较大改进，使用了三色标记算法。
4、channel
channel是Go语言在语言级别提供的goroutine间的通信方式
是一种进程内的通信方式。
4.1、有缓存和无缓存channel的区别？
管道分为无缓冲管道和有缓冲管道
无缓存channel，只能接受一个数据，有数据时存则阻塞，无数据时取也阻塞
有缓存channel，在满之前存和非空时取不会阻塞，在满时存和空时取会阻塞
4.2、channel的实现原理？
channel 内部就是一个带锁的环形队列。
关键变量：buf、sendx、recvx、lock
buf 指向一个环形队列。
sendx 和 recvx 分别用来记录发送、接收的位置。
然后用一个 lock 互斥锁来确保无数据竞争。
4.3、channel关闭以后，再往其发送或接收，会发生什么？
channel关闭后，发送数据会报错，读取数据不报错
有数据时读数据能正常读取，且读取操作返回true，
无数据时读取则读取到该类型的0值，并且读取返回false，
4.4、哪些操作会使channel发生panic？
情况1：往一个已经关闭的channel写数据
情况2：关闭一个nil的channel
情况3：关闭一个已经关闭的channel
4.5、channel发送和接收元素的本质是什么？
值的拷贝
5、Go slice
5.1 slice内部有什么？
type slice struct {
array unsafe.Pointer // 元素指针
len int // 长度
cap int // 容量
}
底层数组是可以被多个 slice 同时指向的，因此对一个 slice 的元素进行操作可能影响到其他 slice 。
var s []int 创建一个 nil slice。它的长度和容量都为0。和nil比较的结果为true。
var s = make([]int, 0)创建一个empty slice
它的长度和容量也都为0，但是所有的空切片的数据指针都指向同一个地址 ，
空切片和 nil 比较的结果为false。
使用make函数时需要传入三个参数：切片类型，长度，容量。当然，容量可以不传，默认和长度相等。
5.2 slice 和 array 区别？
1 slice 的底层数据是数组，
slice 是对数组的封装，它描述一个数组的片段。
两者都可以通过下标来访问单个元素。
2 数组是定长的，长度定义好之后，不能再更改。
数组长度是类型的一部分，比如 [3]int 和 [4]int 就是不同的类型。
而切片则非常灵活，它可以动态地扩容。切片的类型和长度无关。
3 作为参数传递时，参数是数组时传递的是数组的拷贝，函数内修改不影响外部
参数是切片时传递的是切片的指针的拷贝，函数内修改影响外部
5.3 slice的扩容？
如果切片的容量小于1024个元素，那么扩容的时候slice的cap就翻番，乘以2；
一旦元素个数超过1024个元素，则乘以1.25，即每次增加原来容量的四分之一。
切片的一个特点是，被截取后的数组仍然指向原始切片的底层数据。
slice的拷贝属于引用拷贝。拷贝后的slice如果扩容之后，还没有触及原数组的容量，那么，切片中的指针指向的位置，就还是原数组，
如果扩容之后，超过了原数组的容量，那么，Go就会开辟一块新的内存，把原来的值拷贝过来，这种情况丝毫不会影响到原数组。
在go语言中，切片的复制其实也是值复制，但底层指针仍然指向相同的底层数据地址，因此可以理解为数据进行了引用传递。
如果没有触及原数组的容量，那么操作都是对底层数组进行操作
a:= []int{1,2,3,4,5,6,7,8,9}
b := append(a[:3], a[6:]...)
底层数组变为
1 2 3 6 7 8 9 8 9
即前面操作的地方被修改了，后面保持不变
深拷贝有两种方式
1 copy函数
2 append函数容量达到上限，触发翻倍扩容
6、Go map
1、创建
data := make(map[string]string)
data := map[string]string{"123":"123", "1232":"24424"}
2、获取元素个数
len(data)
cap(data) // 报错, map的容量是自动分配的
3、插入和修改
data["123"] = "aaa"
4、删除
delete(data, "123")
5、查找
elem, ok := data["123"] //查找不存在不会添加该key
6、赋值
data2 := data // data2 和 data 指向同一块地址
// 切片扩容会导致切片不指向同一个地址
// map扩容后仍指向同一个地址
6.1 map底层
type hmap struct {
count int // 字典的键值对个数，即len函数得到的长度
B uint8 // 实际buckets 的长度为 2 ^ B
buckets unsafe.Pointer // 存储 buckets 的地方
oldbuckets unsafe.Pointer // 迁移时oldbuckets中存放部分buckets 的数据
...
}
// buckets数组就是bmap数组
type bmap struct {
tophash [8]uint8 // 存储hash值的高8位
keys [8]keytype // 存储key
values [8]valuetype // 存储value
overflow *bmap // 溢出桶，一个桶装不下，继续向右查找
}
golang的map是hash map，是使用数组+链表的形式实现的，使用拉链法消除hash冲突。
hmap中有一个指向bmap数组的指针
bmap存放键值对，每个bmap可以存8个键值对，如果一个桶满了，
会采用链地址法解决hash 的冲突，链接到下一个溢出桶。
根据键生成64位hash值
hash值的最低B位确定放到那个桶
将tophash、key、value分别写入到tophash、keys、values数组
如果桶已满，则通过溢出桶
查找
先根据hash的低B位找到对应的桶，再根据tophash和key查找对应的元素，
如果当前桶没找到，就根据overflow继续在溢出桶查找
删除
把对应位置置为空，但并不删除空间
扩容和迁移
1、当负载因子大于6.5时，采用翻倍扩容，即使用2^(B+1)个桶
迁移时，采用低B位判断应该分配到那个桶
刚好是原来一个桶的数据分到两个桶中，原来是低B位，现在是低B+1位
多出的那一位是0时，存到原来位置，是1时，刚好是新增加的hash桶中的一个
2、当溢出桶个数过多时，采用等量扩容，不增加新桶，
而是把原始的桶中的数据更紧凑的存放，减少所用的溢出桶的个数，
因为溢出桶中有很多空间没有被利用
B<=15，已使用的溢出桶个数>=2的B次方时，引发等量扩容。
B>15，已使用的溢出桶个数>=2的15次方时，引发等量扩容。
6.2 扩容机制
map不能使用cap，实际大小与申请大小不一定一样，
会根据申请的大小自动分配，一个桶放8个数据，自动分配合适的桶个数
6.3 go的map是线程安全的吗？有没有什么线程安全的办法？
go的map不是线程安全的，
线程安全的方法:
1、加锁，即 map + Mutex 或 map + RWMutex
2、使用sync.Map
7、new和make有什么区别？
new和make都用于申请分配内存
1 new只接受一个参数，即类型，返回一个指向该类型内存地址的指针
同时 new 函数会把分配的内存置为零，也就是类型的零值。
而make只能为slice、map、channel分配内存，返回的是原始类型，
也就是slice, map和chan。
2 new 分配的空间被清零。
make 分配空间后，会进行初始化；
3 如果make用于slice类型，make函数的第2个参数表示slice的长度，这个参数必须给值。
8、函数传指针和传值有什么区别？
go语言中只有值传递，没有引用传递，传指针和传值都会拷贝
指针的拷贝和原始指针指向同一片空间，可以通过指针对内容进行修改
而对拷贝的值本身进行修改不影响外界变量的值
9、什么是内存逃逸，在什么情况下发生，原理是什么?
Go程序变量会携带一组校验数据，用来证明它的整个生命周期是否在运行时完全可知。
如果变量通过这些校验，它就可以在栈上分配。否则就说它逃逸了，必须在堆上分配。
编译器在编译阶段进行逃逸分析，决定某个变量需要分配在栈上，还是堆上。
如果一个变量不能在栈上分配，只能在堆上分配，就说这个变量内存逃逸了。
1、在方法内把局部变量指针返回。局部变量原本应该在栈中分配，在栈中回收。但是由于返回时被外部引用，因此其生命周期大于栈，则溢出。
2、发送指针或带有指针的值到 channel 中。在编译时，是没有办法知道哪个 goroutine 会在 channel 上接收数据。所以编译器没法知道变量什么时候才会被释放。
3、在一个切片上存储指针或带指针的值。比如[]*string，导致切片内容逃逸，其引用值一直在堆上。
4、因为切片的append导致超出容量，切片重新分配地址，切片背后的存储基于运行时的数据进行扩充，就会在堆上分配。
5、在 interface 类型上调用方法。在 interface 类型上调用方法都是动态调度的，方法的真正实现只能在运行时知道。
一个经验是指针指向的数据都是在堆上分配的。
10、闭包
闭包指一个函数与其相关的引用环境组合的一个整体
AddUpper()内部内容就是一个闭包，匿名函数和n组成闭包
func AddUpper() func (int) int {
var n int = 10
return func (x int) int {
n = n + x
return n
}
}
func main() {
f := AddUpper()
fmt.Println(f(1)) // 11
fmt.Println(f(2)) // 13
fmt.Println(f(3)) // 13
}
11、go语言的并发问题
func main() {
for i := 0; i < 10; i++ {
go fmt.Println(i)
}
}
上述代码什么都不会输出，因为主协程已经结束了，其它子协程也要跟着退出
func main() {
for i := 0; i < 10; i++ {
go fmt.Println(i)
}
time.Sleep(time.Second)
}
上述代码会随机输出0~9，顺序是不确定的
func main() {
wait := sync.WaitGroup{}
wait.Add(10)
flag := [11]int{}
flag[0] = 1
for i := 0; i < 10; i++ {
go func(j int){
for {
if flag[j] == 1 {
fmt.Println(j)
flag[j + 1] = 1
wait.Done()
break
} else {
time.Sleep(time.Millisecond * 2)
}
}
}(i)
}
wait.Wait()
}
上述代码可以控制顺序输出0~9
func main() {
wait := sync.WaitGroup{}
wait.Add(2)
ch1 := make(chan int, 1)
ch2 := make(chan int, 1)
ch1 <- 1
go func(){
defer wait.Done()
for i:=0; i<=10; i++{
<- ch1
fmt.Println(2*i)
ch2 <- 1
}
}()
go func(){
defer wait.Done()
for i:=0; i<10; i++{
<- ch2
fmt.Println(2*i+1)
ch1 <- 1
}
}()
wait.Wait()
}
上述代码两个协程交替输出0到20
十 技术栈
语言方面，Go，C++
数据库方面，mysql，redis
技能，make，docker，shell，git
三 有什么要问的
一面面试官给的忠告：不会就直接说不会
1、业务方向，技术栈
2、实习生怎么培养
3、我这次的面试表现怎么样，如果有幸进入下一轮的话，
有哪些方面需要去准备，或者需要去改进的；
