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 会被放入通道的等待队列中,并挂起,直到被调度器唤醒。
  1. 通道(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 会被加入相应的等待队列。

  1. SelectCase 结构
    Go 运行时使用一个名为 SelectCase 的数据结构来表示 select 语句中的每个 case,每个 SelectCase 代表一个通道操作。该结构体中记录了每个 case 中的通道、操作类型(发送或接收)以及相关的数据指针等。
type scase struct {
    c    *hchan         // 指向通道的指针
    kind uint16         // 操作类型(发送、接收)
    pc   uintptr        // 程序计数器,用于跟踪执行位置
    elem unsafe.Pointer // 数据元素的指针,用于发送或接收操作
}

c:指向通道的指针,表示这个 case 监听哪个通道。
kind:表示操作类型,是发送、接收还是默认 case。
elem:存储数据的指针,用于发送或接收操作时的存取。

  1. Select 语句的执行流程
    当 Goroutine 执行一个 select 语句时,Go 运行时会执行以下操作:
    初始化 scase 列表:首先,select 语句会初始化每个通道操作,生成一个 scase 列表来表示所有的 case。
    检测是否有就绪通道:然后,运行时会遍历这些 scase,检测是否有通道已经就绪(比如是否有数据可接收,或者通道是否可以发送数据)。如果有通道就绪,立刻执行相应的操作,并返回。
    阻塞等待:如果所有通道都未就绪,当前 Goroutine 会挂起并加入到每个通道的等待队列中。此时,通道内部的 recvq 或 sendq 队列会保存当前 Goroutine 的相关信息,当通道状态发生变化时,这些队列会被唤醒,调度器会重新调度等待的 Goroutine 。
    随机选择通道:当有多个通道同时就绪时,Go 运行时通过随机函数来选择一个通道执行,保证公平性。
  2. 调度器与 select
    Go 调度器通过一组全局的队列和局部队列来管理 Goroutine 的运行状态。在 select 语句中,阻塞的 Goroutine 会被挂起到通道的等待队列中,但它们仍然保留在全局或局部队列中。当通道状态发生变化(如通道中有数据),调度器会从队列中唤醒相关的 Goroutine 并将其重新加入执行队列。
  3. 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 语句能够高效地在并发场景下处理多个通道操作,并且在多个通道就绪时提供随机选择的公平性保障。

你可能感兴趣的:(golang,开发语言,后端)