Golang 自学总结（一）

一、基础部分

Go 语言的设计哲学

简单、显式、组合、并发和面向工程。

简单：是指 Go 语言特性始终保持在少且足够的水平，不走语言特性融合的道路，但又不乏生产力。简单是 Go 生产力的源泉，也是 Go 对开发者的最大吸引力；
显式：是指任何代码行为都需开发者明确知晓，不存在因"暗箱操作"而导致可维护性降低和不安全的结果；
组合是构建 Go 程序骨架的主要方式，它可以大幅降低程序元素间的耦合，提高程序的可扩展性和灵活性；
并发：是 Go 敏锐地把握了 CPU 向多核方向发展这一趋势的结果，可以让开发人员在多核时代更容易写出充分利用系统资源、支持性能随 CPU 核数增加而自然提升的应用程序；
面向工程：是 Go 语言在语言设计上的一个重大创新，它将语言要解决的问题域扩展到那些原本并不是由编程语言去解决的领域，从而覆盖了更多开发者在开发过程遇到的"痛点"，为开发者提供了更好的使用体验。

go语言的值类型和引用类型？

值类型：int、float、bool、string和数组这些类型都属于值类型。值类型的变量直接指向存在内存中的值，值类型的变量的值存储在栈中。当使用 = 将一个变量的值赋给另一个变量时，如 j = i ,实际上是在内存中将 i 的值进行了拷贝。可以通过 &i 获取变量 i 的内存地址,值拷贝。
引用类型：切片(slice)类型, map类型 ,管道(channel)类型 , 接口(interface)类型。引用类型拥有更复杂的存储结构:(1)分配内存 (2)初始化

go struct 能不能比较

需要具体情况具体分析，如果struct中含有不能被比较的字段类型，就不能被比较，如果struct中所有的字段类型都支持比较，那么就可以被比较。

不可被比较的类型:

slice，因为slice是引用类型，除非是和nil比较
map，和slice同理，如果要比较两个map只能通过循环遍历实现
函数类型其他的类型都可以比较。

还有两点值得注意：
结构体之间只能比较它们是否相等，而不能比较它们的大小。
只有所有属性都相等而属性顺序都一致的结构体才能进行比较。

为什么引用类型不能比较 ?

引用类型，如果你要比较的话，是想去比较他的值还是说他的地址？这就相当于在比较的时候会有歧义产生，因此 Go 从语言层面上直接杜绝了引用类型的比较；就像两个 slice，如果要去实现他们的 == 比较，你是想去比较 len 是否相等？还是 cap 是否相同？还是底层数组的地址是否相同？还是每个元素的值是否相同？所以说歧义很大的，就干脆不支持比较了。当然引用类型可以和 nil 进行比较。

golang 中 make 和 new 的区别？

共同点：

给变量分配内存；

make 与 new对堆栈分配处理是相同的，编译器优先进行逃逸分析，逃逸的才分配到堆上。

不同点：

作用变量类型不同，new给string、int、数组分配内存，make给切片、map、channel分配内存；

返回类型不一样，new 返回指向变量的指针，make 返回变量本身；

new 分配的空间被清零。make 分配空间后，会进行初始化。

for range 的时候它的地址会发生变化么？

在 for a,b := range c 遍历中， a 和 b 在内存中只会存在一份，即之后每次循环时遍历到的数据都是以值覆盖的方式赋给 a 和 b，a，b 的内存地址始终不变。

由于有这个特性，for 循环里面如果开协程，不要直接把 a 或者 b 的地址传给协程。

解决办法：在每次循环时，创建一个临时变量。

rune 类型

rune 是类型 int32 的别名，在所有方面都等价于它，用来区分字符值跟整数值。

在 Go 语言中，字符可以被分成两种类型处理：

对占 1 个字节的英文类字符，可以使用 byte（或者unit8）；
对占 1 ~ 4 个字节的其他字符，可以使用 rune（或者int32），如中文、特殊符号等。

go 复制代码

s := "Go语言编程"
// byte
fmt.Println([]byte(s)) // 输出：[71 111 232 175 173 232 168 128]
// rune
fmt.Println([]rune(s)) // 输出：[71 111 35821 35328]

反射

关于反射（reflect ）在 Golang 中文标准库中是这样介绍的：

reflect 包实现了运行时反射，允许程序操作任意类型的对象。

典型用法是用静态类型 interface{} 保存一个值,然后

通过调用 TypeOf 获取其动态类型信息，该函数返回一个Type类型值。
调用 ValueOf 函数返回一个 Value 类型值，该值代表运行时的数据。
Zero 接受一个 Type 类型参数并返回一个代表该类型零值的 Value 类型值。

上面提到的 reflect.TypeOf 和 reflect.ValueOf 函数就能完成这里的转换，如果我们认为 Go 语言的类型和反射类型处于两个不同的『世界』，那么这两个函数就是连接这两个世界的桥梁。

go 复制代码

package main

import (
    "fmt"
    "reflect"
)

func main() {
    author := "draven"
    fmt.Println("TypeOf author:", reflect.TypeOf(author))
    fmt.Println("ValueOf author:", reflect.ValueOf(author))
}

// 结果
// TypeOf author: string
// ValueOf author: draven

反射优点：

反射就是在程序运行的过程中，可以对一个未知类型的数据进行操作的过程
可以减少重复代码

缺点：

反射会消耗性能，使程序运行缓慢

反射三定律

反射第一定律：反射可以将"接口类型变量"转换为"反射类型对象"；

go 复制代码

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    t := reflect.TypeOf(x) //t is reflext.Type
    fmt.Println("type:", t)

    v := reflect.ValueOf(x) //v is reflext.Value
    fmt.Println("value:", v)
}

//type: float64
// value: 3.4

反射第二定律：反射可以将"反射类型对象"转换为"接口类型变量"；

go 复制代码

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4

    v := reflect.ValueOf(x) //v is reflext.Value

    var y float64 = v.Interface().(float64)
    fmt.Println("value:", y)
}

反射第三定律：如果要修改"反射类型对象"，其值必须是"可写的"。

go 复制代码

package main

import (
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x)
    v.SetFloat(7.1) // Error: will panic.
}

// panic: reflect: reflect.Value.SetFloat using unaddressable value

错误原因即是 v 是不可修改的。

反射对象是否可修改取决于其所存储的值，回想一下函数传参时是传值还是传址就不难理解上例中为何失败了。上例中，传入reflect.ValueOf()函数的其实是x的值，而非x本身。即通过v修改其值是无法影响x的，也即是无效的修改，所以golang会报错。

想到此处，即可明白，如果构建v时使用x的地址就可实现修改了，但此时v代表的是指针地址，我们要设置的是指针所指向的内容，也即我们想要修改的是 *v 。那怎么通过v修改x的值呢？ reflect.Value 提供了 Elem() 方法，可以获得指针向指向的 value 。看如下代码：

css 复制代码

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(&x)
    v.Elem().SetFloat(7.1)
    fmt.Println("x:", v.Elem().Interface()) // x: 7.1
    fmt.Println("x:", x)                    // x: 7.1
}

调用函数传入结构体时，应该传值还是指针？

go 里面只存在只存在值传递(要么是该值的副本，要么是指针的副本)，不存在引用传递。之所以对于引用类型的传递可以修改原内容数据，是因为在底层默认使用该引用类型的指针进行传递，但是也是使用指针的副本，依旧是值传递。

值类型：int、float、bool、string和数组这些类型都属于值类型。

值类型的变量直接指向存在内存中的值，值类型的变量的值存储在栈中。当使用 = 将一个变量的值赋给另一个变量时，如 j = i ,实际上是在内存中将 i 的值进行了拷贝。可以通过 &i 获取变量 i 的内存地址,值拷贝。

引用类型：特指 slice、map、channel 这三种预定义类型。

引用类型拥有更复杂的存储结构:(1)分配内存 (2)初始化。

Go 的 select 底层数据结构和一些特性？

go 的 select 为 golang 提供了多路 IO 复用机制，和其他 IO 复用一样，用于检测是否有读写事件是否 ready。

select 结构组成主要是由 case 语句和执行的函数组成 select 实现的多路复用是：每个线程或者进程都先到注册和接受的 channel（装置）注册，然后阻塞，然后只有一个线程在运输，当注册的线程和进程准备好数据后，装置会根据注册的信息得到相应的数据。

go 复制代码

package main
import (
    "fmt" 
    "time"
)

func main()  {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go func1 ()  {
        time.Sleep(time.Second)
        ch1 <- 1
    }()

    go func2 ()  {
        ch2 <- 3
    }()

    select {
    case i := <-ch1:
        fmt.Printf("从ch1读取了数据%d", i)
    case j := <-ch2:
        fmt.Printf("从ch2读取了数据%d", j)
    }
}

select 的特性

1）select 操作至少要有一个 case 语句，出现读写 nil 的 channel 该分支会忽略，在 nil 的 channel 上操作则会报错；

2）select 仅支持管道，而且是单协程操作；

3）每个 case 语句仅能处理一个管道，要么读要么写；

4）多个 case 语句的执行顺序是随机的；

5）存在 default 语句，select 将不会阻塞，但是存在 default 会影响性能；

6）select 是异步阻塞的；

7）对于空的select{}，会引起死锁。

select 的场景

1.竞争选举

这个是最常见的使用场景，多个通道，有一个满足条件可以读取，就可以"竞选成功"。

go 复制代码

    select {
    case i := <-ch1:
        fmt.Printf("从ch1读取了数据%d", i)
    case j := <-ch2:
        fmt.Printf("从ch2读取了数据%d", j)
    case m := <- ch3
        fmt.Printf("从ch3读取了数据%d", m)
    ...
    }

2.超时处理（保证不阻塞）

因为select是阻塞的，我们有时候就需要搭配超时处理来处理这种情况，超过某一个时间就要进行处理，保证程序不阻塞。

css 复制代码

select {
    case str := <- ch1
        fmt.Println("receive str", str)
    case <- time.After(time.Second * 5): 
        fmt.Println("timeout!!")
}

3.阻塞main函数

有时候我们会让main函数阻塞不退出，如http服务，我们会使用空的select{}来阻塞main goroutine。

go 复制代码

package main
import (
    "fmt"
    "time"
)

func main()  {
    bufChan := make(chan int)
    
    go func() {
        for{
            bufChan <-1
            time.Sleep(time.Second)
        }
    }()


    go func() {
        for{
            fmt.Println(<-bufChan)
        }
    }()
     
    select{}
}

context 结构是什么样的？context 使用场景和用途？

Go 1.7 标准库引入 context，中文译作"上下文"，准确说它是 goroutine 的上下文，包含 goroutine 的运行状态、环境、现场等信息。

Go 的 Context 的数据结构包含 Deadline，Done，Err，Value。

context 主要用来

在 goroutine 之间传递上下文信息，包括：取消信号、超时时间、截止时间、k-v 等；
上下文控制；
多个 goroutine 之间的数据交互等；
超时控制：到某个时间点超时，过多久超时。

在 Go context 用法中，我们常常将其与 select 关键字结合使用，用于监听其是否结束、取消等。

演示代码：

css 复制代码

func main() {
	parentCtx := context.Background()
	ctx, cancel := context.WithTimeout(parentCtx, 1*time.Millisecond)
	defer cancel()
 
	select {
	case <-time.After(1 * time.Second):
		fmt.Println("overslept")
	case <-ctx.Done():
		fmt.Println(ctx.Err())
	}
}

// context deadline exceeded

我们通过调用标准库 context.WithTimeout 方法针对 parentCtx 变量设置了超时时间，并在随后调用 select-case 进行 context.Done 方法的监听，最后由于达到了截止时间。因此逻辑上 select 走到了 context.Err 的 case 分支，最终输出 context deadline exceeded。

Go语言中的单引号、双引号和反引号

1.单引号

单引号在go语言中表示golang中的rune(int32)类型，单引号里面是单个字符，对应的值为改字符的ASCII值。

go 复制代码

func main() {
    a := 'A'
    fmt.Println(a)
}

// 输出：
// 65

2.双引号

在 go 语言中双引号里面可以是单个字符也可以是字符串，双引号里面可以有转义字符，如\n、\r等，对应 go 语言中的 string类型。

go 复制代码

func main() {
    a := "Hello golang\nI am random_wz."
    fmt.Println(a)
}

// 输出：
// Hello golang
// I am random_wz.

3.反引号

反引号中的字符表示其原生的意思，在单引号中的内容可以是多行内容，不支持转义。

go 复制代码

func main() {
    a := `Hello golang\n:
I am random_wz.
Good.`
    fmt.Println(a)
}

// 输出：
// Hello golang\n:
// I am random_wz.
// Good.

可以看到 \n 并没有被转义，而是被直接作为字符串输出。

二、数组和切片

数组和切片的区别

相同点：

只能存储一组相同类型的数据结构；
都是通过下标来访问，并且有容量长度，长度通过 len 获取，容量通过 cap 获取；
函数传递中，数组切片都是值传递。区别：
数组是定长，访问和复制不能超过数组定义的长度，否则就会下标越界，切片长度和容量可以自动扩容；
数组是值类型，切片是引用类型，每个切片都引用了一个底层数组，切片本身不能存储任何数据，都是这底层数组存储数据，所以修改切片的时候修改的是底层数组中的数据。切片一旦扩容，指向一个新的底层数组，内存地址也就随之改变；
定义方式不一样、初始化方式不一样，数组需要指定大小，大小不改变。

数组的定义

csharp 复制代码

var a1 [3]int

var a2 [...]int{1,2,3}

切片的定义

go 复制代码

var a1 []int

var a2 :=make([]int,3,5)

数组的初始化

go 复制代码

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

a2 := [5]int{1,2,3}

切片的初始化

go 复制代码

b:= make([]int,3,5)

Go 的 slice 底层数据结构和一些特性？

Go 的 slice 底层数据结构是由一个 array 指针指向底层数组，len 表示切片长度，cap 表示切片容量。slice 的主要实现是扩容:

对于 append 向 slice 添加元素时，假如 slice 容量够用，则追加新元素进去，slice.len++，返回原来的 slice。
当原容量不够，则 slice 先扩容，扩容之后 slice 得到新的 slice，将元素追加进新的 slice，slice.len++，返回新的 slice。

对于切片的扩容规则

当切片比较小时（容量小于 1024），则采用较大的扩容倍速进行扩容（新的扩容会是原来的 2 倍），避免频繁扩容，从而减少内存分配的次数和数据拷贝的代价。
当切片较大的时（原来的 slice 的容量大于或者等于 1024），采用较小的扩容倍速（新的扩容将扩大大于或者等于原来 1.25 倍），主要避免空间浪费。

数组是如何实现用下标访问任意元素的

例如： a := [10]int{0}

计算机给数组a，分配了一组连续的内存空间。

比如内存块的首地址为 base_address=1000。

当计算给每个内存单元分配一个地址，计算机通过地址来访问数据。当计算机需要访问数组的某个元素的时候，会通过一个寻址公式来计算存储的内存地址。

三、map

Go map 的底层实现？

go 复制代码

// Go map的一个header结构
type hmap struct {
    count     int // map的大小.  len()函数就取的这个值
    flags     uint8 //map状态标识
    B         uint8  // 可以最多容纳 6.5 * 2 ^ B 个元素，6.5为装载因子即:map长度=6.5*2^B
                    //B可以理解为buckets已扩容的次数
    noverflow uint16 // 溢出buckets的数量
    hash0     uint32 // hash 种子
 
    buckets    unsafe.Pointer //指向最大2^B个Buckets数组的指针. count==0时为nil.
    oldbuckets unsafe.Pointer //指向扩容之前的buckets数组，并且容量是现在一半.不增长就为nil
    nevacuate  uintptr  // 搬迁进度，小于nevacuate的已经搬迁
    extra *mapextra // 可选字段，额外信息
}
 
//额外信息
 type mapextra struct {
     overflow    *[]*bmap
     oldoverflow *[]*bmap
 
     nextOverflow *bmap
 }
 
 //在编译期间会产生新的结构体，bucket
 type bmap struct {
     tophash [8]uint8 //存储哈希值的高8位
     data    byte[1]  //key value数据:key/key/key/.../value/value/value...
     overflow *bmap   //溢出bucket的地址
 }

hmap：

buckets中包含了哈希中最小细粒度单元bucket桶，数据通过hash函数均匀的分布在各个bucket中，buckets这个参数，它存储的是指向buckets数组的一个指针，当bucket(桶为0时)为nil。我们可以理解为，hmap指向了一个空bucket数组。

bmap(bucket)

bucket（桶），每一个bucket最多放8个key和value，最后由一个overflow字段指向下一个bmap，注意key、value、overflow字段都不显示定义，而是通过maptype计算偏移获取的。

它的tophash 存储的是哈希函数算出的哈希值的高八位。是用来加快索引的。因为把高八位存储起来，这样不用完整比较key就能过滤掉不符合的key，加快查询速度当一个哈希值的高8位和存储的高8位相符合，再去比较完整的key值，进而取出value。
第二部分，存储的是key 和value，就是我们传入的key和value，注意，它的底层排列方式是，key全部放在一起，value全部放在一起。当key大于128字节时，bucket的key字段存储的会是指针，指向key的实际内容；value也是一样。这样排列好处是在key和value的长度不同的时候，可以消除padding带来的空间浪费。并且每个bucket最多存放8个键值对。
第三部分，存储的是当bucket溢出时，指向的下一个bucket的指针

查找和插入

了解查找和插入过程，必须要先知道高位hash和低位hash值

哈希函数会将传入的key值进行哈希运算，得到一个唯一的值。

比如key1的hash值为：1123456789876543210 若将前八位hash值取出"11234567"部分就叫做"高位哈希值"。Go取后B位hash值为"低位hash值"。

高位哈希值：是用来确定当前的bucket（桶）有没有所存储的数据的。

低位哈希值：是用来确定，当前的数据存在了哪个bucket（桶）。

查找过程如下：

根据key值算出哈希值；
取哈希值低位与hmap.B取模确定bucket位置；
取哈希值高位在tophash数组中查询；
如果tophash[i]中存储值也哈希值相等，则去找到该bucket中的key值进行比较；
当前bucket没有找到，则继续从下个overflow的bucket中查找；
如果当前处于搬迁过程，则优先从oldbuckets查找；注：如果查找不到，也不会返回空值，而是返回相应类型的0值。

新元素插入过程如下：

根据key值算出哈希值；
取哈希值低位与hmap.B取模确定bucket位置；
查找该key是否已经存在，如果存在则直接更新值；
如果没找到将key，将key插入。

如图：

算出hash值
取高低位hash值

通过低位hash找到对应bucket桶，再通过高位hash找到对应key值（此处可能有hash冲突和扩容），

查找hahs冲突：若找到对应高位hash值，但key值不一致，则线性向下或通过扩展指针(数组到末尾了)查找key值。

插入hash冲突：先查找，若存在重复高位hash值，则线性向下寻空位插入。若当前kv数组已满，则扩展bucket，插入

渐进式扩容

扩容的前提条件

为了保证访问效率，当新元素将要添加进map时，都会检查是否需要扩容，扩容实际上是以空间换时间的手段。触发扩容的条件有二个：

负载因子 > 6.5时，也即平均每个bucket存储的键值对达到6.5个。当溢出桶过多时：

当 B < 15 时，如果overflow的bucket数量超过 2^B
当 B >= 15 时，overflow的bucket数量超过 2^15

简单来讲，新加入key的hash值后B位都一样，使得个别桶一直在插入新数据，进而导致它的溢出桶链条越来越长。如此一来，当map在操作数据时，扫描速度就会变得很慢。及时的扩容，可以对这些元素进行重排，使元素在桶的位置更平均一些。

等量扩容

由于map中不断的 put 和delete key，桶中可能会出现很多断断续续的空位，这些空位会导致连接的bmap溢出桶很长，导致扫描时间边长。这种扩容实际上是一种整理，把后置位的数据整理到前面。这种情况下，元素会发生重排，但不会换桶。

增量扩容

这种2倍扩容是由于当前桶数组确实不够用了，发生这种扩容时，元素会重排，可能会发生桶迁移。

当负载因子过大时，就新建一个 bucket，新的 bucket 长度是原来的 2 倍，然后旧 bucket 数据搬迁到新的 bucket。

考虑到如果 map 存储了数以亿计的 key-value，一次性搬迁将会造成比较大的延时，Go采用逐步搬迁策略，即每次访问 map 时都会触发一次搬迁，每次搬迁2 个键值对。

B=0，其溢出桶上限也为2^0 =1,触发条件进行buckets扩容，则根据后B位hash值进行元素重排

map 是否并发安全？

map默认是并发不安全的，同时对map进行并发读写时，程序会panic。

实现map线程安全，有两种方式：

使用读写锁map+sync.RWMutex
使用sync.Map

map 循环是有序的还是无序的？

无序的, map 因扩容⽽重新哈希时，各键值项存储位置都可能会发生改变，顺序自然也没法保证了，所以官方避免大家依赖顺序，直接打乱处理。就是 for range map 在开始处理循环逻辑的时候，就做了随机播种。

golang 哪些类型可以作为map key

在golang规范中，可比较的类型都可以作为map key，包括：

boolean 布尔值
numeric 数字包括整型、浮点型，以及复数
string 字符串
pointer 指针两个指针类型相等，表示两指针指向同一个变量或者同为nil
channel 通道两个通道类型相等，表示两个通道是被相同的make调用创建的或者同为nil
interface 接口两个接口类型相等，表示两个接口类型的动态类型和动态值都相等或者两接口类型同为 nil
structs、arrays 只包含以上类型元素

不能作为map key 的类型包括：

slices
maps
functions

map取一个key，然后修改这个值，原map数据的值会不会变化

map属于引用类型，所以取一个key，然后修改这个值，原map数据的值会发生变化。

map 中删除一个 key，它的内存会释放么？

如果删除的元素是值类型，如int，float，bool，string以及数组和struct，map的内存不会自动释放；

如果删除的元素是引用类型，如指针，slice，map，chan等，map的内存会自动释放，但释放的内存是子元素应用类型的内存占用；

将map设置为nil后，内存被回收。

nil map 和空 map 有何不同？

nil map 未初始化

空 map 是长度为空

可以对未初始化的map进行取值，但取出来的东西是空：

go 复制代码

var m1 map[string]string

fmt.Println(m1["1"])

不能对未初始化的map进行赋值，这样将会抛出一个异常：

go 复制代码

var m1 map[string]string

m1["1"] = "1"

// panic: assignment to entry in nil map

通过fmt打印map时，空map和nil map结果是一样的，都为map[]。所以，这个时候别断定map是空还是nil，而应该通过map == nil来判断。

四、goroutine

为什么不要大量使用goroutine

大量创建goroutine，势必会消耗大量的系统资源（如内存、CPU等），从而可能导致系统崩溃。避免不必要的麻烦，应该合理创建goroutine的数量。

多个 goroutine 对同一个 map 写会 panic，异常是否可以用 defer 捕获？

可以捕获异常，但是只能捕获一次，Go语言，可以使用多值返回来返回错误。不要用异常代替错误，更不要用来控制流程。在极个别的情况下，才使用Go中引入的 Exception 处理：defer, panic, recover Go中，对异常处理的原则是：多用error包，少用panic。

go 复制代码

defer func() {
		if err := recover(); err != nil {
			// 打印异常，关闭资源，退出此函数
			fmt.Println(err)
		}
	}()

2 个协程交替打印字母和数字

go 复制代码

package main

import (
	"fmt"
)

func main() {
	limit := 26

	numChan := make(chan int, 1)
	charChan := make(chan int, 1)
	mainChan := make(chan int, 1)
	charChan <- 1

	go func() {
		for i := 0; i < limit; i++ {
			<-charChan
			fmt.Printf("%c\n", 'a'+i)
			numChan <- 1

		}
	}()
	go func() {
		for i := 0; i < limit; i++ {
			<-numChan
			fmt.Println(i)
			charChan <- 1

		}
		mainChan <- 1
	}()
	<-mainChan
	close(charChan)
	close(numChan)
	close(mainChan)
}

为什么需要协程池？

虽然go语言自带"高并发"的标签，其并发编程就是由groutine实现的，因其消耗资源低（大约2KB左右，线程通常2M左右），性能高效，开发成本低的特性而被广泛应用到各种场景，例如服务端开发中使用的HTTP服务，在golang net/http包中，每一个被监听到的tcp链接都是由一个groutine去完成处理其上下文的，由此使得其拥有极其优秀的并发量吞吐量。

但是，如果无休止的开辟Goroutine依然会出现高频率的调度Groutine，那么依然会浪费很多上下文切换的资源，导致做无用功。所以设计一个Goroutine池限制Goroutine的开辟个数在大型并发场景还是必要的。

简单的协程池

go 复制代码

package main
 
import (
	"fmt"
	"time"
)
 
/* 有关Task任务相关定义及操作 */
//定义任务Task类型,每一个任务Task都可以抽象成一个函数
type Task struct {
	f func() error //一个无参的函数类型
}
 
//通过NewTask来创建一个Task
func NewTask(f func() error) *Task {
	t := Task{
		f: f,
	}
	return &t
}
 
//执行Task任务的方法
func (t *Task) Execute() {
	t.f() //调用任务所绑定的函数
}
 
/* 有关协程池的定义及操作 */
//定义池类型
type Pool struct {
	EntryChannel chan *Task //对外接收Task的入口
	worker_num   int        //协程池最大worker数量,限定Goroutine的个数
	JobsChannel  chan *Task //协程池内部的任务就绪队列
}
 
//创建一个协程池
func NewPool(cap int) *Pool {
	p := Pool{
		EntryChannel: make(chan *Task),
		worker_num:   cap,
		JobsChannel:  make(chan *Task),
	}
	return &p
}
 
//协程池创建一个worker并且开始工作
func (p *Pool) worker(work_ID int) {
	//worker不断的从JobsChannel内部任务队列中拿任务
	for task := range p.JobsChannel {
		//如果拿到任务,则执行task任务
		task.Execute()
		fmt.Println("worker ID ", work_ID, " 执行完毕任务")
	}
}
 
//让协程池Pool开始工作
func (p *Pool) Run() {
	//1,首先根据协程池的worker数量限定,开启固定数量的Worker,
	//  每一个Worker用一个Goroutine承载
	for i := 0; i < p.worker_num; i++ {
		fmt.Println("开启固定数量的Worker:", i)
		go p.worker(i)
	}
 
	//2, 从EntryChannel协程池入口取外界传递过来的任务
	//   并且将任务送进JobsChannel中
	for task := range p.EntryChannel {
		p.JobsChannel <- task
	}
 
	//3, 执行完毕需要关闭JobsChannel
	close(p.JobsChannel)
	fmt.Println("执行完毕需要关闭JobsChannel")
 
	//4, 执行完毕需要关闭EntryChannel
	close(p.EntryChannel)
	fmt.Println("执行完毕需要关闭EntryChannel")
}
 
//主函数
func main() {
	//创建一个Task
	t := NewTask(func() error {
		fmt.Println("创建一个Task:", time.Now().Format("2006-01-02 15:04:05"))
		return nil
	})
 
	//创建一个协程池,最大开启3个协程worker
	p := NewPool(3)
 
	//开一个协程 不断的向 Pool 输送打印一条时间的task任务
	go func() {
		for {
			p.EntryChannel <- t
		}
	}()
 
	//启动协程池p
	p.Run()
}

优雅关闭Golang中的协程

第一种方式：

采用 for-range 从 channel 上接收值，直到 channel 关闭，该循环将失效自动推出 for range

go 复制代码

func TestNameChannel(t *testing.T) {
	WaitInfo.Add(1)
	exitChannel := make(chan int, 20)
	go DoSome1(exitChannel)
	for i := 0; i < 10; i++ {
		//执行完某个业务的时候决定退出逻辑
		exitChannel <- i
	}
	//如果不关闭通道会导致程序阻塞
	close(exitChannel)
	WaitInfo.Wait()

}

func DoSome(exitChannel chan int) {
	//doSome.....
	defer WaitInfo.Done()
	for value := range exitChannel {
		fmt.Println(value)
	}
}

第二种方式：

采用 for select 配合退出队列的队列的方式完成协程的退出

go 复制代码

func TestNameChannel(t *testing.T) {
	exitChannel := make(chan int)
	doSomeChannel := make(chan int)
	WaitInfo.Add(1)
	go DoSome(exitChannel, doSomeChannel)
	for i := 0; i < 3; i++ {
		doSomeChannel <- i
		time.Sleep(time.Second)
		if i == 2 {
			exitChannel <- 1
			break
		}
	}

	WaitInfo.Wait()
}

func DoSome(exitChannel chan int, doSomeChannel chan int) {

	for {
		select {
		case <-exitChannel:
			fmt.Println("我要关闭通道了")
			time.Sleep(time.Second)
			WaitInfo.Done()
			return
		case info := <-doSomeChannel:
			fmt.Println(info)
			time.Sleep(time.Second)
		default:
			time.Sleep(time.Second)
			fmt.Println("===default===")
		}
	}
}

第三种方式

通过框架提供的 Context 对象完成协程的优雅推出，Done 会返回一个 channel，当该 context 被取消的时候，该 channel 会被关闭，同时对应的使用该 context 的 routine 也应该结束并返回。

go 复制代码

var WaitInfo sync.WaitGroup

func TestNameChannel(t *testing.T) {
	doSomeChannel := make(chan int)
	WaitInfo.Add(1)
	ctx, CancelFunc := context.WithCancel(context.Background())
	go DoSome(ctx, doSomeChannel)
	for i := 0; i < 3; i++ {
		doSomeChannel <- i
		time.Sleep(time.Second)
		if i == 2 {
			CancelFunc()
			break
		}
	}
	WaitInfo.Wait()
}

func DoSome(context context.Context, doSomeChannel chan int) {

	for {
		select {
		case <-context.Done():
			fmt.Println("通过Context对象完成协程的退出")
			WaitInfo.Done()
			return
		case info := <-doSomeChannel:
			fmt.Println(info)
			time.Sleep(time.Second)
		default:
			time.Sleep(time.Second)
			fmt.Println("===default===")
		}
	}
}

五、channel

channel 的底层实现原理

channel主要用于进程内各 goroutine 间通信，如果需要跨进程通信，建议使用分布式系统的方法来解决。

chan数据结构:

go 复制代码

type hchan struct {
	qcount   uint           // 当前队列中剩余元素个数
	dataqsiz uint           // 环形队列长度，即可以存放的元素个数
	buf      unsafe.Pointer // 环形队列指针
	elemsize uint16         // 每个元素的大小
	closed   uint32	        // 标识关闭状态
	elemtype *_type         // 元素类型
	sendx    uint           // 队列下标，指示元素写入时存放到队列中的位置
	recvx    uint           // 队列下标，指示元素从队列的该位置读出
	recvq    waitq          // 等待读消息的goroutine队列
	sendq    waitq          // 等待写消息的goroutine队列
	lock mutex              // 互斥锁，chan不允许并发读写
}

环形队列

chan内部实现了一个环形队列作为其缓冲区，队列的长度是创建chan时指定的。

下图展示了一个可缓存6个元素的channel示意图：

dataqsiz指示了队列长度为6，即可缓存6个元素；
buf指向队列的内存，队列中还剩余两个元素；
qcount表示队列中还有两个元素；
sendx指示后续写入的数据存储的位置，取值[0, 6)；
recvx指示从该位置读取数据, 取值[0, 6)；

channel 读写原理

创建channel

创建channel的过程实际上是初始化hchan结构。其中类型信息和缓冲区长度由make语句传入，buf的大小则与元素大小和缓冲区长度共同决定。

创建channel的伪代码如下所示：

ini 复制代码

func makechan(t *chantype, size int) *hchan {
	var c *hchan
	c = new(hchan)
	c.buf = malloc(元素类型大小*size)
	c.elemsize = 元素类型大小
	c.elemtype = 元素类型
	c.dataqsiz = size
 
	return c
}

向channel写数据

向一个channel中写数据简单过程如下：

如果等待接收队列recvq不为空，说明缓冲区中没有数据或者没有缓冲区，此时直接从recvq取出G(队列),并把数据写入，最后把该G唤醒，结束发送过程；
如果缓冲区中有空余位置，将数据写入缓冲区，结束发送过程；
如果缓冲区中没有空余位置，将待发送数据写入 G，将当前G 加入 sendq，进入睡眠，等待被读goroutine 唤醒；

从channel读数据

从一个channel读数据简单过程如下：

如果等待发送队列sendq不为空，且没有缓冲区，直接从sendq中取出G，把G中数据读出，最后把G唤醒，结束读取过程；
如果等待发送队列sendq不为空，此时说明缓冲区已满，从缓冲区中首部读出数据，把G中数据写入缓冲区尾部，把G唤醒，结束读取过程；
如果缓冲区中有数据，则从缓冲区取出数据，结束读取过程；
将当前goroutine加入recvq，进入睡眠，等待被写goroutine唤醒；

关闭channel

关闭channel时会把recvq中的G全部唤醒，本该写入 G 的数据位置为nil。把 sendq 中的 G 全部唤醒，但这些 G 会 panic。

除此之外，panic出现的常见场景还有：

关闭值为 nil 的channel；
关闭已经被关闭的 channel；
向已经关闭的 channel 写数据。

对已经关闭的channel进行读写操作会发生什么?

读已关闭的channel

读已经关闭的channel无影响。如果在关闭前，通道内部有元素，会正确读到元素的值；如果关闭前通道无元素，则会读取到通道内元素类型对应的零值。若遍历通道，如果通道未关闭，读完元素后，会报死锁的错误。

fatal error: all goroutines are asleep - deadlock!

写已关闭的通道

会引发panic: send on closed channel

关闭已关闭的通道

会引发panic: close of closed channel

总结：对于一个已初始化，但并未关闭的通道来说，收发操作一定不会引发 panic。但是通道一旦关闭，再对它进行发送操作，就会引发 panic。如果我们试图关闭一个已经关闭了的通道，也会引发 panic。

有缓冲和无缓冲通道 channel

ch1:=make(chan int) 无缓冲

在向chan写入数据时，会阻塞当前协程，直到其他协程从该chan中读取了数据。

ch2:=make(chan int,1) 有缓冲

向chan写入数据时，若chan未满不会阻塞协程，满时阻塞线程直至缓冲有空间可写入。

arduino 复制代码

ch <- x		//发送语句
x = <-ch	//接收语句
<-ch		//接收语句，丢弃结果

通道类型的值本身就是并发安全的。

channel的应用场景

channel适用于数据在多个协程中流动的场景，有很多实际应用：

超时处理：

css 复制代码

select {
    case <-time.After(time.Second):
    }

定时任务

lua 复制代码

select {
    case <- time.Tick(time.Second)
    }

解耦生产者和消费者

可以将生产者和消费者解耦出来，生产者只需要往channel发送数据，而消费者只管从channel中获取数据。

控制并发数

以爬虫为例，比如需要爬取1w条数据，需要并发爬取以提高效率，但并发量又不过过大，可以通过channel来控制并发规模，比如同时支持5个并发任务：

go 复制代码

ch := make(chan int, 5)
	for _, url := range urls {
		go func() {
			ch <- 1
			worker(url)
			<- ch
		}
	}

六、GPM

G 是 Goroutine 的缩写，相当于操作系统的进程控制块 (process control block)。它包含：函数执行的指令和参数，任务对象，线程上下文切换，字段保护，和字段的寄存器。

M 是一个线程，每个 M 都有一个线程的栈。

P (处理器，Processor) 是一个抽象的概念，不是物理上的CPU。当一个P有任务，需要创建或者唤醒一个系统线程去处理它队列中的任务。P决定同时执行的任务的数量，GOMAXPROCS 限制系统线程执行用户层面的任务的数量。

GO 调度器的调度过程： 首先创建一个 G 对象，然后 G 被保存在 P 的本地队列或者全局队列（global queue）。这时 P 会唤醒一个 M 。P 按照它的执行顺序继续执行任务。M 寻找一个空闲的 P，如果找得到，将 G 与自己绑定。然后 M 执行一个调度循环：调用 G 对象 -> 执行 -> 清理线程 -> 继续寻找Goroutine。

在 M 的执行过程中，上下文切换随时发生。当切换发生，任务的执行现场需要被保护，这样在下一次调度执行可以进行现场恢复。M的栈保存在G对象中，只有现场恢复需要的寄存器(SP,PC等)，需要被保存到G对象。

如果G对象还没有被执行，M可以将G重新放到P的调度队列，等待下一次的调度执行。当调度执行时，M可以通过G的vdsoSP, vdsoPC 寄存器进行现场恢复。

P队列 P有2种类型的队列：

**本地队列：**本地的队列是无锁的，没有数据竞争问题，处理速度比较高。

**全局队列：**是用来平衡不同的P的任务数量，所有的M共享P的全局队列。线程清理 G的调度是为了实现P/M的绑定，所以线程清理就是释放P上的G，让其他的G能够被调度。

**主动释放(active release)：**典型的例子是，执行G任务时，发生了系统调用(system call)，这时M会处于阻塞（Block）状态。调度器会设置一个超时时间，来释放P。

**被动释放(passive release)：**如果系统调用发生，监控程序需要扫描处于阻塞状态的P/M。这时，超时之后，P资源会回收，程序被安排给队列中的其他G任务。

M 和 P 的数量问题？

p默认cpu内核数

M与P的数量没有绝对关系，一个M阻塞，P就会去创建或者切换另一个M，所以，即使P的默认数量是1，也有可能会创建很多个M出来。

goroutine 的自旋占用资源如何解决

自旋锁是指当一个线程在获取锁的时候，如果锁已经被其他线程获取，那么该线程将循环等待，然后不断地判断是否能够被成功获取，直到获取到锁才会退出循环。

自旋的条件如下：

还没自旋超过 4 次,
多核处理器，
GOMAXPROCS > 1，
p 上本地 goroutine 队列为空。

mutex 会让当前的 goroutine 去空转 CPU，在空转完后再次调用 CAS 方法去尝试性的占有锁资源，直到不满足自旋条件，则最终会加入到等待队列里。

如果 goroutine 一直占用资源，GMP模型怎么解决这个问题

如果有一个goroutine一直占用资源的话，GMP模型会从正常模式转为饥饿模式，通过信号协作强制处理在最前的 goroutine 去分配使用。

进程、线程、协程有什么区别？

进程：是应用程序的启动实例，每个进程都有独立的内存空间，不同的进程通过进程间的通信方式来通信。

线程：从属于进程，每个进程至少包含一个线程，线程是 CPU 调度的基本单位，多个线程之间可以共享进程的资源并通过共享内存等线程间的通信方式来通信。

协程：为轻量级线程，与线程相比，协程不受操作系统的调度，协程的调度器由用户应用程序提供，协程调度器按照调度策略把协程调度到线程中运行

Go 中主协程如何等待其余协程退出?

答：Go 的 sync.WaitGroup 是等待一组协程结束，sync.WaitGroup 只有 3 个方法

Add()是添加计数；
Done()减去一个计数；
Wait()阻塞直到所有的任务完成。

Go 里面还能通过有缓冲的 channel 实现其阻塞等待一组协程结束，这个不能保证一组 goroutine 按照顺序执行，可以并发执行协程。Go 里面能通过无缓冲的 channel 实现其阻塞等待一组协程结束，这个能保证一组 goroutine 按照顺序执行，但是不能并发执行。

CPU 占用 100% 如何排查？

使用性能分析工具 pprof

go tool pprof
执行命令, pprof 会分析内存占用信息，并进入命令行模式

rust 复制代码

go tool pprof http://127.0.0.1:6060/debug/pprof/heap
Fetching profile over HTTP from http://127.0.0.1:8888/debug/pprof/heap
Saved profile in C:\Users\2837.GOLDENTECAD\pprof\pprof.alloc_objects.alloc_space.inuse_objects.inuse_space.001.pb.gz
Type: inuse_space
Time: Oct 28, 2021 at 3:15pm (CST)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof)

top
输入 top10，会显示前10 最消耗cpu的程序片断

erlang 复制代码

(pprof) top10
Showing nodes accounting for 30ms, 100% of 30ms total
Showing top 10 nodes out of 15
      flat  flat%   sum%        cum   cum%
      10ms 33.33% 33.33%       10ms 33.33%  runtime.checkTimers
      10ms 33.33% 66.67%       10ms 33.33%  runtime.lock2
      10ms 33.33%   100%       10ms 33.33%  sync.(*Pool).pin
...

description
    flat：给定函数上运行耗时
    flat%：同上的 CPU 运行耗时总比例
    sum%：给定函数累积使用 CPU 总比例
    cum：当前函数加上它之上的调用运行总耗时
    cum%：同上的 CPU 运行耗时总比例

还可以：

输入 web 命令，可在弹出的浏览器窗口看到cpu占用情况;
输入 pdf 命令，会生成一张pdf文件;

七、锁

channel 和锁的对比

并发问题可以用channel解决也可以用Mutex解决，但是它们的擅长解决的问题有一些不同。

channel关注的是并发问题的数据流动，适用于数据在多个协程中流动的场景。

而mutex关注的是是数据不动，某段时间只给一个协程访问数据的权限，适用于数据位置固定的场景。

Mutex 是悲观锁还是乐观锁？

答：Mutex是悲观锁

悲观锁：当要对数据库中的一条数据进行修改的时候，为了避免同时被其他人修改，最好的办法就是直接对该数据进行加锁以防止并发。这种借助数据库锁机制，在修改数据之前先锁定，再修改的方式被称之为悲观并发控制【Pessimistic Concurrency Control，缩写"PCC"，又名"悲观锁"】。

乐观锁：乐观锁是相对悲观锁而言的，乐观锁假设数据一般情况不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果冲突，则返回给用户异常信息，让用户决定如何去做。乐观锁适用于读多写少的场景，这样可以提高程序的吞吐量。

Mutex 有几种模式？

sync.Mutex 有两种模式,正常模式和饥饿模式。

正常模式： 等待的 goroutines 按照 FIFO（先进先出）顺序排队，但是 goroutine 被唤醒之后并不能立即得到 mutex 锁，它需要与新到达的 goroutine 争夺 mutex 锁。因为新到达的 goroutine 已经在 CPU上运行了，所以被唤醒的 goroutine 很大概率是争夺 mutex 锁是失败的。出现这样的情况时候，被唤醒goroutine 需要排队在队列的前面。

如果被唤醒的 goroutine 有超过 1ms 没有获取到 mutex 锁，那么它就会变为饥饿模式。在饥饿模式中，mutex 锁直接从解锁的 goroutine 交给队列前面的 goroutine。新达到的 goroutine 也不会去争夺mutex 锁（即使没有锁，也不能去自旋），而是到等待队列尾部排队。正常模式有更好的性能，因为goroutine 可以连续多次获得 mutex 锁。

饥饿模式： 锁的所有权将从 unlock 的 gorutine 直接交给交给等待队列中的第一个。新来的 goroutine将不会尝试去获得锁，即使锁看起来是 unlock 状态,也不会去尝试自旋操作，而是放在等待队列的尾部。 mutex 切换回正常模式的条件：等待队列中的最后一个 goroutine 的等待时间不超过 1ms。饥饿模式能阻止尾部延迟的现象，对于预防队列尾部 goroutine 一致无法获取mutex锁的问题。

八、并发

怎么控制并发数？

第一，有缓冲通道

根据通道中没有数据时读取操作陷入阻塞和通道已满时继续写入操作陷入阻塞的特性，正好实现控制并发数量。

go 复制代码

func main() {
	count := 10 // 最大支持并发
	sum := 100 // 任务总数
	wg := sync.WaitGroup{} //控制主协程等待所有子协程执行完之后再退出。

	c := make(chan struct{}, count) // 控制任务并发的chan
	defer close(c)

	for i:=0; i<sum;i++{
		wg.Add(1)
		c <- struct{}{} // 作用类似于waitgroup.Add(1)
		go func(j int) {
			defer wg.Done()
			fmt.Println(j)
			<- c // 执行完毕，释放资源
		}(i)
	}
	wg.Wait()
}

第二，三方库实现的协程池

panjf2000/ants 或者 Jeffail/tunny

go 复制代码

import (
	"log"
	"time"

	"github.com/Jeffail/tunny"
)
func main() {
	pool := tunny.NewFunc(10, func(i interface{}) interface{} {
		log.Println(i)
		time.Sleep(time.Second)
		return nil
	})
	defer pool.Close()

	for i := 0; i < 500; i++ {
		go pool.Process(i)
	}
	time.Sleep(time.Second * 4)
}

九、GC

常见的垃圾回收算法：

引用计数： 对每个对象维护一个引用计数，当引用该对象的对象被销毁时，引用计数减1，当引用计数器为0时回收该对象。

优点：对象可以很快的被回收，不会出现内存耗尽或达到某个阀值时才回收。

缺点：不能很好的处理循环引用，而且实时维护引用计数，有也一定的代价。

代表语言：Python、PHP

标记-清除： 从根变量开始遍历所有引用的对象，引用的对象标记为"被引用"，没有被标记的进行回收。

优点：解决了引用计数的缺点。

缺点：需要STW，即要暂时停掉程序运行。

代表语言：Golang(其采用三色标记法)

分代收集： 按照对象生命周期长短划分不同的代空间，生命周期长的放入老年代，而短的放入新生代，不同代有不能的回收算法和回收频率。

优点：回收性能好

缺点：算法复杂

代表语言： JAVA

Golang 垃圾回收

STW 解释： Golang 中的 STW（Stop The World）就是停掉所有的 goroutine，专心做垃圾回收，待垃圾回收结束后再恢复 goroutine。 STW 时间的长短直接影响了应用的执行，时间过长对于一些 web 应用来说是不可接受的，这也是广受诟病的原因之一。为了缩短 STW 的时间，Golang 不断优化垃圾回收算法，这种情况得到了很大的改善。 Go 现阶段采用的是通过三色标记清除扫法与混合写屏障 GC策略。其核心优化思路就是尽量使得 STW(Stop The World) 的时间越来越短。

GC 的过程一共分为四个阶段：

栈扫描（STW），所有对象开始都是白色
从 root 开始找到所有可达对象（所有可以找到的对象），标记灰色，放入待处理队列
遍历灰色对象队列，将其引用对象标记为灰色放入待处理队列，自身标记为黑色
清除（并发）循环步骤3 直到灰色队列为空为止，此时所有引用对象都被标记为黑色，所有不可达的对象依然为白色，白色的就是需要进行回收的对象
三色标记法相对于普通标记清除，减少了 STW 时间。这主要得益于标记过程是 "on-the-fly" 的，在标记过程中是不需要 STW 的，它与程序是并发执行的，这就大大缩短了 STW 的时间。

写屏障:

插入屏障，在 A 对象引用 B 对象的时候，B 对象被标记为灰色。(满足强三色不变性) 删除屏障，被删除的对象，如果自身为灰色或者白色，那么被标记为灰色。(满足弱三色不变性)

混合写屏障：

GC 开始将栈上的对象全部扫描并标记为黑色 (之后不再进行第二次重复扫描，无需 STW)， GC 期间，任何在栈上创建的新对象，均为黑色。

被删除的对象标记为灰色。

被添加的对象标记为灰色。

前面说过 STW 目的是防止 GC 扫描时内存变化而停掉 goroutine，而写屏障就是让 goroutine 与 GC 同时运行的手段。虽然写屏障不能完全消除 STW，但是可以大大减少 STW 的时间。

写屏障类似一种开关，在 GC 的特定时机开启，开启后指针传递时会把指针标记，即本轮不回收，下次GC 时再确定。 GC 过程中新分配的内存会被立即标记，用的并不是写屏障技术，也即 GC 过程中分配的内存不会在本轮GC 中回收。

辅助GC(Mutator Assist)

为了防止内存分配过快，在 GC 执行过程中，如果 goroutine 需要分配内存，那么这个 goroutine 会参与一部分 GC 的工作，即帮助 GC 做一部分工作，这个机制叫作 Mutator Assist。

Go 垃圾回收，什么时候触发

1.手动触发，通过调用 runtime.GC 来触发GC，此调用阻塞式地等待当前 GC 运行完毕。 2.内存分配量达到阀值触发 GC

每次内存分配时都会检查当前内存分配量是否已达到阀值，如果达到阀值则立即启动 GC。

阀值 = 上次GC内存分配量 * 内存增长率

内存增长率由环境变量 GOGC 控制，默认为100，即每当内存扩大一倍时启动 GC。

定期触发

默认情况下，最长2分钟触发一次GC，这个间隔在 src/runtime/proc.go:forcegcperiod 变量中被声明：

（参考资料：blog.csdn.net/sumatch/art...

Golang 自学总结（一）

一、基础部分

Go 语言的设计哲学

go语言的值类型和引用类型？

go struct 能不能比较

golang 中 make 和 new 的区别？

for range 的时候它的地址会发生变化么？

rune 类型

反射

反射三定律

调用函数传入结构体时，应该传值还是指针？

Go 的 select 底层数据结构和一些特性？

select 的特性

select 的场景

context 结构是什么样的？context 使用场景和用途？

Go语言中的单引号、双引号和反引号

二、数组和切片

数组和切片的区别

Go 的 slice 底层数据结构和一些特性？

数组是如何实现用下标访问任意元素的

三、map

Go map 的底层实现 ？

hmap：

bmap(bucket)

查找和插入

渐进式扩容

等量扩容

增量扩容

map 是否并发安全？

map 循环是有序的还是无序的？

golang 哪些类型可以作为map key

map取一个key，然后修改这个值，原map数据的值会不会变化

map 中删除一个 key，它的内存会释放么？

nil map 和空 map 有何不同？

四、goroutine

为什么不要大量使用goroutine

多个 goroutine 对同一个 map 写会 panic，异常是否可以用 defer 捕获？

2 个协程交替打印字母和数字

为什么需要协程池？

简单的协程池

优雅关闭Golang中的协程

第一种方式：

第二种方式：

第三种方式

五、channel

channel 的底层实现原理

channel 读写原理

创建channel

向channel写数据

从channel读数据

关闭channel

对已经关闭的channel进行读写操作会发生什么?

读已关闭的channel

写已关闭的通道

关闭已关闭的通道

有缓冲和无缓冲通道 channel

channel的应用场景

六、GPM

M 和 P 的数量问题？

goroutine 的自旋占用资源如何解决

如果 goroutine 一直占用资源，GMP模型怎么解决这个问题

进程、线程、协程有什么区别？

Go 中主协程如何等待其余协程退出?

CPU 占用 100% 如何排查？

七、锁

channel 和锁的对比

Mutex 是悲观锁还是乐观锁？

Mutex 有几种模式？

八、并发

怎么控制并发数？

九、GC

常见的垃圾回收算法：

Golang 垃圾回收

Go 垃圾回收，什么时候触发

Go map 的底层实现？