1.一起用Go做一个小游戏（上）
2.Go看源码必会知识之unsafe包
3.Go 并发实战--sync Cond
4.《实战：centos上安装Go软件》-2022.4.28
5.Go的战斗执行原理以及Go的命令
6.游戏服务端开源引擎GoWorld教程——（1）安装和运行

一起用Go做一个小游戏（上）

       最近偶然看到一个Go语言库，口号喊出“一个超级简单（dead simple）的游戏源码游戏源码2D游戏引擎”，好奇点开了它的对战官网。

       官网上已经有很多可以在线体验的战斗小游戏了（利用WASM技术）。例如曾经风靡一时的游戏源码游戏源码：

       当然只要安装了Go，我们也键入下面的对战代源码共享命令本地运行这个游戏：

       还有童年《俄罗斯方块》：

       有年左右让无数人疯狂的《Flappy Bird》（或许称为Flappy Gopher更贴切一点 ）：

       这些瞬间让我产生了极大的兴趣。简单浏览一下文档，战斗整体感觉下来，游戏源码游戏源码虽然与成熟的对战游戏引擎（如Cocos2dx，DirectX，战斗Unity3d等）相比，游戏源码游戏源码ebiten功能还不算丰富。对战但是战斗麻雀虽小，五脏俱全。游戏源码游戏源码ebiten的对战API设计比较简单，使用也很方便，即使对于新手也可以在1-2个小时内掌握，并开发出一款简单的游戏。更妙的是，Go语言让ebitengine实现了跨平台！

       接下来的3篇文章，我会介绍ebitengine这个库。对于游戏引擎来说，只介绍它的API用法似乎有点纸上谈兵。恰好我想起之前看到一个《外星人入侵》的小游戏，刚好可以拿来练手。那请大家坐稳扶好，我们出发咯。

       安装

       ebitengine 要求Go版本 >= 1.。使用go module下载这个包：

       显示窗口

       游戏开发第一步是将游戏窗口显示出来，并且能在窗口上显示一些文字。先看代码：

       使用命令go run运行该程序：

       我们会看到一个窗口，标题为外星人入侵，并且左上角显示了文字Hello，World：

       现在我们来分析使用ebiten开发的游戏程序的结构。

       首先，ebiten引擎运行时要求传入一个游戏对象，该对象的必须实现ebiten.Game这个接口：

       ebiten.Game接口定义了ebiten游戏需要的3个方法：Update,Draw和Layout。

       在main函数中，

       设置游戏窗口的大小。

       而

       设置窗口标题，标题显示在窗口的左上角。

       一切准备就绪，创建一个Game对象，调用ebiten.RunGame()运行。是不是很简单？

       处理输入

       没有交互的游戏不是真的游戏！下面我们来监听键盘的输入，当前只处理3个键：左方向←，右方向→和空格。

       ebiten提供函数IsKeyPressed来判断某个键是否按下，同时内置了多个键的常量定义，见源码keys.go文件。ebiten.KeyLeft表示左方向键，ebiten.KeyRight表示右方向键，ebiten.KeySpace表示空格。

       为了代码清晰，我们定义一个Input结构来处理输入：

       Game结构中添加一个Input类型的字段，并且为了方便新增NewGame方法用于创建Game对象：

       Game结构的Update方法中，我们需要调用Input的Update方法触发按键的判断：

       Game的Draw方法中将显示Input的msg字段：

       将main函数中创建Game对象的方式修改如下：

       使用go run命令运行：

       窗口与前一个例子相同，然而我们可以在窗口上按←→和空格，观察控制台输出：

       设置背景

       黑色背景看起来有些无趣，我们现在就来换一个背景。

       ebiten.Image定义了一个名为Fill的方法，可以传入一个颜色对象color.RGBA，将背景填充为特定颜色。Draw函数的参数为*ebiten.Image类型，它表示的是屏幕对象，ebitengine引擎最终会将screen显示出来，故填充它的背景即可修改窗口的背景。代码中我们将背景颜色修改为灰色(R:,G:,B:)。

       注意：由于每帧都会调用Draw方法刷新屏幕内容，所以每次调用都需要填充背景。抖音权重查询 接口源码

       运行结果如下：

       第一次重构

       目前为止，我们的实现了显示窗口和处理输入的功能。我们先分析一下目前的程序有哪些问题： 所有逻辑都堆在一个文件中，修改不便 逻辑中直接出现字面值，例如/，字符串"外星人入侵"等，每次修改都需要重新编译程序

       在继续之前，我们先对代码组织结构做一次重构，这能让我们走得更远。

       为了清晰，方便管理，我们逻辑拆分到4个文件中： game.go：编写Game对象，并实现相关方法，同时负责协调其他各个模块 input.go：输入相关的逻辑 config.go：专门负责配置相关的逻辑 main.go：main函数，负责创建Game对象，运行游戏

       为了程序的灵活修改，我们将程序中的可变项都作为配置存放在文件中，程序启动时自动读取这个配置文件。我选择json作为配置文件的格式：

       然后定义配置的结构和加载配置的函数：

       将游戏核心逻辑移到game.go文件中，定义游戏对象结构和创建游戏对象的方法：

       先从配置文件中加载配置，然后根据配置设置游戏窗口大小和标题。拆分之后，Draw和Layout方法实现如下：

       第一次重构到此完成，现在来看一下文件结构，是否更清晰了呢？

       注意，因为拆分成了多个文件，所以运行程序不能再使用go run main.go命令了，需要改为go run .。

       显示

       接下来我们尝试在屏幕底部中心位置显示一张飞船的：

       ebitengine引擎提供了ebitenutil.NewImageFromFile函数，传入路径即可加载该，so easy。为了很好的管理游戏中的各个实体，我们给每个实体都定义一个结构。先定义飞船结构：

       我提供了两种格式，一种是png，一种是bmp，用哪种都可以。注意，需要将对应的解码包导入。Go标准库提供了三种格式的解码包，image/png，image/jpeg，image/gif。也就是说标准库中没有bmp格式的解码包，所幸golang.org/x仓库没有让我们失望，golang.org/x/image/bmp提供了解析bmp格式的功能。我们这里不需要显式的使用对应的库，故使用import _这种方式，让init函数产生副作用。

       然后在游戏对象中添加飞船类型的字段：

       为了将飞船显示在屏幕底部中央位置，我们需要计算坐标。ebitengine采用如下所示的二维坐标系：

       x轴向右，y轴向下，左上角为原点。我们需要计算飞船左上角的位置。由上图很容易计算出：

       为了在屏幕上显示飞船，我们需要调用*ebiten.Image的DrawImage方法，该方法的第二个参数可以用于指定坐标相对于原点的偏移：

       我们给Ship类型增加一个绘制自身的方法，传入屏幕对象screen和配置，让代码更好维护：

       这样游戏对象中的Draw方法就可以简化为：

       运行：

       移动飞船

       现在我们来实现使用左右方向键来控制飞船的移动。首先给飞船的类型增加x/y坐标字段：

       我们前面已经计算出飞船位于屏幕底部中心时的坐标，在创建飞船时将该坐标赋给xy：

       由于NewShip计算初始坐标需要屏幕尺寸，故增加屏幕宽、高两个参数，由NewGame方法传入：

       然后我们在Input的Update方法中根据按下的是左方向键还是右方向键来更新飞船的坐标：

       由于需要修改飞船坐标，Game.Update方法调用Input.Update时需要传入飞船对象：

       好了，现在可以运行程序了go run .，效果如下：

       注意到，目前有两个问题：

       因为现在每次只对x坐标修改1个像素位置，故而显得太慢。我们可以在增加一个飞船速度的南山奶粉溯源码在哪扫配置项来控制每次变化的像素数：

       config.go需要相应的修改：

       修改Input.Update方法，每次更新ShipSpeedFactor个像素：

       因为在Input.Update方法中需要访问配置，因此增加Config类型的参数，由Game.Update方法传入：

       运行，是不是快了很多呢？

       总结

       本文介绍了2D游戏开发库ebiten的基本使用，并开始开发一个外星人入侵的游戏（1/3），目前只能在屏幕上移动飞船，下篇文章继续完成剩下的内容。

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

Go 并发实战--sync Cond

       在 Go 语言中，sync.Cond 是一个条件同步变量，它与 Java 中的 Object 的 wait、notify、notifyAll 方法或 Condition 类功能相似。掌握 Java 的 JUC 包实现后，学习其他语言的并发特性及工具变得相对简单。

       sync.Cond 提供了阻塞和唤醒函数：Wait()、Signal() 和 Broadcast()。使用时，需要指定一把锁，如 Mutex、RWLock 或自定义实现的锁。下面展示一个简单的使用示例：

       输出：

       注：在启动 Go 协程后，它并不会立即执行，需要等待分配过程和一定时间。因此，建议在调用 Wait() 之前稍作等待，以免唤醒通知在 wait 之前发生而变得无效。上述示例展示了 Cond 的基础使用，生产环境中可能更为复杂，但大致原理相同。

       Cond 的实现相对简单，核心依赖于创建的锁操作和 runtime 提供的阻塞和唤醒 Go 协程的函数。在 Wait 函数中，锁的使用方式可能不够直观，其主要目的是使外部条件判断与添加阻塞队列的操作变为原子操作。这种锁的使用方式需要谨慎，容易引发问题。

       在醒操作部分，同步通知机制确保了当条件满足时，等待的协程能够被正确唤醒。关于 Cond 的使用和源码实现的详细内容，这里不再赘述。

《实战：centos上安装Go软件》-.4.

       目录

       [TOC]

       实验环境实验软件

       链接：pan.baidu.com/s/1dwuL9m... 提取码：3gmb

       1.下载安装包

       将Linux的go.tar.gz包下载至本地：

       使用wget命令或者浏览器直接下载至Linux系统。

       2.安装&配置

       将Windows编写的go源码上传至Linux机器进行编译运行：（可成功运行代码）

       解压并安装go包，配置环境变量，完成go环境搭建。

       3.如何卸载

       删除文件，删除环境变量配置。

       卸载go环境，删除已安装的go包及配置。

       关于我

       博客主旨：通过实验现象结合理论知识深入理解技术，提高学习乐趣和动力。

       分享源码及实验所需软件，共同进步。

       如遇操作疑问，可随时联系本人免费解决问题。

       最后

       实验结束，感谢阅读，祝大家生活快乐，充实每一天，期待下次再见！

Go的执行原理以及Go的命令

       Go的源码文件主要分为三类：命令源码文件、库源码文件和测试源码文件。

       命令源码文件是Go程序的入口，被声明为main包，包含main函数。文件被安装后，会根据GOPATH设置存放于当前工作区的bin目录或GOBIN设置的目录。这些文件可以单独运行，使用go run命令直接执行，或通过go build或go install生成可执行文件。命令源码文件不应与其他文件混合在同一个代码包中。

       库源码文件不具备命令源码文件的特征，是普通源码文件。文件被安装后，对应的归档文件(.a文件)会被存放在当前工作区的pkg目录下的平台相关目录。库源码文件不能通过go build或go install编译和安装。

       测试源码文件以_test.go为后缀，并包含Test或Benchmark函数。Test函数接受*testing.T参数，用于功能测试；Benchmark函数接受*testing.B参数，用于性能测试。

       命令方面，Go的最新版本1.提供了个基本命令，如build、get、install、run等。build命令用于编译代码包及其依赖；get命令用于下载远程代码仓库中的代码包；install命令用于编译并安装代码包；run命令用于运行命令源码文件。build和install命令会在指定目录生成可执行文件；run命令只能运行命令源码文件。install命令还负责将编译结果移动到bin目录或GOBIN目录。get命令会将代码包下载到GOPATH中的src目录。clean命令用于清除已编译生成的文件。

       fmt命令用来格式化代码文件，通常与gofmt命令结合使用，格式化后的结果会覆盖源代码文件。test命令自动读取_test.go文件，生成并运行测试用的可执行文件。doc命令提供强大的文档功能，可以查看相应package的文档，甚至创建本地版本的golang.org文档。fix命令用于修复老版本代码到新版本，version命令查看当前Go版本，env命令查看Go环境变量，list命令列出当前安装的所有package。

       综上所述，Go的源码文件分类清晰，命令提供了全面的编译、下载、安装、测试和文档支持，满足了开发者的需求。

游戏服务端开源引擎GoWorld教程——（1）安装和运行

       GoWorld是一套分布式开源Go语言游戏服务器引擎，采用Entity/Space的逻辑抽象结构，适用于MMORPG、RTS、射击等类型游戏。这种结构使得游戏的网络通信模式较为统一，能够在框架层实现更多功能，顶层逻辑无需关心数据同步，能提高游戏开发效率。

       GoWorld结构图展示了它会开启3类进程。其中dispatcher和gate是固定的程序，需要我们自己编写的game是游戏逻辑所在，也是Entity/Space活动的地方。客户端连接到gate，它负责网络消息的接收和转发；dispatcher负责消息分发；game处理游戏逻辑。

       安装GoWorld项目后，可以通过命令行goworld进行操作，如使用goworld start examples/chatroom_demo开启聊天服务器。安装过程包括安装Go语言、设置Go路径、安装goworld所需的依赖包，以及手动安装某些依赖包。测试安装是否成功的方法是执行goworld指令。

       GoWorld提供了聊天室示例，是运行它的起点。聊天室示例包含4个go文件，后续可以仿照示例编写自己的游戏逻辑。安装和运行聊天室示例的步骤包括安装依赖包、编译代码并生成可执行文件，以及运行示例程序。执行goworld指令查看服务器状态，执行stop指令关闭服务器。

       推荐学习资料包括收听关于网络游戏同步算法的课程，以及阅读《Unity3D网络游戏实战（第2版）》书籍，这是一本专门介绍多人网络游戏开发的实战书籍，手把手教你搭建网络框架，制作大型项目。

       以下为GoWorld教程系列文章链接：

       罗培羽：游戏服务端开源引擎GoWorld教程—— (1)安装和运行

       罗培羽：游戏服务端开源引擎GoWorld教程——（2）Unity示例双端联调

       罗培羽：游戏服务端开源引擎GoWorld教程——（3）手把手写一个聊天室

       罗培羽：游戏服务端开源引擎GoWorld教程——（4）制作多频道聊天室

       罗培羽：游戏服务端开源引擎GoWorld教程——（5）登录注册和存储

       罗培羽：游戏服务端开源引擎GoWorld教程——（6）移动同步和AOI

       罗培羽：游戏服务端开源引擎GoWorld教程——（7）源码解析之启动流程和热更新

       罗培羽：游戏服务端开源引擎GoWorld教程——（8）源码解析之gate

       罗培羽：游戏服务端开源引擎GoWorld教程——（9）源码解析之dispatcher

       罗培羽：游戏服务端开源引擎GoWorld教程——（）源码解析之entity

go源码分析——类型

       类型是Go语言中的核心概念，用于定义数据的结构和行为。类型可以分为基础类型和自定义类型，编译器会为每种类型生成对应的描述信息，这些信息构成了Go语言的类型系统。内置类型的数据结构在`runtime.type`文件中，而自定义类型的数据结构在`type.go`文件中，包括了类型名称、大小、对齐边界等属性。例如，切片的元素类型和map的键值类型都在其中有所体现。空接口`interface{ }`和非空接口`iface`是描述接口的底层结构体，分别用于表示不包含方法的接口和包含方法的接口。空接口的结构简单，包含类型和数据的位置信息，而非空接口的结构更复杂，包含接口的类型、实体类型和方法信息。接口的实现依赖于方法集的匹配，时间复杂度为O(m+n)。断言是判断一个类型是否实现了某个接口的机制，它依赖于接口的动态类型和类型元数据。类型转换和接口断言遵循类型兼容性原则，而反射提供了访问和操作类型元数据的能力，其核心是`reflect.Type`和`reflect.Value`两个结构体类型，分别用于获取类型信息和操作值。反射的关键在于明确接口的动态类型和类型实现了哪些方法，以及类型元数据与空接口和非空接口的数据结构之间的关系。

Go语言源码阅读分析（3）-- unsafe

       Go语言的unsafe包提供了一套打破类型安全限制的操作，但使用时需谨慎，因为它可能导致代码无法移植。包内主要包含unsafe.go文件和一些声明，实际实现和测试用例并未提供。关键内容如下：

       1. Pointer类型：可以转换为任何类型的指针，以及Uintptr类型，这种转换允许直接读写内存，风险极高，需谨慎使用。

        - 可以将任意类型转换为Pointer类型，但转换后不能长于原类型，且要求内存布局一致。例如，将float转换为uint的函数`Floatbits`。

        - Pointer可以转换为uintptr，但这种转换仅用于内存地址的打印，且不能直接从uintptr恢复为Pointer，除非是枚举类型。

       2. 偏移指针：用于访问结构体字段或数组元素，需确保指针不会超出原始对象的内存范围。

       3. syscall调用：在syscall包中，某些函数需要在同一条语句中进行指针到uintptr的转换，以确保指针指向的对象在调用时仍然有效。

       4. reflect包使用：reflect.Value.Pointer和UndafeAddr返回的都是uintptr，应在获取后立即转换为Pointer，避免对象被GC回收。

       5. 反射结构体转换：例如StringHeader和SliceHeader的Data字段，仅在指向活动切片或字符串时有效。

       总之，unsafe包的使用需遵循特定的规则和限制，不当使用可能导致程序不稳定或移植问题。接下来的计划是研究reflect包。