Golang复习

golang的特点

• 自动垃圾回收

  自动垃圾收集明显比 Java 或 Python 更有效，因为它与程序同时执行

• 更丰富的内置类型

• 函数多返回值

• 并发编程

  Golang 针对并发进行了优化，并且在规模上运行良好

• 错误处理

  使用返回值的形式让调用者进行错误处理

golang数据类型

基本数据类型（值类型）

• 布尔类型

• 数字类型

  • 整型

    根据有符号分为：有符号、无符号类型；

    根据占据的空间分为：8，16，32，64；

  • 浮点型

    float32：32位浮点型数；float64：64位浮点型数；

    complex64：32位实数和虚数；complex128：64位实数和虚数；

  • 其他

    byte：类似于uint8，代表了 ASCII 码的一个字符

    rune：类似于int32，表示的是一个 Unicode字符

    uint：长度取决于 CPU，如果是32位CPU就是4个字节，如果是64位就是8个字节

    uintptr：无符号整型，用于存放一个指针

• 字符串类型

• 数组类型

• 结构体类型

引用数据类型

• 指针类型

• Channel类型

• 切片类型

• Map类型

• 函数类型

• 接口类型

make和new

他们都是分配内存空间的内置函数

make

• make 用于创建切片、映射和通道（slice、map、channel）等引用类型的数据结构。

• 它返回一个已初始化并且可以使用的引用类型变量，通常用于创建动态大小的数据结构。

new

• new 主要用于创建值类型的变量，如结构体、整数、浮点数等，而不是引用类型。

• new 用于创建并返回一个指向新分配的零值的指针。

浅拷贝，深拷贝

深拷贝：

拷贝的是数据本身，创造一个新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值

实现深拷贝的方式：

• 值类型：对于 Go 中的基本数据类型（如整数、浮点数、字符串、结构体，数组等），赋值或传递参数时会进行深拷贝。这意味着创建一个新的值，而不是共享数据。

  a := 10
  b := a // 深拷贝
  
  arr1 := [3]int{1, 2, 3}
  arr2 := arr1 // 深拷贝
  1
  2
  3
  4
  5

• 使用copy赋值的数据是深拷贝

  slice1 := []int{1, 2, 3}
  slice2 := []int{0, 0, 0}
  copy(slice2, slice1)
  slice2[0] = 10
  fmt.Printf("slice1:%v\n", slice1)	//slice1:[1 2 3]
  fmt.Printf("slice2:%v\n", slice2)	//slice2:[10 2 3]
  1
  2
  3
  4
  5
  6

浅拷贝：

拷贝的是数据地址，只复制指向的对 象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也会变化

实现浅拷贝的方式

• 引用数据类型默认赋值操作就是浅拷贝：slice2 := slice1

  arr1 := []int{1, 2, 3}
  arr2 := arr1 // 浅拷贝
  arr2[0] = 100
  fmt.Printf("slice1:%v\n", arr1)	//slice1:[100 2 3]
  fmt.Printf("slice2:%v\n", arr2)	//slice2:[100 2 3]
  1
  2
  3
  4
  5

接口

接口是什么

1. interface 是方法声明的集合

2. 任何类型的对象实现了在interface 中声明的全部方法，则表明该类型实现了该接口

3. interface可以作为一种数据类型，实现了该接口的任何对象都可以给对应的接口类型变量赋值

举实例，

某种类型可以比较吗

可以比较的数据结构：

1. 基本数据类型：整数（int、int8、int16、int32、int64）、浮点数（float32、float64）、复数（complex64、complex128）、布尔值（bool）、字符串（string）等基本类型都可以进行比较
2. 数组：数组是值类型，如果数组的元素类型是可比较的，则整个数组可以进行比较。例如，[3]int 和 [3]int 可以进行比较
3. 结构体：结构体是用户自定义的复合数据类型，如果结构体的字段都是可比较的，则结构体可以进行比较
4. 指针：指针类型可以进行比较，但比较的是指针的地址值
5. 接口：接口类型可以进行比较，但比较的是接口的动态类型和动态值。只有当这两个变量的动态类型和动态值都相等的时候，才是相等的
6. 通道：通道类型是可比较类型。当一个通道值被赋给另一个通道值后，这两个通道值将共享相同的底层部分。 换句话说，这两个通道引用着同一个底层的内部通道对象。 比较这两个通道的结果为true

不可以比较的数据结构：

1. 切片：切片是引用类型，不能直接进行比较。你可以比较切片是否为nil，但不能比较两个切片的内容是否相同
2. 映射：映射也是引用类型，不能直接进行比较。你可以比较映射是否为nil，但不能比较两个映射的内容是否相同
3. 函数：函数类型不能进行比较

channel

channel主要用于进程内各goroutine间的通信

数据结构

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不允许并发读写
}
1
2
3
4
5
6
7
8
9
10
11
12
13

环形队列：

环形队列作为其缓冲区，队列长度是创建channel时候指定的

等待队列

从channel读数据，如果channel缓冲区为空或者没有缓冲区，当前goroutine会被阻塞。
向channel写数据，如果channel缓冲区已满或者没有缓冲区，当前goroutine会被阻塞。

被阻塞的goroutine将会挂在channel的等待队列中：

• 因读阻塞的goroutine会被向channel写入数据的goroutine唤醒；
• 因写阻塞的goroutine会被从channel读数据的goroutine唤醒；

channel读写过程

创建channel

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

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

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

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

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

关闭channel会发生什么

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

特点：

• 关闭通道后，已经在通道中的数据仍然可以被读取，直到通道中的数据全部被读取完毕。之后再次去读取，读取操作将不会阻塞，而是立即返回其元素类型的零值
• 关闭通道后，向管道中写数据会发生panic

channel缓冲区的特点

同步与非同步：

无缓冲的 channel 是同步的，有缓冲的 channel 是非同步的，缓冲满时发送阻塞

channel无缓冲时，发送阻塞直到数据被接收，接收阻塞直到读到数据；
channel有缓冲时，当缓冲满时发送阻塞，当缓冲空时接收阻塞。

nil：

如果给一个nil的 channel 发送数据，会造成永远阻塞。
如果从一个nil的 channel 中接收数据，会造成永久阻塞。

panic：

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

进程，线程，协程的区别

• 进程：进程是具有一定独立功能的程序，进程是系统资源分配和调度的最小单位。每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。
• 线程：线程是进程的一个实体,线程是内核态,而且是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。
• 协程：协程是一种用户态的轻量级线程，协程的调度完全是由用户来控制的。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

切片

数据结构

Slice依托数组实现，底层数组对用户屏蔽，在底层数组容量不足时可以实现自动重分配并生成新的Slice。

type slice struct {
    array unsafe.Pointer	//array指向底层数组
    len   int				//len代表切片长度
    cap   int				//cap是底层数据的长度
}
1
2
3
4
5

Slice的扩容

• 使用append向Slice追加元素时，如果Slice空间不足，将会触发Slice扩容，扩容实际上是重新分配一块更大的内存，将原Slice数据拷贝进新Slice，然后返回新Slice，扩容后再将数据追加进去。
• 扩容操作只关心容量，会把原Slice数据拷贝到新Slice，追加数据由append在扩容结束后完成

append扩容过程

1. 假如Slice容量够用，则将新元素追加进去，Slice.len++，返回原Slice
2. 原Slice容量不够，则将Slice先扩容，扩容后得到新Slice
3. 将新元素追加进新Slice，Slice.len++，返回新的Slice。

扩容容量规则

1.8版本之前

• 首先判断，如果新申请容量大于 2 倍的旧容量，最终容量就是新申请的容量
• 否则判断，如果旧切片的长度小于 1024，则最终容量就是旧容量的两倍
• 否则判断，如果旧切片长度大于等于 1024，则最终容量从旧容量开始循环增加原来的 1/4, 直到最终容量大于等于新申请的容量
• 如果最终容量计算值溢出，则最终容量就是新申请容量

上面描述的是一次追加一个元素 append(a,1)，如果是一次追加多个元素append(a,1,2,3)，容量扩容到大于切片长度的最小的偶数

a := make([]int, 0)
a = append(a, 1, 2, 3, 4, 5)
fmt.Printf("len(a):%v,cap(a):%v\n", len(a), cap(a)) 
//len(a):5,cap(a):6
1
2
3
4

切片append之后还跟原来的一样吗

切片添加追加一个元素之后，如果切片的cap不会发生扩容，那么底层指向的还是原来的那个数组

// 情况一：切片扩容后仍然指向原数组
originalSlice := make([]int, 0, 5)
originalSlice = append(originalSlice, 1)
originalSlice = append(originalSlice, 2)
originalSlice = append(originalSlice, 3)

modifiedSlice := originalSlice

// 添加元素到切片
modifiedSlice = append(modifiedSlice, 4)

fmt.Println("Original Slice:", originalSlice)
fmt.Println("Modified Slice:", modifiedSlice)
fmt.Printf("Original Slice Address: %p\n", &originalSlice[0])
fmt.Printf("Modified Slice Address: %p\n", &modifiedSlice[0])

//运行结果
//Original Slice: [1 2 3]
//Modified Slice: [1 2 3 4]
//Original Slice Address: 0xc00000e390
//Modified Slice Address: 0xc00000e390
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

如果切片的cap发生扩容，那么底层指向的已经不是原来那个数组，而是对数组进行了拷贝

originalSlice := make([]int, 0, 2)
originalSlice = append(originalSlice, 1)
originalSlice = append(originalSlice, 2)

modifiedSlice := originalSlice

// 添加元素到切片
modifiedSlice = append(modifiedSlice, 3)

fmt.Println("Original Slice:", originalSlice)
fmt.Println("Modified Slice:", modifiedSlice)
fmt.Printf("Original Slice Address: %p\n", &originalSlice[0])
fmt.Printf("Modified Slice Address: %p\n", &modifiedSlice[0])

//运行结果
//Original Slice: [1 2]
//Modified Slice: [1 2 3]
//Original Slice Address: 0xc00001c0c0
//Modified Slice Address: 0xc0000141e0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Slice线程不安全

Slice底层结构并没有使用加锁等方式，不支持并发读写，所以并不是线程安全的，使用多个goroutine 对类型为 slice 的变量进行操作，每次输出的值大概率都不会一样，与预期值不一致；slice在并发执行中不会报错，但是数据会丢失

map

数据结构

hmap

Golang的map使用哈希表作为底层实现，一个哈希表里可以有多个哈希表节点，也即bucket，而每个bucket就保存了map中的一个或一组键值对。

type hmap struct {
    count     int // 当前保存的元素个数
    ...
    B         uint8
    ...
    buckets    unsafe.Pointer // bucket数组指针，数组的大小为2^B
    ...
}
1
2
3
4
5
6
7
8

一个拥有4个bucket的map：

bucket

type bmap struct {
    tophash [8]uint8 //存储哈希值的高8位
    data    byte[1]  //key value数据:key/key/key/.../value/value/value...
    overflow *bmap   //溢出bucket的地址
}
1
2
3
4
5

• tophash：是长度为8的数组，哈希值低位相同的键存入当前bucket时，会将哈希值的高位存放到该数组中，以方便后续匹配

• data区存放的是key-value数据，存放顺序是key/key/key/…value/value/value，如此存放是为了节省字节对齐带来的空间浪费。

• overflow 指针指向的是下一个bucket，据此将所有冲突的键连接起来。

哈希冲突

当有两个或以上数量的键被哈希到了同一个bucket时，我们称这些键发生了冲突

Go使用链地址法来解决键冲突。由于每个bucket可以存放8个键值对，所以同一个bucket存放超过8个键值对时就会再创建一个键值对，用类似链表的方式将bucket连接起来。

bucket数据结构指示下一个bucket的指针称为overflow bucket，意为当前bucket盛不下而溢出的部分。事实上哈希冲突并不是好事情，它降低了存取效率

负载因子

负载因子用于衡量一个哈希表冲突情况，公式为：

负载因子 = 键数量/bucket数量
1

例如，对于一个bucket数量为4，包含4个键值对的哈希表来说，这个哈希表的负载因子为1

哈希表需要将负载因子控制在合适的大小，超过其阀值需要进行rehash，也即键值对重新组织：

• 哈希因子过小，说明空间利用率低
• 哈希因子过大，说明冲突严重，存取效率低

每个哈希表的实现对负载因子容忍程度不同，比如Redis实现中负载因子大于1时就会触发rehash，而Go则在在负载因子达到6.5时才会触发rehash，因为Redis的每个bucket只能存1个键值对，而Go的bucket可能存8个键值对，所以Go可以容忍更高的负载因子。

渐进式扩容

扩容的前提条件

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

1. 负载因子 > 6.5时，也即平均每个bucket存储的键值对达到6.5个。
2. overflow数量 > 2^15时，也即overflow数量超过32768时。

增量扩容

• 当负载因子过大时，就先建一个bucket，新的bucket长度时原来的2倍，然后将旧的bucket数据搬迁到新的bucket
• 考虑到map可能存储数以亿计的key-value，一次搬迁将会造成比较大的延时，go采用逐步搬迁策略，每次访问map时都会触发一次搬迁，每次搬迁2个键值对
• hmap数据结构中oldbuckets成员指身原bucket，而buckets指向了新申请的bucket。新的键值对被插入新的bucket中。后续对map的访问操作会触发迁移，将oldbuckets中的键值对逐步的搬迁过来。当oldbuckets中的键值对全部搬迁完毕后，删除oldbuckets。
• 数据搬迁过程中原bucket中的键值对将存在于新bucket的前面，新插入的键值对将存在于新bucket的后面。

等量扩容

所谓的等量扩容并不是扩大容量。buckets数量不变，重新做一遍类似于增量扩容的搬迁动作，把松散的键值对重新排列一次，使得bucket的使用效率更高，进而保证更快的存取

查找过程

1. 根据key值算出哈希值
2. 取哈希值低位与hmap.B取模确定bucket位置
3. 取哈希值高位在tophash数组中查询
4. 如果tophash[i]中存储值也哈希值相等，则去找到该bucket中的key值进行比较
5. 当前bucket没有找到，则继续从下个overflow的bucket中查找。
6. 如果当前处于搬迁过程，则优先从oldbuckets查找

插入过程

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

无序遍历

map在遍历时，并不是从固定的0号bucket开始遍历的，每次遍历，都会从一个随机值序号的bucket，然后再从该桶中随机选择一个单元格（cell）开始遍历

线程不安全

在Go语言中，普通的map（即map数据类型）是非线程安全的。这意味着在多个goroutine之间并发访问和修改同一个map时，可能会导致竞态条件和未定义的行为。

为了在多线程或多goroutine环境中安全地使用map，你有以下几种选项：

1. 使用sync.Mutex进行同步：你可以在每次访问map之前使用sync.Mutex进行加锁和解锁操作，以确保一次只有一个goroutine能够访问map。

   m = make(map[keyType]valueType)
   var mu sync.Mutex
   // 在读取或写入map之前加锁
   mu.Lock()
   m[key] = value
   mu.Unlock()
   1
   2
   3
   4
   5
   6

2. 使用sync.Map：Go语言提供了sync.Map类型，它是一种并发安全的map实现，可以安全地在多个goroutine之间进行读取和写入操作。

   var m sync.Map
   // 写入数据
   m.Store(key, value)
   // 读取数据
   val, ok := m.Load(key)
   1
   2
   3
   4
   5

某种数据类型线程安全吗

GMP调度

G、M、P分别是什么，分别有多少数量

• G（Goroutine）：即Go协程，每个go关键字都会创建一个协程。
• M（Machine）：工作线程，在Go中称为Machine，数量对应真实的CPU数（真正干活的对象）。
• P（Processor）：处理器（Go中定义的一个摡念，非CPU），包含运行Go代码的必要资源，用来调度 G 和 M 之间的关联关系，其数量可通过 GOMAXPROCS() 来设置，默认为核心数。

M必须拥有P才可以执行G中的代码，P含有一个包含多个G的队列，P可以调度G交由M执行。

数量，调度过程：P维护调度（注意专业词汇）（了解G的生命周期）

GMP调度流程

1. 创建G：通过go关键字来创建一个goroutine
2. 保存G：新创建的G会先保存在P的本地队列中，如果P的本地队列已经满了就会保存在全局的队列中
3. 唤醒或者新建M：M执行任务进入循环调度
4. M获取G：M会从P的本地队列获取G来执行，如果P的本地队列为空，则从全局队列获取G，如果全局队列也为空，则会从另一个本地队列偷取一半数量的G（这种从其它P偷取的方式称之为work stealing）
5. M调度和执行G：M调用G.func()函数执行G，如果M在执行G的过程中发生系统调用阻塞，会阻塞G和M，P会和当前的M解绑，并寻找新的M，如果没有空闲的M就会新建一个M，接管正在阻塞G所属的P，继续执行P中其余的G，这种阻塞后释放P的方式称之为hand off
6. 清理现场：M执行完G之后，清理现场，重新进入调度循环，（将M上运行的goroutine切换为G0，G0负责调度时候协程的切换）

垃圾回收机制

垃圾回收算法

• 引用计数：对每个对象维护一个引用计数，当引用该对象的对象被销毁时，引用计数减1，当引用计数器为0时回收该对象。
  • 优点：对象可以很快地被回收，不会出现内存耗尽或达到某个阀值时才回收。
  • 缺点：不能很好地处理循环引用，而且实时维护引用计数，也有一定的代价。
  • 代表语言：Python、PHP、Swift
• 标记-清除：从根变量开始遍历所有引用的对象，引用的对象标记为”被引用”，没有被标记的进行回收。
  • 优点：解决了引用计数的缺点。
  • 缺点：需要STW，即要暂时停掉程序运行。
  • 代表语言：Golang（其采用三色标记法）
• 分代收集：按照对象生命周期长短划分不同的代空间，生命周期长的放入老年代，而短的放入新生代，不同代有不同的回收算法和回收频率。
  • 优点：回收性能好
  • 缺点：算法复杂
  • 代表语言： JAVA

Golang垃圾回收原理

内存标记

• span区域中，位图allocBits表示每个内存块的分配情况（已被分配的内存块标记为1，未被分配的内存块标记0），位图gcmarkBits用于标记内存块被引用情况（已被对象引用的内存块标记为1，未被对象引用的内存块标记0）
• allocBits和gcmarkBits数据结构是完全一样的，标记结束就是内存回收，回收时将allocBits指向gcmarkBits，则代表标记过的才是存活的，gcmarkBits则会在下次标记时重新分配内存，非常的巧妙

三色标记法的三种状态

• 灰色：对象还在标记队列中等待
• 黑色：对象已被标记，gcmarkBits对应的位为1，该对象不会再本次GC中被清除
• 白色：对象未被标记，gcmarkBits对应的位为0，该对象将会再本次GC中被清除

三色标记的过程

1. 每次新创建的对象，默认的颜色都是标记为白色
2. 每次GC回收开始，会从根节点开始遍历所有对象，把遍历到的对象从白色集合放入灰色集合中
3. 遍历灰色集合，将灰色对象引用的对象从白色集合中放入灰色集合，并将此灰色对象放入黑色集合
4. 重复上一个步骤，直到灰色对象中没有任何对象
5. 回收所有的白色对象

缺点是需要STW，程序出现卡顿

屏障机制

插入写屏障（对象被引用时触发的机制）：

不存在黑色对象引用到白色对象，当黑色节点新增了白色节点的引用时，将对应的白色节点改为灰色（满足强三色不变式）

删除写屏障（对象被引用时触发的机制）：

黑色节点允许引用白色节点，但是该白色节点有其他灰色节点间接的引用（满足弱三色不变式）

混合写屏障

1. GC开始将栈上的对象全部扫描并标记为黑色
2. GC期间，任何在栈上创建的新对象，均为黑色。
3. 被删除的对象标记为灰色。
4. 被添加的对象标记为灰色。

满足弱三色不变式

总结

GoV1.3- 普通标记清除法，整体过程需要启动STW，效率极低。

GoV1.5- 三色标记法， 堆空间启动写屏障，栈空间不启动，全部扫描之后，需要重新扫描一次栈(需要STW)，效率普通

GoV1.8-三色标记法，混合写屏障机制， 栈空间不启动，堆空间启动。整个过程几乎不需要STW（在标记准备每个栈单独暂停），效率较高

defer

defer语句用于延迟函数的调用，每次defer都会把一个函数压入栈中，函数返回前再把延迟的函数取出并执行。

特点

• 延迟函数的参数在defer语句出现时就已经确定下来了
• 延迟函数执行按后进先出顺序执行，即先出现的defer最后执行
• 延迟函数可能操作主函数的具名返回值

使用场景

• 释放资源：关闭数据库连接，关闭文件
• 流程控制
• 异常处理
• 与recover配合，消除panic

defer recover painc执行顺序

error

错误处理：

可预测，不可预测，panic（执行过程，里面涉及到recover）