1.golang的源码对象池sync.pool源码解读
2.驳狗屎文"我为什么放弃Go语言
3.golang为什么gc时要管理栈对象?
4.Golang内存管理（一）：堆内存管理
5.Go看源码必会知识之unsafe包
6.golang本地缓存(bigcache/freecache/fastcache等)选型对比及原理总结

golang的对象池sync.pool源码解读

       在编程实践中，对象池sync.pool的解析出现是为了优化频繁创建和销毁对象带来的性能问题。它解决了新对象创建时的源码内存分配和垃圾回收(GC)压力。对象池的解析核心思想是复用已经创建的对象，避免不必要的源码资源消耗。

       对象池的解析手机应用市场源码在哪应用范围广泛，如连接池、源码线程池等，解析它们都是源码通过池化来复用资源，减少创建和销毁的解析开销，提升服务响应速度。源码实际上，解析缓存也是源码类似的概念，通过存储已计算结果，解析减少重复计算，源码加快服务响应。

       go1.版本的对象池原理涉及一个简单的结构体，通过Get和Put函数来管理对象。创建对象池时，需要传入一个创建新对象的函数。池中的对象存储在local数组中，每个goroutine的P都有对应的池，以减少锁竞争。pin和unpin函数用于管理和抢占P，以控制资源的使用。

       在GC过程中，对象池会在每次清理前清空，以防止内存溢出。go1.版本引入了victim cache机制，通过双向链表优化了对象的获取和存储，减少锁竞争，提升性能。

       总结来说，对象池的关键在于复用和预分配，通过技术手段减少创建、减少GC压力，并利用缓存提高响应速度。理解这些原理对于优化程序性能和资源管理至关重要。

驳狗屎文"我为什么放弃Go语言

       此篇文章流传甚广，其实里面没啥干货，而且里面很多观点是有问题的。这个文章在 golang-china 很早就讨论过了。最近因为 Rust 1.0 和 1.1 的发布，导致这个文章又出来毒害读者。所以改缺写了这篇反驳文章，指出其中的问题。有好几次，当我想起来的时候，总是会问自己：我为什么要放弃Go语言？这个决定是正确的吗？是明智和理性的吗？其实我一直在认真思考这个问题。开门见山地说，我当初放弃Go语言（golang），就是因为两个“不爽”：第一，对Go语言本身不爽；第二，对Go语言社区里的某些人不爽。毫无疑问，这是非常主观的结论。但是我有足够详实的客观的论据，用以支撑这个看似主观的结论。文末附有本文更新日志。确实是非常主观的结论，因为里面有不少有问题的观点（用来忽悠Go小白还行）。第0节：我的Go语言经历先说说我的经历吧，以避免被无缘无故地当作Go语言的低级黑。年底，Go语言（golang）第一个公开版本发布，笼罩着“Google公司制造”的光环，吸引了许多慕名而来的尝鲜者，我（Liigo）也身居其中，笼统的看了一些Go语言的资料，学习了基础的教程，因对其语法中的分号和花括号不满，很快就遗忘掉了，没拿它当一回事。在年Go刚发布时，确实是因为“Google公司制造”的光环而吸引了（包括文章作者和诸多IT记者）很多低级的尝鲜者。还好，经过5年的发展，这些纯粹因为光环来的投机者所剩已经不多了（Google趋势）。目前，真正的Go用户早就将Go用于实际的生产了。说到其语法中的分号和花括号不满，我想说这只是你的个人主观感受，还有很多人对Go的分号和花括号很满意，包括水果公司的的Swift的语言设计者也很满意这种风格（Swift中的分号和花括号和Go基本相同）。如果只谈个人主观感受，实现lzo源码我也可以说Rust的fn缩写也很蛋疼！两年之后，年底，Go语言发布1.0的计划被提上日程，相关的报道又多起来，我再次关注它，重新评估之后决定深入参与Go语言。我订阅了其users、nuts、dev、commits等官方邮件组，坚持每天阅读其中的电子邮件，以及开发者提交的每一次源代码更新，给Go提交了许多改进意见，甚至包括修改Go语言编译器源代码直接参与开发任务。如此持续了数月时间。这个到是事实，在 golang-china 有不少吵架的帖子，感兴趣的可以去挖下，我就不展开说了。到年初，核弊辩Go 1.0发布，语言和标准库都已经基本定型，不可能再有大幅改进，我对Go语言未能在1.0定型之前更上一个台阶、实现自我突破，甚至带着诸多明显缺陷走向1.0，感到非常失望，因而逐渐疏远了它（所以Go 1.0之后的事卜漏情我很少关心）。后来看到即将发布的Go 1.1的Release Note，发现语言层面没有太大改变，只是在库和工具层面有所修补和改进，感到它尚在幼年就失去成长的动力，越发失望。外加Go语言社区里的某些人，其中也包括Google公司负责开发Go语言的某些人，其态度、言行，让我极度厌恶，促使我决绝地离弃Go语言。真的不清楚楼主说的可以在 Go1.0 之前短时间内能实现的 重大改进和诸多明显缺陷 是什么。如果是楼主说前面的 其语法中的分号和花括号不满 之类的重大改进，我只能说这只是你的个人主观感受而已，你的很多想法只能说服你自己，没办法说服其他绝大部分人（不要以为像C++或Rust那样什么特性都有就NB了，各种NB特性加到一起只能是 要你命，而绝对不会是什么银弹）。Go 1.1的Release Note，发现语言层面没有太大改变。语言层没有改变是因为 Go1 作出的向后兼容的承诺。对于工业级的语言来说，Go1 这个只能是优点。如果连语言层在每个版本都会出现诸多大幅改进，那谁还敢用Go语言来做生产开发呢（我承认Rust的改动很大胆，但也说明了Rust还处于比较幼稚和任性的阶段）？说 Go语言社区里的某些人固执的观点我是同意的。但是这些固执的人是可以讲道理的，但是他们对于很多东西的要求很高（特别是关于Go的设计哲学部分）。只要你给的建议有依据（语言的设计哲学是另外一回事情），他们绝对不会盲目的拒绝（只是讨论的周期会比较长）。关于楼主提交的给Go文件添加BOM的文章，需要补充说明下。在Go1.0发布的时候，Go语言的源文件(.go)明确要求必须是UTF8编码的，而且是无BOM的UTF8编码的。注意：这个无BOM的UTF8编码的限制仅仅是针对Go语言的源文件(.go)。这个限制并不是说不允许用户处理带BOM的UTF8的txt文件！我觉得对于写Go程序来说，这个限制是没有任何问题的，到目前为止，我还没有使用过带BOM的.go文件。不仅是因为带BOM的.go文件没有太多的意义，而且有很多的缺陷。BOM的原意是用来表示编码是大端还是小端的，主要用于UTF和UTF。对于UTF8来说，BOM没有任何存在的意义（正是Go的2个作者发明了UTF8，彻底解决了全球的编码问题）。但是，在现实中，因为MS的txt记事本，对于中文环境会将txt（甚至是C/C++源文件）当作GBK编码（GBK是个烂编码），为了区别到底是GBK还是UTF8，MS的记事本在前面加了BOM这个垃圾（被GBK占了茅坑），这里的xgboost的源码bom已经不是表示字节序本意了。不知道有没有人用ms的记事本写网页，然后生成一个带bom的utf8网页肯定很有意思。这是MS的记事本的BUG：它不支持生成无BOM的UTF8编码的文本文件！这些是现实存在的带BOM的UTF8编码的文本文件，但是它们肯定都不是Go语言源文件！所以说，Go语言的源文件即使强制限制了无BOM的UTF8编码要求，也是没有任何问题的（而且我还希望有这个限制）。虽然后来Go源文件接受带BOM的UTF8了，但是运行 go fmt 之后，还是会删除掉BOM的（因为BOM就是然并卵）。也就是说带BOM的Go源文件是不符合Go语言的编码风格的，go fmt会强制删除BOM头。前面说了BOM是MS带来的垃圾，但是BOM的UTF8除了然并卵之外还有很多问题，因为BOM在string的开头嵌入了垃圾，导致正则表达式，string的链接运算等操作都被会被BOM这个垃圾所污染。对于.go语言，即使代码完全一样，有BOM和无BOM会导致文件的MD5之类的校验码不同。所以，我觉得Go用户不用纠结BOM这个无关紧要的东西。在上一个年，我（Liigo）在我所属的公司里，深度参与了两个编程语言项目的开发。我想，对于如何判断某个编程语言的优劣，或者说至少对于如何判断某个编程语言是否适合于我自己，我应该还是有一点发言权的。第1节：我为什么对Go语言不爽？Go语言有很多让我不爽之处，这里列出我现在还能记起的其中一部分，排名基本上不分先后。读者们耐心地看完之后，还能淡定地说一句“我不在乎”吗？1.1 不允许左花括号另起一行关于对花括号的摆放，在C语言、C++、Java、C#等社区中，十余年来存在持续争议，从未形成一致意见。在我看来，这本来就是主观倾向很重的抉择，不违反原则不涉及是非的情况下，不应该搞一刀切，让程序员或团队自己选择就足够了。编程语言本身强行限制，把自己的喜好强加给别人，得不偿失。无论倾向于其中任意一种，必然得罪与其对立的一群人。虽然我现在已经习惯了把左花括号放在行尾，但一想到被禁止其他选择，就感到十分不爽。Go语言在这问题上，没有做到“团结一切可以团结的力量”不说，还有意给自己树敌，太失败了。我觉得Go最伟大的发明是 go fmt，从此Go用户不会再有花括弧的位置这种无聊争论了（当然也少了不少灌水和上tiobe排名的机会）。是这优点，Swift语言也使用和Go类似的风格（当然楼主也可能鄙视swift的作者）。1.2 编译器莫名其妙地给行尾加上分号对Go语言本身而言，行尾的分号是可以省略的。但是在其编译器（gc）的实现中，为了方便编译器开发者，却在词法分析阶段强行添加了行尾的分号，反过来又影响到语言规范，对“怎样添加分号”做出特殊规定。这种变态做法前无古人。在左花括号被意外放到下一行行首的情况下，它自动在上一行行尾添加的分号，会导致莫名其妙的编译错误（Go 1.0之前），连它自己都解释不明白。如果实在处理不好分号，干脆不要省略分号得了；或者，Scala和JavaScript的

golang为什么gc时要管理栈对象?

       探索 Golang 内存管理机制，本文基于源码解读，聚焦于垃圾回收的理论与实践。内容涉及触发机制、标记准备、并发标记、标记终止及系统驻留内存清理。通过分析源码，免费源码 2018揭示 Golang 垃圾回收的触发逻辑、标记准备流程、并发标记机制、标记终止处理及内存管理优化策略。

       垃圾回收的触发由多种事件驱动，包括定时触发、对象分配触发及手动触发。定时触发在 GC 守护协程被唤醒后执行，对象分配触发在内存分配达到阈值时触发，手动触发则通过 runtime.GC 调用实现。标记准备阶段启动标记协程，通过 STW 暂停所有用户协程，控制标记协程的 CPU 占用率，并启用写屏障。并发标记阶段，标记协程在唤醒后执行，采用三色标记法，灰对象缓存队列与写屏障协同工作，确保标记过程的效率与并发性。标记终止阶段，内存清扫与下轮 GC 阈值设定完成。系统驻留内存清理进一步优化内存使用，通过异步回收协程实现对空闲内存的动态回收。

       本文深入探讨了 Golang 垃圾回收的各个关键步骤，揭示了其高效、并发和异步管理内存的机制，为读者提供了全面的理解。通过源码走读的方式，本文不仅解释了理论原理，还阐述了实践应用，旨在帮助读者构建对 Golang 内存管理机制的深入认知。

Golang内存管理（一）：堆内存管理

       堆内存管理基于操作系统的虚拟内存管理，了解虚拟内存有助于深入理解堆内存管理。在程序中变量的存储位置分布于全局数据区、栈区和堆区。栈空间的管理由操作系统和运行时环境协同完成，而堆空间的分配与释放则需程序自行管理。本文主要关注堆内存管理，动态申请堆内存通常需调用系统函数。然而，频繁的系统调用带来性能损耗，为解决此问题，内存池技术成为常用解决方案。内存池预先向操作系统申请大量内存，程序可自行管理，带来显著优势，包括减少内存浪费和提升资源利用效率。

       Golang采用内存池架构来管理内存。MSpan描述span的数据结构，MHeap描述堆内存结构体，heapArena描述arena结构体。MCentralMCache与Golang协程调度模型中的P绑定，而非线程，优化内存空间使用，确保每个G使用MCache时不需加锁。Go内存分配流程依赖mallocgc函数，将对象分为三类：Tiny对象分配器针对微对象特殊处理，MCache保存Span Class级别内存块和Tiny存储空间。Golang内存管理引入Tiny空间以避免Size Class = 1的Span造成内存浪费，优化内存分配效率。对象分配逻辑大致如下，具体细节可参考源码。

       相关资源：zhuanlan.zhihu.com/p/...

       draveness.me/golang/doc...

Go看源码必会知识之unsafe包

       前言

       有看源码的朋友应该会发现，Go标准库中大量使用了unsafe.pointer，要想更好的理解源码实现，就要知道unsafe.pointer到底是什么？所以今天就与大家来聊一聊unsafe包。

什么是unsafe

       众所周知，Go语言被设计成一门强类型的静态语言，那么他的类型就不能改变了，静态也是意味着类型检查在运行前就做了。所以在Go语言中是不允许两个指针类型进行转换的，使用过C语言的朋友应该知道这在C语言中是可以实现的，Go中不允许这么使用是处于安全考虑，毕竟强制转型会引起各种各样的麻烦，有时这些麻烦很容易被察觉，有时他们却又隐藏极深，难以察觉。大多数读者可能不明白为什么类型转换是不安全的，这里用C语言举一个简单的例子：

int main(){ double pi = 3.;double *pv = πvoid *temp = pd;int *p = temp;}

       在标准C语言中，任何非void类型的指针都可以和void类型的指针相互指派，也可以通过void类型指针作为中介，实现不同类型的指针间接相互转换。上面示例中，指针pv指向的格子怪兽源码空间本是一个双精度数据，占8个字节，但是经过转换后，p指向的是一个4字节的int类型。这种发生内存截断的设计缺陷会在转换后进行内存访问是存在安全隐患。我想这就是Go语言被设计成强类型语言的原因之一吧。

       虽然类型转换是不安全的，但是在一些特殊场景下，使用了它，可以打破Go的类型和内存安全机制，可以绕过类型系统低效，提高运行效率。所以Go标准库中提供了一个unsafe包，之所以叫这个名字，就是不推荐大家使用，但是不是不能用，如果你掌握的特别好，还是可以实践的。

unsafe 实现原理

       在使用之前我们先来看一下unsafe的源码部分，标准库unsafe包中只提供了3``种方法，分别是:

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr

       Sizeof(x ArbitrayType)方法主要作用是用返回类型x所占据的字节数，但并不包含x所指向的内容的大小，与C语言标准库中的Sizeof()方法功能一样，比如在位机器上，一个指针返回大小就是4字节。

       Offsetof(x ArbitraryType)方法主要作用是返回结构体成员在内存中的位置离结构体起始处(结构体的第一个字段的偏移量都是0)的字节数，即偏移量，我们在注释中看一看到其入参必须是一个结构体，其返回值是一个常量。

       Alignof(x ArbitratyType)的主要作用是返回一个类型的对齐值，也可以叫做对齐系数或者对齐倍数。对齐值是一个和内存对齐有关的值，合理的内存对齐可以提高内存读写的性能。一般对齐值是2^n，最大不会超过8(受内存对齐影响).获取对齐值还可以使用反射包的函数，也就是说：unsafe.Alignof(x)等价于reflect.TypeOf(x).Align()。对于任意类型的变量x，unsafe.Alignof(x)至少为1。对于struct结构体类型的变量x，计算x每一个字段f的unsafe.Alignof(x，f)，unsafe.Alignof(x)等于其中的最大值。对于array数组类型的变量x，unsafe.Alignof(x)等于构成数组的元素类型的对齐倍数。没有任何字段的空struct{ }和没有任何元素的array占据的内存空间大小为0，不同大小为0的变量可能指向同一块地址。

       细心的朋友会发发现这三个方法返回的都是uintptr类型，这个目的就是可以和unsafe.poniter类型相互转换，因为*T是不能计算偏移量的，也不能进行计算，但是uintptr是可以的，所以可以使用uintptr类型进行计算，这样就可以可以访问特定的内存了，达到对不同的内存读写的目的。三个方法的入参都是ArbitraryType类型，代表着任意类型的意思，同时还提供了一个Pointer指针类型，即像void *一样的通用型指针。

type ArbitraryType inttype Pointer *ArbitraryType// uintptr 是一个整数类型，它足够大，可以存储type uintptr uintptr

       上面说了这么多，可能会有点懵，在这里对三种指针类型做一个总结：

       *T：普通类型指针类型，用于传递对象地址，不能进行指针运算。

       unsafe.poniter：通用指针类型，用于转换不同类型的指针，不能进行指针运算，不能读取内存存储的值(需转换到某一类型的普通指针)

       uintptr：用于指针运算，GC不把uintptr当指针，uintptr无法持有对象。uintptr类型的目标会被回收。

       三者关系就是：unsafe.Pointer是桥梁，可以让任意类型的指针实现相互转换，也可以将任意类型的指针转换为uintptr进行指针运算，也就说uintptr是用来与unsafe.Pointer打配合，用于指针运算。画个图表示一下：

       基本原理就说到这里啦，接下来我们一起来看看如何使用~

unsafe.Pointer基本使用

       我们在上一篇分析atomic.Value源码时，看到atomic/value.go中定义了一个ifaceWords结构，其中typ和data字段类型就是unsafe.Poniter，这里使用unsafe.Poniter类型的原因是传入的值就是interface{ }类型，使用unsafe.Pointer强转成ifaceWords类型，这样可以把类型和值都保存了下来，方便后面的写入类型检查。截取部分代码如下：

// ifaceWords is interface{ } internal representation.type ifaceWords struct { typunsafe.Pointer data unsafe.Pointer}// Load returns the value set by the most recent Store.// It returns nil if there has been no call to Store for this Value.func (v *Value) Load() (x interface{ }) { vp := (*ifaceWords)(unsafe.Pointer(v))for { typ := LoadPointer(&vp.typ) // 读取已经存在值的类型/**..... 中间省略**/// First store completed. Check type and overwrite data.if typ != xp.typ { //当前类型与要存入的类型做对比 panic("sync/atomic: store of inconsistently typed value into Value")}}

       上面就是源码中使用unsafe.Pointer的一个例子，有一天当你准备读源码时，unsafe.pointer的使用到处可见。好啦，接下来我们写一个简单的例子，看看unsafe.Pointer是如何使用的。

func main(){ number := 5 pointer := &number fmt.Printf("number:addr:%p, value:%d\n",pointer,*pointer) floatNumber := (*float)(unsafe.Pointer(pointer)) *floatNumber = *floatNumber + 3 fmt.Printf("float:addr:%p, value:%f\n",floatNumber,*floatNumber)}

       运行结果：

number:addr:0xc, value:5float:addr:0xc, value:3.

       由运行可知使用unsafe.Pointer强制类型转换后指针指向的地址是没有改变，只是类型发生了改变。这个例子本身没什么意义，正常项目中也不会这样使用。

       总结一下基本使用：先把*T类型转换成unsafe.Pointer类型，然后在进行强制转换转成你需要的指针类型即可。

Sizeof、Alignof、Offsetof三个函数的基本使用

       先看一个例子：

type User struct { Name string Age uint Gender bool // 男:true 女：false 就是举个例子别吐槽我这么用。。。。}func func_example(){ // sizeof fmt.Println(unsafe.Sizeof(true)) fmt.Println(unsafe.Sizeof(int8(0))) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof("asong")) fmt.Println(unsafe.Sizeof([]int{ 1,3,4})) // Offsetof user := User{ Name: "Asong", Age: ,Gender: true} userNamePointer := unsafe.Pointer(&user) nNamePointer := (*string)(unsafe.Pointer(userNamePointer)) *nNamePointer = "Golang梦工厂" nAgePointer := (*uint)(unsafe.Pointer(uintptr(userNamePointer) + unsafe.Offsetof(user.Age))) *nAgePointer = nGender := (*bool)(unsafe.Pointer(uintptr(userNamePointer)+unsafe.Offsetof(user.Gender))) *nGender = false fmt.Printf("u.Name: %s, u.Age: %d,u.Gender: %v\n", user.Name, user.Age,user.Gender) // Alignof var b bool var i8 int8 var i int var i int var f float var s string var m map[string]string var p *int fmt.Println(unsafe.Alignof(b)) fmt.Println(unsafe.Alignof(i8)) fmt.Println(unsafe.Alignof(i)) fmt.Println(unsafe.Alignof(i)) fmt.Println(unsafe.Alignof(f)) fmt.Println(unsafe.Alignof(s)) fmt.Println(unsafe.Alignof(m)) fmt.Println(unsafe.Alignof(p))}

       为了省事，把三个函数的使用示例放到了一起，首先看sizeof方法，我们可以知道各个类型所占字节大小，这里重点说一下int类型，Go语言中的int类型的具体大小是跟机器的 CPU位数相关的。如果 CPU 是 位的，那么int就占4字节，如果 CPU是位的，那么 int 就占8 字节，这里我的电脑是位的，所以结果就是8字节。

       然后我们在看Offsetof函数，我想要修改结构体中成员变量，第一个成员变量是不需要进行偏移量计算的，直接取出指针后转换为unsafe.pointer，在强制给他转换成字符串类型的指针值即可。如果要修改其他成员变量，需要进行偏移量计算，才可以对其内存地址修改，所以Offsetof方法就可返回成员变量在结构体中的偏移量，也就是返回结构体初始位置到成员变量之间的字节数。看代码时大家应该要住uintptr的使用，不可以用一个临时变量存储uintptr类型，前面我们提到过用于指针运算，GC不把uintptr当指针，uintptr无法持有对象。uintptr类型的目标会被回收，所以你不知道他什么时候会被GC掉，那样接下来的内存操作会发生什么样的错误，咱也不知道。比如这样一个例子：

// 切记不要这样使用p1 := uintptr(userNamePointer)nAgePointer := (*uint)(unsafe.Pointer(p1 + unsafe.Offsetof(user.Age)))

       最后看一下Alignof函数，主要是获取变量的对齐值，除了int、uintptr这些依赖CPU位数的类型，基本类型的对齐值都是固定的，结构体中对齐值取他的成员对齐值的最大值，结构体的对齐涉及到内存对齐，我们在下面详细介绍。

经典应用：string与[]byte的相互转换

       实现string与byte的转换，正常情况下，我们可能会写出这样的标准转换：

// string to []bytestr1 := "Golang梦工厂"by := []byte(s1)// []byte to stringstr2 := string(by)

       使用这种方式进行转换都会涉及底层数值的拷贝，所以想要实现零拷贝，我们可以使用unsafe.Pointer来实现，通过强转换直接完成指针的指向，从而使string和[]byte指向同一个底层数据。在reflect包中有·string和slice对应的结构体，他们的分别是：

type StringHeader struct { Data uintptr Lenint}type SliceHeader struct { Data uintptr Lenint Capint}

       StringHeader代表的是string运行时的表现形式(SliceHeader同理)，通过对比string和slice运行时的表达可以看出，他们只有一个Cap字段不同，所以他们的内存布局是对齐的，所以可以通过unsafe.Pointer进行转换，因为可以写出如下代码：

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr0

       上面的代码我们通过重新构造slice header和string header完成了类型转换，其实[]byte转换成string可以省略掉自己构造StringHeader的方式，直接使用强转就可以，因为string的底层也是[]byte，强转会自动构造，省略后的代码如下：

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr1

       虽然这种方式更高效率，但是不推荐大家使用，前面也提高到了，这要是不安全的，使用当不当会出现极大的隐患，一些严重的情况recover也不能捕获。

内存对齐

       现在计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但是实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就对齐。

       对齐的作用和原因：CPU访问内存时，并不是逐个字节访问，而是以字长（word size)单位访问。比如位的CPU，字长为4字节，那么CPU访问内存的单位也是4字节。这样设计可以减少CPU访问内存的次数，加大CPU访问内存的吞吐量。假设我们需要读取8个字节的数据，一次读取4个字节那么就只需读取2次就可以。内存对齐对实现变量的原子性操作也是有好处的，每次内存访问都是原子的，如果变量的大小不超过字长，那么内存对齐后，对该变量的访问就是原子的，这个特性在并发场景下至关重要。

       我们来看这样一个例子：

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr2

       从结果可以看出，字段放置不同的顺序，占用内存也不一样，这就是因为内存对齐影响了struct的大小，所以有时候合理的字段可以减少内存的开销。下面我们就一起来分析一下内存对齐，首先要明白什么是内存对齐的规则，C语言的对齐规则与Go语言一样，所以C语言的对齐规则对Go同样适用：

       对于结构的各个成员，第一个成员位于偏移为0的位置，结构体第一个成员的偏移量（offset）为0，以后每个成员相对于结构体首地址的 offset 都是该成员大小与有效对齐值中较小那个的整数倍，如有需要编译器会在成员之间加上填充字节。

       除了结构成员需要对齐，结构本身也需要对齐，结构的长度必须是编译器默认的对齐长度和成员中最长类型中最小的数据大小的倍数对齐。

       好啦，知道规则了，我们现在来分析一下上面的例子，根据我的mac使用的位CPU,对齐参数是8来分析，int、[]int、string、bool对齐值分别是4、8、8、1，占用内存大小分别是4、、、1，我们先根据第一条对齐规则分析User1：

       第一个字段类型是int，对齐值是4，大小为4，所以放在内存布局中的第一位.

       第二个字段类型是[]int，对齐值是8，大小为，所以他的内存偏移值必须是8的倍数，所以在当前user1中，就不能从第4位开始了，必须从第5位开始，也就偏移量为8。第4,5,6,7位由编译器进行填充，一般为0值，也称之为空洞。第9位到第位为第二个字段B.

       第三个字段类型是string，对齐值是8，大小为，所以他的内存偏移值必须是8的倍数，因为user1前两个字段就已经排到了第位，所以下一位的偏移量正好是，正好是字段C的对齐值的倍数，不用填充，可以直接排列第三个字段，也就是从第位到位第三个字段C.

       第三个字段类型是bool，对齐值是1，大小为1，所以他的内存偏移值必须是1的倍数，因为user1前两个字段就已经排到了第位，所以下一位的偏移量正好是。正好是字段D的对齐值的倍数，不用填充，可以直接排列到第四个字段，也就是从到第位是第三个字段D.

       好了现在第一条内存对齐规则后，内存长度已经为字节，我们开始使用内存的第2条规则进行对齐。根据第二条规则，默认对齐值是8，字段中最大类型程度是，取最小的那一个，所以求出结构体的对齐值是8，我们目前的内存长度是，不是8的倍数，所以需要补齐，所以最终的结果就是，补了7位。

       说了这么多，画个图看一下吧：

       现在你们应该懂了吧，按照这个思路再去分析其他两个struct吧，这里就不再分析了。

       对于内存对齐这里还有一最后需要注意的知识点，空struct不占用任何存储空间，空 struct{ } 大小为 0，作为其他 struct 的字段时，一般不需要内存对齐。但是有一种情况除外：即当 struct{ } 作为结构体最后一个字段时，需要内存对齐。因为如果有指针指向该字段, 返回的地址将在结构体之外，如果此指针一直存活不释放对应的内存，就会有内存泄露的问题（该内存不因结构体释放而释放）。来看一个例子：

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr3

       简单来说，对于任何占用0大小空间的类型，像struct { }或者[0]byte这些，如果该类型出现在结构体末尾，那么我们就假设它占用1个字节的大小。因此对于test1结构体，他看起来就是这样：`

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr4

       因此在内存对齐时，最后结构体占用的字节就是8了。

       重点要注意的问题：不要在结构体定义的最后添加零大小的类型

总结

       好啦，终于又到文章的末尾了，我们来简单的总结一下，unsafe 包绕过了 Go 的类型系统，达到直接操作内存的目的，使用它有一定的风险性。但是在某些场景下，使用 unsafe 包提供的函数会提升代码的效率，Go 源码中也是大量使用 unsafe 包。

       unsafe 包定义了 Pointer 和三个函数：

type ArbitraryType inttype Pointer *ArbitraryTypefunc Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr

       uintptr 可以和 unsafe.Pointer 进行相互转换，uintptr 可以进行数学运算。这样，通过 uintptr 和 unsafe.Pointer 的结合就解决了 Go 指针不能进行数学运算的限制。通过 unsafe 相关函数，可以获取结构体私有成员的地址，进而对其做进一步的读写操作，突破 Go 的类型安全限制。

       最后我们又学习了内存对齐的知识，这样设计可以减少CPU访问内存的次数，加大CPU访问内存的吞吐量，所以结构体中字段合理的排序可以更节省内存，注意：不要在结构体定义的最后添加零大小的类型。

原文：/post/

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

       创建了一个Golang学习交流群，欢迎各位大佬们踊跃入群，我们一起学习交流。入群方式：加我vx拉你入群，或者公众号获取入群二维码

       结尾给大家发一个小福利吧，最近我在看[微服务架构设计模式]这一本书，讲的很好，自己也收集了一本PDF，有需要的小伙可以到自行下载。获取方式：关注公众号：[Golang梦工厂]，后台回复：[微服务]，即可获取。

       我翻译了一份GIN中文文档，会定期进行维护，有需要的小伙伴后台回复[gin

golang本地缓存(bigcache/freecache/fastcache等)选型对比及原理总结

       以下内容来自腾讯后台研发工程师jayden

       导语：提到本地缓存大家都不陌生，只要是个有点经验的后台开发人员，都知道缓存的作用和弊端。本篇文章我们就来简单聊聊在golang做业务开发的过程中，本地缓存的一些可选的开源方案，分析它们的特点，以及内部的实现原理。

       1.本地缓存需求分析

       首先来梳理一下业务开发过程中经常面临的本地缓存的一些需求。我们一般做缓存就是为了能提高系统的读写性能，缓存的命中率越高，也就意味着缓存的效果越好。其次本地缓存一般都受限于本地内存的大小，所有全量的数据一般存不下。那基于这样的场景一方面是想缓存的数据越多，则命中率理论上也会随着缓存数据的增多而提高；另外一方面是想，既然所有的数据存不下那就想办法利用有限的内存存储有限的数据。这些有限的数据需要是经常访问的，同时有一定时效性(不会频繁改变)的。基于这两个点展开，我们一般对本地缓存会要求其满足支持过期时间、支持淘汰策略。最后再使用自动管理内存的语言例如golang等开发时，还需要考虑在加入本地缓存后引发的GC问题。

       分析完我们日常本地缓存的诉求，再结合我们日常开发用到的golang语言，我们可以提炼得到golang本地缓存组件必须具备以下几个能力：

       分析清楚了我们的需求，也明确了我们需要的能力。那自然优先考虑golang内置的标准库中是否存在这样的组件可以直接使用呢？很遗憾，没有。golang中内置的可以直接用来做本地缓存的无非就是map和sync.Map。而这两者中，map是非并发安全的数据结构，在使用时需要加锁；而sync.Map虽然是线程安全的。但是需要在并发读写时加锁。此外二者均无法支持数据的过期和淘汰，同时在存储大量数据时，又会产生比较频繁的GC问题，更严重的情况下导致线上服务无法稳定运行。

       既然标准库中没有我们满足上述需求的本地缓存组件，那我们就想只有两种解决方案了

       那首先面临的第一个问题就是方案的调研和选型，没有合适的方案时自己再来动手构建。下面我们就来给大家介绍下golang中哪些可以直接来使用的本地缓存组件吧。

       2.golang本地缓存组件概览

       golang中本地缓存方案可选的有如下一些：

       下面通过笔者一段时间的调研和研究，将golang可选的开源本地缓存组件汇总为下表，方便大家在方案选型时作参考。

       在上述方案中，freecache、bigcache、fastcache、ristretto、groupcache这几个大家根据实际的业务场景首选，offheap有定制需求时可考虑。

       通过上表的总结，个人想再此再谈几点关于本地缓存组件的理解：

       （1）上述本地缓存组件中，实现零GC的方案主要就两种：

       a.无GC：分配堆外内存(Mmap)

       b.避免GC：map非指针优化(map[uint]uint)或者采用slice实现一套无指针的map

       c.避免GC：数据存入[]byte slice(可考虑底层采用环形队列封装循环使用空间)

       （2）实现高性能的关键在于：

       a.数据分片(降低锁的粒度)

       3. 主流缓存组件实现原理剖析

       在本节中我们会重点分析下freecache、bigcache、fastcache、offheap这几个组件内部的实现原理。

       3.1 freecache实现原理

       首先分析下freecache的内部实现原理。在freecache中它通过segment来进行对数据分片，freecache内部包含个segment，每个segment维护一把互斥锁，每一条kv数据进来后首先会根据k进行计算其hash值，然后根据hash值决定当前的这条数据落入到哪个segment中。

       对于每个segment而言，它由索引、数据两部分构成。

       索引：其中索引最简单的方式采用map来维护，例如map[uint]uint这种。而freecache并没有采用这种做法，而是通过采用slice来底层实现一套无指针的map，以此避免GC扫描。

       数据：数据采用环形缓冲区来循环使用，底层采用[]byte进行封装实现。数据写入环形缓冲区后，记录写入的位置index作为索引，读取时首先读取数据header信息，然后再读取kv数据。

       在freecache中数据的传递过程是：freecache->segment->(slot,ringbuffer) 下图是freecache的内部实现框架图。

       总结： freecache通过利用数据分片减小锁的粒度，然后再存储时索引并没有采用内置的map来维护而是采用自建map减少指针来避免GC，同时数据存储时采用预先分配内存然后后边循环使用。通过上述两种方法保证了在堆上分配内存同时减少GC对系统性能的影响。

       3.2 bigcache实现原理

       bigcache和freecache类似，也是一个零GC、高性能的cache组件，但是它的实现和freecache还是有些差异，这儿有篇 英文博客介绍bigcache设计原理的，内容稍长感兴趣的可以阅读下，下面我们介绍一下bigcache的实现原理。

       bigcache同样是采用分片的方式构成，一个bigcache对象包含2^n 个cacheShard对象，默认是个。每个cacheShard对象维护着一把sync.RWLock锁(读写锁)。所有的数据会分散到不同的cacheShard中。

       每个cacheShard同样由索引和数据构成。索引采用map[uint]uint来存储，数据采用entry([]byte)环形队列存储。索引中存储的是该条数据在entryBuffer写入的位置pos。每条kv数据按照TLV的格式写入队列。

       不过值得注意的是，和bigcache和freecache不同的一点在于它的环形队列可以自动扩容。同时bigcache中数据的过期是通过全局的时间窗口维护的，每个单独的kv无法设置不同的过期时间。

       下面是bigcache的内容实现原理框架图。

       总结：bigcache思路和freecache大体相同，只不过在索引存储时更为巧妙，直接采用内置的map结构加上基础数据类型来实现。同时底层存储数据的队列也可以根据空间大小来决定是否扩容。唯一的缺陷是无法针对每个key进行设置不同的过期时间。这个个人认为如果想用bigcache同时想要这个特性，可以进行二次开发一下。

       通过 性能测试数据来看，bigcache性能要比freecache稍微好一点。大家可以思考下他们性能的差异可能会在哪里呢？

       3.3 fastcache实现原理

       本节介绍下fastcache的实现原理，根据fastcache官方文档介绍，它的灵感来自于bigcache。所以整体的思路和bigcache很类似，数据通过bucket进行分片。fastcache由个bucket构成。每个bucket维护一把读写锁。在bucket内部数据同理是索引、数据两部分构成。索引用map[uint]uint存储。数据采用chunks二维的切片(二维数组)存储。不过值得注意的是fastcache有一个很大的特性是，它的内存分配是在堆外分配的，而不是在堆上分配的。堆外分配的内存。这样做也就避免了golang GC的影响。下图是fastcache内部实现框架图。

       总结： fastcache一方面充分利用了分片来降低锁的粒度，另一方面在索引存储时采用了对map的优化，同时在分配内存时，直接从堆外申请内存，自己实现了分配和释放内存的逻辑。通过上述手段使得GC的影响降到了最低。fastcache唯一的缺陷是官方提供的版本没有提供针对kv数据的过期时间这个特性。所以如果需要这个特性的话，需要自己动手二次开发。整体从性能上来看是比bigcache和freecache都更优。

       3.4 offheap实现原理

       本节介绍下offheap的相关内容，offheap其实功能就比较简单了，就是一个基于堆外内存构建的哈希表。它通过直接调用系统调用函数来分配内存。然后在内部通过数组来实现哈希表。实现过程中当发生哈希冲突时，它是采用探测法来解决。由于是在堆外分配的内存上构建的哈希表。导致它的GC开销非常的小。下图是offheap的内部实现框架图。

       总结：offheap内部由于是采用探测法解决哈希冲突的，所以当哈希冲突严重时数据删除、查询都会带来非常复杂的处理流程。而且性能也会有一些损耗。可以作为学习和研究的项目还是非常不错的。

       4.总结

       本文主要从日常需求出发，分析了日常业务过程中对本地缓存的需求，再调研了业界可选的一些组件并进行了对比，希望对本地缓存选型上起到一些参考和帮助。最后再对其中比较重要的几个组件如freecache、bigcache、fastcache、offheap等做了内部实现的简单介绍。上述内容只是从架构层面展开介绍，后续有时间再从源码层面做一些分析。由于篇幅限制本篇内容并未对map、sync.Map、go-cache、groupcache进行介绍。感兴趣的读者可以自行搜索资料进行阅读。如果大致理解了上述原理的童鞋也可以自己动手实践起来，造个轮子看看。

       5.参考资料

       欢迎点赞分享，关注 @鹅厂架构师，一起探索更多业界领先产品技术。