Golang复习

golang的特点

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

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

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 // 深拷贝
```

使用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]

浅拷贝：

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

实现浅拷贝的方式

引用数据类型默认赋值操作就是浅拷贝：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]

接口

接口是什么

interface 是方法声明的集合
任何类型的对象实现了在interface 中声明的全部方法，则表明该类型实现了该接口
interface可以作为一种数据类型，实现了该接口的任何对象都可以给对应的接口类型变量赋值

举实例，

某种类型可以比较吗

可以比较的数据结构：

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

不可以比较的数据结构：

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

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不允许并发读写
}

环形队列：

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

在这里插入图片描述

等待队列

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

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

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

channel读写过程

创建channel

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

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

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

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

如果等待发送队列sendq不为空，且没有缓冲区，直接从sendq中取出G，把G中数据读出，最后把G唤醒，结束读取过程；
如果等待发送队列sendq不为空，此时说明缓冲区已满，从缓冲区中首部读出数据，把G中数据写入缓冲区尾部，把G唤醒，结束读取过程；
如果等待发送队列sendq为空，但缓冲区中有数据，则从缓冲区取出数据，结束读取过程；
如果等待发送队列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是底层数据的长度
}

Slice的扩容

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

append扩容过程

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

扩容容量规则

1.8版本之前

如果原Slice容量小于1024，则新Slice容量将扩大为原来的2倍；
如果原Slice容量大于等于1024，则新Slice容量将扩大为原来的1.25倍；

上面描述的是一次追加一个元素 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

切片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

如果切片的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

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...
}

一个拥有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的地址
}

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数量

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

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

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

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

渐进式扩容

扩容的前提条件

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

负载因子 > 6.5时，也即平均每个bucket存储的键值对达到6.5个。
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的使用效率更高，进而保证更快的存取

查找过程

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

插入过程

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

无序遍历

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

线程不安全

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

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

使用sync.Mutex进行同步：你可以在每次访问map之前使用sync.Mutex进行加锁和解锁操作，以确保一次只有一个goroutine能够访问map。
```
m = make(map[keyType]valueType)
var mu sync.Mutex
// 在读取或写入map之前加锁
mu.Lock()
m[key] = value
mu.Unlock()
```
使用sync.Map：Go语言提供了sync.Map类型，它是一种并发安全的map实现，可以安全地在多个goroutine之间进行读取和写入操作。
```
var m sync.Map
// 写入数据
m.Store(key, value)
// 读取数据
val, ok := m.Load(key)
```

某种数据类型线程安全吗

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调度流程

创建G：通过go关键字来创建一个goroutine
保存G：新创建的G会先保存在P的本地队列中，如果P的本地队列已经满了就会保存在全局的队列中
唤醒或者新建M：M执行任务进入循环调度
M获取G：M会从P的本地队列获取G来执行，如果P的本地队列为空，则从全局队列获取G，如果全局队列也为空，则会从另一个本地队列偷取一半数量的G（这种从其它P偷取的方式称之为work stealing）
M调度和执行G：M调用G.func()函数执行G，如果M在执行G的过程中发生系统调用阻塞，会阻塞G和M，P会和当前的M解绑，并寻找新的M，如果没有空闲的M就会新建一个M，接管正在阻塞G所属的P，继续执行P中其余的G，这种阻塞后释放P的方式称之为hand off
清理现场：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则会在下次标记时重新分配内存，非常的巧妙