go基础知识归纳总结

无缓冲的 channel 和有缓冲的 channel 的区别？

在 Go 语言中，channel 是用来在 goroutines 之间传递数据的主要机制。它们有两种类型：无缓冲的 channel 和有缓冲的 channel。

1. 无缓冲的 channel

行为：无缓冲的 channel 是一种同步的通信方式，发送和接收必须同时发生。如果一个 goroutine 试图通过无缓冲 channel 发送数据，它会阻塞，直到另一个 goroutine 从该 channel 中接收数据。反之亦然，接收方在准备好接收数据之前，发送方无法继续执行。

用法：适合在两个 goroutines 之间实现精确的同步，确保它们在同一时刻传递数据。

优点：

保证了发送和接收的同步，可以避免某些类型的并发错误。

更简单，适合需要严格按顺序处理任务的场景。

缺点：

性能上可能存在瓶颈，因为必须等待对应的发送或接收操作才能继续执行。
无缓冲的 Channel 示例

package main

import (
	"fmt"
	"time"
)

func main() {
	// 创建一个无缓冲的 channel
	ch := make(chan int)

	// 启动一个 goroutine 来接收数据
	go func() {
		// 接收数据之前会阻塞，直到 main goroutine 发送数据
		val := <-ch
		fmt.Println("接收到的数据:", val)
	}()

	// 模拟一些操作
	time.Sleep(1 * time.Second)

	// 发送数据到 channel，会阻塞直到接收方读取数据
	ch <- 42

	fmt.Println("数据已发送")
}

由于是无缓冲的 channel，main goroutine 在发送 42 时会阻塞，直到 goroutine 从 channel 中接收到这个值，程序才会继续执行。

2. 有缓冲的 channel

行为：有缓冲的 channel 容许在 channel 中存储一定数量的数据元素，发送方可以在 channel 未满时继续发送数据，而无需等待接收方。接收方只有当 channel 非空时才会接收数据。

用法：适合发送方和接收方的处理速度不一致的情况，允许发送方先发送一部分数据，接收方稍后接收。

优点：

提供了一定的并发灵活性，发送方可以在接收方未准备好时先发送一定数量的数据。

提高了性能，减少了因为同步阻塞而导致的性能损耗。

缺点：

如果缓冲区设计不当，可能会出现缓冲区溢出或浪费资源的情况。

由于有缓冲的存在，可能会导致发送和接收之间的时间不同步，增加调试和排查问题的难度。

总结

无缓冲的 channel 强调的是同步性，适合需要严格同步的场景。
有缓冲的 channel 提供更多的灵活性，允许在并发处理中有更大的自由度，不需要完全同步。

在使用中，可以根据具体场景选择合适的 channel 类型。例如，在生产者-消费者模型中，有缓冲的 channel 可以防止生产者等待消费者处理；而在需要精确同步的任务中，无缓冲 channel 则更加合适。
有缓冲的 Channel 示例

package main

import (
	"fmt"
	"time"
)

func main() {
	// 创建一个带有缓冲区大小为 2 的 channel
	ch := make(chan int, 2)

	// 发送两个数据到 channel
	ch <- 1
	fmt.Println("发送了数据 1")
	ch <- 2
	fmt.Println("发送了数据 2")

	// 此时，由于缓冲区还有空间，发送不会阻塞
	go func() {
		// 延迟读取，模拟一些操作
		time.Sleep(2 * time.Second)
		val := <-ch
		fmt.Println("接收到的数据:", val)
	}()

	// 继续发送数据
	time.Sleep(1 * time.Second)
	ch <- 3
	fmt.Println("发送了数据 3")

	// 接收数据
	time.Sleep(2 * time.Second)
	val := <-ch
	fmt.Println("接收到的数据:", val)
}

这里的 channel 有缓冲区大小为 2，因此前两个 ch <- 操作不会阻塞，因为缓冲区有足够空间。第三次发送数据时，如果缓冲区已满，发送方会阻塞，直到接收方读取数据并释放空间。

channel和select底层数据结构是怎样的？

Go 中 select 语句的底层实现涉及多个关键数据结构和调度机制，主要是为了高效地处理通道（channel）操作和 Goroutine 调度。我们可以从 Go 语言的源代码中窥探其底层数据结构。以下是 select 相关的几个重要底层数据结构和其如何与通道和 Goroutine 协同工作：

1. Goroutine 和 P 结构
   Go 的并发模型基于 Goroutine 和 M
   调度模型。每个 select 语句本质上都会涉及到 Goroutine 的阻塞与唤醒。调度器的核心数据结构包括：
   Goroutine（G）：代表一个执行中的协程，每个 Goroutine 都包含了当前执行状态、栈信息等。当某个 select 语句阻塞 Goroutine 时，Goroutine 会被挂起，并与通道关联。
   P（Processor）：代表一个运行 Goroutine 的处理器，它与 OS 线程（M）配合使用，管理并调度多个 Goroutine。
   当某个 select 语句涉及到通道的操作时，如果通道未就绪，当前 Goroutine 会被放入通道的等待队列中，并挂起，直到被调度器唤醒。
2. 通道（Channel）结构
   通道的底层结构非常重要，因为 select 语句的核心在于处理通道操作。通道的内部结构如下

type hchan struct {
    qcount   uint           // 通道中已经存在的数据个数
    dataqsiz uint           // 环形队列的大小
    buf      unsafe.Pointer // 环形队列的指针
    elemsize uint16         // 每个元素的大小
    closed   uint32         // 通道是否关闭
    sendx    uint           // 发送操作的索引
    recvx    uint           // 接收操作的索引
    recvq    waitq          // 等待接收的 Goroutine 队列
    sendq    waitq          // 等待发送的 Goroutine 队列
}

recvq/sendq：表示接收和发送操作等待的 Goroutine 队列。当 select 语句中有对通道的接收或发送操作时，如果通道未就绪，当前 Goroutine 会被加入相应的等待队列。

3. SelectCase 结构
   Go 运行时使用一个名为 SelectCase 的数据结构来表示 select 语句中的每个 case，每个 SelectCase 代表一个通道操作。该结构体中记录了每个 case 中的通道、操作类型（发送或接收）以及相关的数据指针等。

type scase struct {
    c    *hchan         // 指向通道的指针
    kind uint16         // 操作类型（发送、接收）
    pc   uintptr        // 程序计数器，用于跟踪执行位置
    elem unsafe.Pointer // 数据元素的指针，用于发送或接收操作
}

c：指向通道的指针，表示这个 case 监听哪个通道。

kind：表示操作类型，是发送、接收还是默认 case。

elem：存储数据的指针，用于发送或接收操作时的存取。

4. Select 语句的执行流程
   当 Goroutine 执行一个 select 语句时，Go 运行时会执行以下操作：
   初始化 scase 列表：首先，select 语句会初始化每个通道操作，生成一个 scase 列表来表示所有的 case。
   检测是否有就绪通道：然后，运行时会遍历这些 scase，检测是否有通道已经就绪（比如是否有数据可接收，或者通道是否可以发送数据）。如果有通道就绪，立刻执行相应的操作，并返回。
   阻塞等待：如果所有通道都未就绪，当前 Goroutine 会挂起并加入到每个通道的等待队列中。此时，通道内部的 recvq 或 sendq 队列会保存当前 Goroutine 的相关信息，当通道状态发生变化时，这些队列会被唤醒，调度器会重新调度等待的 Goroutine 。
   随机选择通道：当有多个通道同时就绪时，Go 运行时通过随机函数来选择一个通道执行，保证公平性。
5. 调度器与 select
   Go 调度器通过一组全局的队列和局部队列来管理 Goroutine 的运行状态。在 select 语句中，阻塞的 Goroutine 会被挂起到通道的等待队列中，但它们仍然保留在全局或局部队列中。当通道状态发生变化（如通道中有数据），调度器会从队列中唤醒相关的 Goroutine 并将其重新加入执行队列。
6. select 的公平性和随机性
   Go 在 select 中实现了对多个通道操作的随机选择机制，避免某些通道操作被长期饿死。具体来说，当有多个通道同时就绪时，Go 会打乱 scase 列表的顺序，并随机选择一个通道进行处理。这确保了 select 的公平性，即使多个 Goroutine 同时监听同一组通道，也不会导致某个通道长期得不到处理。
   select 的核心数据结构总结

Goroutine (G)：Goroutine 是 select 语句中的执行单元，当一个 select 阻塞时，当前 Goroutine 会挂起。

hchan：通道是核心数据结构，负责管理发送和接收操作，recvq 和 sendq 队列保存了等待通道操作的 Goroutine。

scase：select 语句中每个通道操作的表示，存储了通道的指针、操作类型等信息。

调度器：Go 调度器负责管理 Goroutine 的执行和状态，当 select 语句涉及到阻塞操作时，调度器会将 Goroutine 挂起并重新调度。

通过这些底层机制，Go 的 select 语句能够高效地在并发场景下处理多个通道操作，并且在多个通道就绪时提供随机选择的公平性保障。