【导入hadoop源码】【便签贴源码】【grafana源码结构】golang 源码分析

时间:2024-11-28 19:45:53 来源:黄金宝塔线指标源码 分类:综合

1.Golang学习——error和创建error源码解析
2.golang源码系列---手把手带你看list实现
3.golang map 源码解读(8问)
4.golang chan 最详细原理剖析,源码全面源码分析!分析看完不可能不懂的源码!
5.浅析源码 golang kafka sarama包(一)如何生产消息以及通过docker部署kafka集群with kraft
6.golang context的分析使用和源码分析

golang 源码分析

Golang学习——error和创建error源码解析

       Golang中的错误处理与Java或Python有着显著的不同。它没有类似于try...catch的源码结构来处理错误,这种处理方式在编程界引起了争议。分析导入hadoop源码正确且优雅地处理错误是源码值得深入研究的话题。

       本文将对Golang中的分析错误概念和错误创建方法进行解析,同时解读源码,源码帮助读者更好地理解和运用。分析

       一. 初识error

       在Golang中,源码错误被定义为`error`类型,分析它是源码标准库中的一个接口类型。`error`类型包含一个`Error()`方法,分析返回一个字符串描述,源码使得任何实现该接口的类型都可以作为错误使用。

       `error`值可以被存储在变量中,也可以从函数中返回。`error`为`nil`时,表示没有错误发生。

       1. 什么是error

       错误是指在业务过程中出现的问题,如打开文件失败,这类情况在预期之中。而异常则指的是不应该出现的问题却发生了,这类情况在预期之外。

       错误是业务流程的一部分,而异常不是。`error`可以被视为一种类型,类似于`int`或`float`等。

       2. error源码

       在`src/builtin/builtin.go`文件中,定义了`error`接口和相关实现。

       `error`接口包含一个`Error()`方法,该方法返回描述错误的字符串。任何实现了`Error()`方法的类型都可以作为错误使用。

       记住,`error`为`nil`表示没有错误。

       二. error创建

       错误在Golang中可以通过两种方式创建:

       1. errors.New()函数

       在`src/errors/errors.go`文件中,定义了`errors.New()`函数,该函数接受一个字符串参数,返回一个`error`对象。

       `New()`函数创建一个错误,其格式为给定的文本。即使文本相同,每次调用`New()`也会返回不同的错误值。

       错误值使用一个结构体`errorString`表示,包含一个`string`类型字段`s`,并实现了一个`Error()`方法。

       实战

       实例中,使用`errors.New()`创建了一个错误对象。

       输出显示了错误对象的类型为`errorString`指针,前面的`errors.`表明了其来自`errors`包。

       更具体的信息

       在某些情况下,可能需要更具体的信息来描述错误,此时可以使用`fmt.Errorf()`函数。

       2. fmt.Errorf()函数

       `fmt.Errorf()`函数用于将字符串格式化,并添加上下文信息,以更精确地描述错误。便签贴源码

       实战

       实例中,通过`fmt.Errorf()`创建了一个带有上下文信息的错误对象。

       输出显示了错误对象的类型为`*errors.errorString`,同时包含具体错误编码``。

       疑问解答

       疑惑在于为什么`fmt.Errorf()`创建的错误对象类型也是`*errors.errorString`,实际上,这与`p.wrappedErr`字段有关。

       通过源码分析,可以理解`p.wrappedErr`是`pp`结构体的一个字段,当格式化错误字符串中不包含`%w`占位符时,该字段为`nil`。

       `fmt.wrapError`类型源自于当`p.wrappedErr`不为`nil`时,所执行的代码逻辑。这个类型是通过`wrapError`结构体实现的,它包含两个字段,并实现了两个方法。

       至此,我们了解了Golang中错误的创建方式及其背后的原理。通过`errors.New()`和`fmt.Errorf()`函数,开发者可以有效地创建和处理错误,从而实现更健壮的代码。

golang源码系列---手把手带你看list实现

       本文提供Golang源码中双向链表实现的详细解析。

       双向链表结构包含头节点对象root和链表长度,无需遍历获取长度,链表节点额外设指针指向链表,方便信息获取。

       创建双向链表使用`list.New`函数,初始化链表。

       `Init`方法可初始化或清空链表,链表结构内含占位头结点。

       `Len`方法返回链表长度,由结构体字段存储,无需遍历。

       `Front`与`Back`分别获取头结点和尾结点。

       `InsertBefore`与`InsertAfter`方法在指定节点前后插入新节点,底层调用`insertValue`实现。

       `PushFront`与`PushBack`方法分别在链表头部和尾部插入新节点。

       `MoveToBack`与`MoveToFront`内部调用`move`方法,将节点移动至特定位置。

       `MoveBefore`与`MoveAfter`将节点移动至指定节点前后。

       `PushBackList`与`PushFrontList`方法分别在链表尾部或头部插入其他链表节点。

       例如,原始链表A1 - A2 - A3与链表B1 - B2 - B3,`PushFrontList`结果为B1 - B2 - B3 - A1 - A2 - A3,`PushBackList`结果为A1 - A2 - A3 - B1 - B2 - B3。

golang map 源码解读(8问)

       map底层数据结构为hmap,包含以下几个关键部分:

       1. buckets - 指向桶数组的指针,存储键值对。

       2. count - 记录key的数量。

       3. B - 桶的数量的对数值,用于计算增量扩容。

       4. noverflow - 溢出桶的数量,用于等量扩容。

       5. hash0 - hash随机值,增加hash值的随机性,减少碰撞。grafana源码结构

       6. oldbuckets - 扩容过程中的旧桶指针,判断桶是否在扩容中。

       7. nevacuate - 扩容进度值,小于此值的已经完成扩容。

       8. flags - 标记位,用于迭代或写操作时检测并发场景。

       每个桶数据结构bmap包含8个key和8个value,以及8个tophash值,用于第一次比对。

       overflow指向下一个桶,桶与桶形成链表存储key-value。

       结构示意图在此。

       map的初始化分为3种,具体调用的函数根据map的初始长度确定:

       1. makemap_small - 当长度不大于8时,只创建hmap,不初始化buckets。

       2. makemap - 当长度参数为int时,底层调用makemap。

       3. makemap - 初始化hash0,计算对数B,并初始化buckets。

       map查询底层调用mapaccess1或mapaccess2,前者无key是否存在的bool值,后者有。

       查询过程:计算key的hash值,与低B位取&确定桶位置,获取tophash值,比对tophash,相同则比对key,获得value,否则继续寻找,直至返回0值。

       map新增调用mapassign,步骤包括计算hash值,确定桶位置,比对tophash和key值,插入元素。

       map的扩容有两种情况:当count/B大于6.5时进行增量扩容,容量翻倍,渐进式完成,每次最多2个bucket;当count/B小于6.5且noverflow大于时进行等量扩容,容量不变,但分配新bucket数组。

       map删除元素通过mapdelete实现,查找key,计算hash,找到桶,遍历元素比对tophash和key,找到后置key,value为nil,修改tophash为1。

       map遍历是无序的,依赖mapiterinit和mapiternext,选择一个bucket和offset进行随机遍历。

       在迭代过程中,可以通过修改元素的key,value为nil,设置tophash为1来删除元素,rpm解压源码不会影响遍历的顺序。

golang chan 最详细原理剖析,全面源码分析!看完不可能不懂的!

       大纲

       概述

       chan 是 golang 的核心结构,是与其他高级语言区别的显著特色之一,也是 goroutine 通信的关键要素。尽管广泛使用,但对其深入理解的人却不多。本文将从源码编译器的视角,全面剖析 channel 的用法。

       channel 的本质

       从实现角度来看,golang 的 channel 实质上是环形队列(ringbuffer)的实现。我们将 chan 称为管理结构,channel 中可以放置任何类型的对象,称为元素。

       channel 的使用方法

       我们从 channel 的使用方式入手,详细介绍 channel 的使用方法。

       channel 的创建

       创建 channel 时,用户通常有两种选择:创建带有缓冲区和不带缓冲区的 channel。这对应于 runtime/chan.go 文件中的 makechan 函数。

       channel 入队

       用户使用姿势:对应函数实现为 chansend,位于 runtime/chan.go 文件。

       channel 出队

       用户使用姿势:对应函数分别是 chanrecv1 和 chanrecv2,位于 runtime/chan.go 文件。

       结合 select 语句

       用户使用姿势:对应函数实现为 selectnbsend,位于 runtime/chan.go 文件中。

       结合 for-range 语句

       用户使用姿势:对应使用函数 chanrecv2,位于 runtime/chan.go 文件中。

       源码解析

       以上,我们通过宏观的用户使用姿势,了解了不同使用姿势对应的不同实现函数,接下来将详细分析这些函数的实现。

       makechan 函数

       负责 channel 的创建。在 go 程序中,当我们写类似 v := make(chan int) 的初始化语句时,就会调用不同类型对应的初始化函数,其中 channel 的初始化函数就是 makechen。

       runtime.makechan

       定义原型:

       通过这个,我们可以了解到,声明创建一个 channel 实际上是得到了一个 hchan 的指针,因此 channel 的核心结构就是基于 hchan 实现的。

       其中,t 参数指定元素类型,size 指定 channel 缓冲区槽位数量。如果是带缓冲区的 channel,那么 size 就是槽位数;如果没有指定,那么就是 0。

       makechan 函数执行了以下两件事:

       1. 参数校验:主要是越界或 limit 的校验。

       2. 初始化 hchan:分为三种情况:

       所以,我们看到除了 hchan 结构体本身的内存分配,该结构体初始化的关键在于四个字段:

       hchan 结构

       makechan 函数负责创建了 chan 的核心结构-hchan,接下来我们将详细分析 hchan 结构体本身。

       在 makechan 中,初始化时实际上只初始化了四个核心字段:

       我们使用 channel 时知道,channel 常常会因为两种情况而阻塞:1)投递时没有空间;2)取出时还没有元素。秘鲁传说源码

       从以上描述来看,就涉及到 goroutine 阻塞和 goroutine 唤醒,这个功能与 recvq,sendq 这两个字段有关。

       waitq 类型实际上是一个双向列表的实现,与 linux 中的 LIST 实现非常相似。

       chansend 函数

       chansend 函数是在编译器解析到 c <- x 这样的代码时插入的,本质上就是把一个用户元素投递到 hchan 的 ringbuffer 中。chansend 调用时,一般用户会遇到两种情况:

       接下来,我们看看 chansend 究竟做了什么。

       当我们在 golang 中执行 c <- x 这样的代码,意图将一个元素投递到 channel 时,实际上调用的是 chansend 函数。这个函数分几个场景来处理,总结来说:

       关于返回值:chansend 返回值标明元素是否成功入队,成功则返回 true,否则 false。

       select 的提前揭秘:

       golang 源代码经过编译会变成类似如下:

       而 selectnbasend 只是一个代理:

       小结:没错,chansend 功能就是这么简单,本质上就是一句话:将元素投递到 channel 中。

       chanrecv 函数

       对应的 golang 语句是 <- c。该函数实现了 channel 的元素出队功能。举个例子,编译对应一般如下:

       golang 语句:

       对应:

       golang 语句(这次的区别在于是否有返回值):

       对应:

       编译器在遇到 <- c 和 v, ok := <- c 的语句时,会换成对应的 chanrecv1,chanrecv2 函数,这两个函数本质上都是一个简单的封装,元素出队的实现函数是 chanrecv,我们详细分析这个函数。

       chanrecv 函数的返回值有两个值,selected,received,其中 selected 一般作为 select 结合的函数返回值,指明是否要进入 select-case 的代码分支,received 表明是否从队列中成功获取到元素,有几种情况:

       selectnbsend 函数

       该函数是 c <- v 结合到 select 时的函数,我们使用 select 的 case 里面如果是一个 chan 的表达式,那么编译器会转换成对应的 selectnbsend 函数,如下:

       对应编译函数逻辑如下:

       selectnbsend 本质上也就是个 chansend 的封装:

       chansend 的内部逻辑上面已经详细说明过,唯一不同的就是 block 参数被赋值为 false,也就是说,在 ringbuffer 没有空间的情况下也不会阻塞,直接返回。划重点:chan 在这里不会切走执行权限。

       selectnbrecv 函数

       该函数是 v := <- c 结合到 select 时的函数,我们使用 select 的 case 里面如果是一个 chan 的表达式,那么编译器会转换成对应的 selectnbsrecv 函数,如下:

       对应编译函数逻辑如下:

       selectnbrecv 本质上也就是个 chanrecv 的封装:

       chanrecv 的内部逻辑上面已经详细说明过,在 ringbuffer 没有元素的情况下也不会阻塞,直接返回。这里不会因此而切走调度权限。

       selectnbrecv2 函数

       该函数是 v, ok = <- c 结合到 select 时的函数,我们使用 select 的 case 里面如果是一个 chan 的表达式,那么编译器会转换成对应的 selectnbrecv2 函数,如下:

       对应编译函数逻辑如下:

       selectnbrecv2 本质上是个 chanrecv 的封装,只不过返回值不一样而已:

       chanrecv 的内部逻辑上面已经详细说明过,在 ringbuffer 没有元素的情况下也不会阻塞,直接返回。这里不会因此而切走调度权限。selectnbrecv2 与 selectnbrecv 函数的不同之处在于还有一个 ok 参数指明是否获取到了元素。

       chanrecv2 函数

       chan 可以与 for-range 结合使用,编译器会识别这种语法。如下:

       这个本质上是个 for 循环,我们知道 for 循环关键是拆分成三个部分:初始化、条件判断、条件递进。

       那么在我们 for-range 和 chan 结合起来之后,这三个关键因素又是怎么理解的呢?简述如下:

       init 初始化:无

       condition 条件判断:

       increment 条件递进:无

       当编译器遇到上面 chan 结合 for-range 写法时,会转换成 chanrecv2 的函数调用。目的是从 channel 中出队元素,返回值为 received。首先看下 chanrecv2 的实现:

       chan 结合 for-range 编译之后的伪代码如下:

       划重点:从这个实现中,我们可以获取一个非常重要的信息,for-range 和 chan 的结束条件只有这个 chan 被 close 了,否则一直会处于这个死循环内部。为什么?注意看 chanrecv 接收的参数是 block=true,并且这个 for-range 是一个死循环,除非 chanrecv2 返回值为 false,才有可能跳出循环,而 chanrecv2 在 block=true 场景下返回值为 false 的唯一原因只有:这个 chan 是 close 状态。

       总结

       golang 的 chan 使用非常简单,这些简单的语法糖背后其实都是对应了相应的函数实现,这个翻译由编译器来完成。深入理解这些函数的实现,对于彻底理解 chan 的使用和限制条件是必不可少的。深入理解原理,知其然知其所以然,你才能随心所欲地使用 golang。

浅析源码 golang kafka sarama包(一)如何生产消息以及通过docker部署kafka集群with kraft

       本文将深入探讨Golang中使用sarama包进行Kafka消息生产的过程,以及如何通过Docker部署Kafka集群采用Kraft模式。首先,我们关注数据的生产部分。

       在部署Kafka集群时,我们将选择Kraft而非Zookeeper,通过docker-compose实现。集群中,理解LISTENERS的含义至关重要,主要有几个类型:

       Sarama在每个topic和partition下,会为数据传输创建独立的goroutine。生产者操作的起点是创建简单生产者的方法,接着维护局部处理器并根据topic创建topicProducer。

       在newBrokerProducer中,run()方法和bridge的匿名函数是关键。它们反映了goroutine间的巧妙桥接,通过channel在不同线程间传递信息,体现了goroutine使用的精髓。

       真正发送消息的过程发生在AsyncProduce方法中,这是数据在三层协程中传输的环节,虽然深度适中,但需要仔细理解。

       sarama的架构清晰,但数据传输的核心操作隐藏在第三层goroutine中。输出变量的使用也有讲究:当output = p.bridge,它作为连接内外协程的桥梁;output = nil则关闭channel,output = bridge时允许写入。

golang context的使用和源码分析

       context是golang的标准库,用于在多个goroutine之间传递上下文信息,方便进行协调与通信。通过context,可以实现goroutine之间的取消操作、数据传递等功能。

       context的使用相对简单,主要接口包括Background()、TODO()、WithCancel、WithDeadline、WithTimeout、WithValue等。在需要传递context的goroutine中,可调用这些接口生成相应的context。

       WithCancel、WithDeadline、WithTimeout接口均用于协调goroutine间的操作,返回CancelFunc函数,用于取消context。使用时需调用cancel()函数来取消context。通过select ctx.Done()可判断context是否取消。

       WithValue接口用于在goroutine间传递key-value数据。获取数据时,会从当前context逐级向上查找,直至找到父context为止。

       context内部结构设计精巧,包含cancel类与value类。cancel类通过propagateCancel()函数建立与parent context的关系,使用Done()与cancel()方法进行context的取消操作。value类用于在goroutine间传递数据,实现层级查找与数据传递。

       深入源码分析,可以更好地理解context的内部机制与实现细节。通过官方文档与相关代码解析资料,可以深入了解context的原理与实践应用。

Golang源码剖析panic与recover,看不懂你打我好了

       哈喽,大家好,我是asong,今天与大家来聊一聊go语言中的"throw、try.....catch{ }"。如果你之前是一名java程序员,我相信你一定吐槽过go语言错误处理方式,但是这篇文章不是来讨论好坏的,我们本文的重点是带着大家看一看panic与recover是如何实现的。上一文我们讲解了defer是如何实现的,但是没有讲解与defer紧密相连的recover,想搞懂panic与recover的实现也没那么简单,就放到这一篇来讲解了。废话不多说,直接开整。

       Go 语言中panic 关键字主要用于主动抛出异常,类似 java 等语言中的 throw 关键字。panic 能够改变程序的控制流,调用 panic 后会立刻停止执行当前函数的剩余代码,并在当前 Goroutine 中递归执行调用方的 defer;

       Go 语言中recover 关键字主要用于捕获异常,让程序回到正常状态,类似 java 等语言中的 try ... catch 。recover 可以中止 panic 造成的程序崩溃。它是一个只能在 defer 中发挥作用的函数,在其他作用域中调用不会发挥作用;

       recover只能在defer中使用这个在标准库的注释中已经写明白了,我们可以看一下:

       这里有一个要注意的点就是recover必须要要在defer函数中使用,否则无法阻止panic。最好的验证方法是先写两个例子:

       运行我们会发现example2()方法的panic是没有被recover住的,导致整个程序直接crash了。这里大家肯定会有疑问,为什么直接写recover()就不能阻止panic了呢。我们在 详解defer实现机制(附上三道面试题,我不信你们都能做对)讲解了defer实现原理,一个重要的知识点**defer将语句放入到栈中时,也会将相关的值拷贝同时入栈。**所以defer recover()这种写法在放入defer栈中时就已经被执行过了,panic是发生在之后,所以根本无法阻止住panic。

       通过运行结果可以看出panic不会影响defer函数的使用,所以他是安全的。

       这里我开了两个协程,一个协程会发生panic,导致程序崩溃,但是只会执行自己所在Goroutine的延迟函数,所以正好验证了多个 Goroutine 之间没有太多的关联,一个 Goroutine 在 panic 时也不应该执行其他 Goroutine 的延迟函数。

       其实我们在实际项目开发中,经常会遇到panic问题, Go 的 runtime 代码中很多地方都调用了 panic 函数,对于不了解 Go 底层实现的新人来说,这无疑是挖了一堆深坑。我们在实际生产环境中总会出现panic,但是我们的程序仍能正常运行,这是因为我们的框架已经做了recover,他已经为我们兜住底,比如gin,我们看一看他是怎么做的。

       我们先来写个简单的代码,看看他的汇编调用:执行go tool compile -N -l -S main.go就可以看到对应的汇编码了,我们截取部分片段分析:

       上面重点部分就是画红线的三处,第一步调用runtime.deferprocStack创建defer对象,这一步大家可能会有疑惑,我上一文忘记讲个这个了,这里先简单概括一下,defer总共有三种模型,编译一个函数里只会有一种defer模式。在讲defer实现机制时,我们一起看过defer的结构,其中有一个字段就是_panic,是触发defer的作用,我们来看看的panic的结构:

       简单介绍一下上面的字段:

       上面的pc、sp、goexit我们单独讲一下,runtime包中有一个Goexit方法,Goext能够终止调用它的goroutine,其他的goroutine是不受影响的,goexit也会在终止goroutine之前运行所有延迟调用函数,Goexit不是一个panic,所以这些延迟函数中的任何recover调用都将返回nil。如果我们在主函数中调用了Goexit会终止该goroutine但不会返回func main。由于func main没有返回,因此程序将继续执行其他gorountine,直到所有其他goroutine退出,程序才会crash。

       下面就开始我们的重点吧~。

       在讲defer实现机制时,我们一起看过defer的结构,其中有一个字段就是_panic,是触发defer的作用,我们来看看的panic的结构:简单介绍一下上面的字段:上面的pc、sp、goexit我们单独讲一下,runtime包中有一个Goexit方法,Goext能够终止调用它的goroutine,其他的goroutine是不受影响的,goexit也会在终止goroutine之前运行所有延迟调用函数,Goexit不是一个panic,所以这些延迟函数中的任何recover调用都将返回nil。如果我们在主函数中调用了Goexit会终止该goroutine但不会返回func main。由于func main没有返回,因此程序将继续执行其他gorountine,直到所有其他goroutine退出,程序才会crash。写个简单的例子:运行上面的例子你就会发现,即使在主goroutine中调用了runtime.Goexit,其他goroutine是没有任何影响的。所以结构中的pc、sp、goexit三个字段都是为了修复runtime.Goexit,这三个字段就是为了保证该函数的一定会生效,因为如果在defer中发生panic,那么goexit函数就会被取消,所以才有了这三个字段做保护。看这个例子:

       英语好的可以看一看这个: github.com/golang/go/is...,这就是上面的一个例子,这里就不过多解释了,了解就好。

       接下来我们再来看一看gopanic方法。

       gopanic的代码有点长,我们一点一点来分析:

       根据不同的类型判断当前发生panic错误,这里没什么多说的,接着往下看。

       上面的代码都是截段,这些部分都是为了判断当前defer是否可以使用开发编码模式,具体怎么操作的就不展开了。

       在第三部分进行defer内联优化选择时会执行调用延迟函数(reflectcall就是这个作用),也就是会调用runtime.gorecover把recoverd = true,具体这个函数的操作留在下面讲,因为runtime.gorecover函数并不包含恢复程序的逻辑,程序的恢复是在gopanic中执行的。先看一下代码:

       这段代码有点长,主要就是分为两部分:

       第一部分主要是这个判断if gp._panic != nil && gp._panic.goexit && gp._panic.aborted { ... },正常recover是会绕过Goexit的,所以为了解决这个,添加了这个判断,这样就可以保证Goexit也会被recover住,这里是通过从runtime._panic中取出了程序计数器pc和栈指针sp并且调用runtime.recovery函数触发goroutine的调度,调度之前会准备好 sp、pc 以及函数的返回值。

       第二部分主要是做panic的recover,这也与上面的流程基本差不多,他是从runtime._defer中取出了程序计数器pc和栈指针sp并调用recovery函数触发Goroutine,跳转到recovery函数是通过runtime.call进行的,我们看一下其源码(src/runtime/asm_amd.s 行):

       因为go语言中的runtime环境是有自己的堆栈和goroutine,recovery函数也是在runtime环境执行的,所以要调度到m->g0来执行recovery函数,我们在看一下recovery函数:

       在recovery 函数中,利用 g 中的两个状态码回溯栈指针 sp 并恢复程序计数器 pc 到调度器中,并调用 gogo 重新调度 g , goroutine 继续执行,recovery在调度过程中会将函数的返回值设置为1。这个有什么作用呢? 在deferproc函数中找到了答案:

       当延迟函数中recover了一个panic时,就会返回1,当 runtime.deferproc 函数的返回值是 1 时,编译器生成的代码会直接跳转到调用方函数返回之前并执行 runtime.deferreturn,跳转到runtime.deferturn函数之后,程序就已经从panic恢复了正常的逻辑。

       在这里runtime.fatalpanic实现了无法被恢复的程序崩溃,它在中止程序之前会通过 runtime.printpanics 打印出全部的 panic 消息以及调用时传入的参数。

       这就是这个逻辑流程,累死我了。。。。

       结尾给大家发一个小福利,哈哈,这个福利就是如果避免出现panic,要注意这些:这几个是比较典型的,还有很多会发生panic的地方,交给你们自行学习吧~。

       好啦,这篇文章就到这里啦,素质三连(分享、点赞、在看)都是笔者持续创作更多优质内容的动力!