Go实践笔记

最新推荐文章于 2024-08-24 10:03:00 发布
最新推荐文章于 2024-08-24 10:03:00 发布
阅读量359 收藏
点赞数
分类专栏： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kugoo11v12/article/details/107134357
版权

Go实践笔记

目前在用go写同步对战服务器这块。这门编程语言很久以前虽然学过，不过时间久了也用的较少，时间久了忘了很多。在写服务器过程中，可以享受到go对高性能并发的内置支持，但同时也会遇到一些坑，这里针对go的一些问题，记录一些笔记，包括一些坑的解决办法。

1. go语言的异常处理机制不够完善。

（1）go的异常处理通过defer recover来实现，不支持函数局部代码块异常处理。

（2）go的异常不像java那样区分类型，包括官方的标准库也是，更多的是通过运行时错误码来判断。处理异常的时候，代码维护和可读方面没有java那么直观。

针对这一点，我思考了下，实际上因为go支持闭包 可以通过闭包来代替代码块处理局部异常；然后go panic抛出的异常可以是任意类型的，而go支持通过反射来动态判断类型，所以可以通过这两点模拟go版的区分类型的try catch机制。

2. go语言内置的一些数据类型都不是线程安全的。

go语言内置的一些数据类型支持，包括slice，map，list等都存在线程安全问题。对于大部分通用场景来说，使用go内置的读写锁即可满足需求；不过也可以使用channel代替锁，通过channel协调读写线程，实现线程安全。此外，也可以使用atomic库实现更灵活的功能。

参考相关文章：https://www.jianshu.com/p/df973e890663

3. go语言不支持宏，不支持泛型，也不支持重载

go语言为了加快编译速度，目前都没有支持宏和泛型，甚至不支持重载，而内置的数学库也只是支持float64型，对于复杂的业务场景来说，非常不便。
所幸有些第三方库帮我们处理了一些脏活累活，比如数学扩展工具库 https://godoc.org/modernc.org/mathutil

4. 数据类型转换不方便

由于go语言不支持泛型，而go对于非基本数据类型的强制类型转换也没有提供专门的支持，在转换非基本数据类型时，显得很繁琐。例如下面这个例子，正确的转换很冗长，也无法使用宏简化（因为go也不支持宏）：

	type _Int32 int32
	var a *[]_Int32
	var b *[]int32=(*[]int32)(a) // 语法报错
	var d *[]int32=(*[]int32)(unsafe.Pointer(a)) //能正确转换

同样的，结构体的串行化也不方面，显得冗长，存在性能消耗：

	type Struct struct{
		a int64
		b int32
	}

	sample:=Struct{}

	size:=int(unsafe.Sizeof(&sample))
	sh := &reflect.SliceHeader{
		Data: uintptr(unsafe.Pointer(&sample)),
		Len:  size,
		Cap:  size,
	}

	// 结构体->[]byte
	data := *(*[]byte)(unsafe.Pointer(sh))

	// []byte->结构体
	originStruct:=(*Struct)(unsafe.Pointer(&data));

5. 对goroutine调度控制较弱，需要注意安排好不同goroutine之间的依赖关系

特别常见的一点是当main函数退出之后，程序就会退出，不会等待其他线程退出。通常会适用wait.group来实现线程依赖等待。

6. 关于 go版本的protobuf的性能问题

最近对比了messagepack和protobuf在go上面的性能表现。

序列化耗时反序列化耗时序列化数据大小
原始数据\\180
protobuf10012045
messagepack200240210

protobuf在性能上确实非常优越，速度快，体积小；但是也存在一些明显的缺陷：

1.protobuf导出的数据类型内部如果存在嵌套结构，那么嵌套结构都是使用指针关联的，一方面在反序列化过程中会发生大量内存分配操作，容易产生大量内存碎片，对于内存相对较小的机器非常不利，另一方面不利于结构体深拷贝操作，强行深拷贝会存在性能问题。

2.对于所有没有赋值或者赋了默认值的字段，在反序列化过程中都会初始化为空指针或者零值，会存在两个隐患：

  • 1.一旦产生字段赋值操作，很容易出现空指针异常。
  • 2.未赋值的数据结构指针（空指针）依旧可以正常使用，只不过获取的字段值都是空指针或零值，容易误导开发者以为该结构体实例是存在实体的。

7. go中所有的对象传递全部都是值传递，包括所谓的指针引用，实际上也是基于值传递实现的。

go初学者稍不注意就会因此引发结构体副本之间的状态同步bug或者产生对一些第三方库（包括官方库）的误用。
比如socket编程中：

listener, err := net.Listen("tcp", "127.0.0.1:8001")
    if err != nil {
            fmt.Println("err = ", err)
            return
    }
    defer listener.Close()
    for {
            conn, err := listener.Accept()
            if err != nil {
                fmt.Println("err = ", err)
                    return
         }
        // 处理用户请求, 新建一个协程
        // 为什么conn不使用指针传递呢，不会产生状态同步问题吗？
        // 这是因为net.Conn类型的数据实际上只保存了一个指针变量 `fd *netFD`，而所有的操作实现都是通过该指针来间接访问，所以无论conn拷贝几份，内部的fd指针值都一样。
        // 这应该是官方为了方便使用特意这样设计的
        // 但这用设计同时会引发另一个问题，就是 (&conn) 指针无法直接使用，虽然目前这不是什么大问题
         go HandleConn(conn)
}

// net.Conn的实际数据结构
type conn struct {
	fd *netFD
}

实践中，总结了一下指针引用和值引用的适用场景：

  • 如果对象包含持续的状态变化，那么应当使用指针引用，避免产生副本导致状态不同步、锁失效等“离奇”问题。
  • 如果对象是简单的无状态数据：
    • 如果对象非常小，那么适合使用值引用。
    • 如果对象较大，那么适合使用指针引用，避免数据拷贝导致执行效率降低、内存占用明显升高。

8. uintptr和gc

使用uintptr类型的值保存原始对象指针不会阻止该对象gc，需要结合runtime.KeepAlive()来使用。要尽量避免这种用法。

9. foreach常见bug

下面这段代码会导致后续go线程中调用的handler是后面遍历到的其他handler

func HandleRequestParallalThreadUnsafe(jobInfo *HandleJobInfo) {
	for _, handler := range this.handlers {
		if handler != nil {
			go func() {
				defer func() {
					if err := recover(); err != nil {
						log.Println("HandleRequestParallalThreadUnsafe-error:", err)
					}
				}()
				handler(jobInfo)
			}()
		}
	}
}

正确写法：


func HandleRequestParallalThreadUnsafe(jobInfo *HandleJobInfo) {
	handlers := make([]RequestHandler, len(this.handlers))
	//通过创建副本，避免this.handlers被动态修改出现遍历bug
	copy(handlers, this.handlers)
	for _, handler := range handlers {
		if handler != nil {
			//不使用闭包变量会导致后续go中调用的handler是后面遍历到的handler
			thandler := handler 
			go func() {
				defer func() {
					if err := recover(); err != nil {
						log.Println("HandleRequestParallalThreadUnsafe-error:", err)
					}
				}()
				thandler(jobInfo)
			}()
		}
	}
}

10. go服务器性能优化

11. 线程锁改进

go内置提供的锁通常是这样用的：

var lock sync.RWMutex
func TestTreadLock1(){
	lock.Lock()
	defer lock.Unlock()
	...
}
func TestTreadLock2(){
	lock.Lock()
	...
	lock.Unlock()
	...
}

这里其实可以封装改进一下，让锁的使用更严格，不容易出现死锁：


import "sync"

type RWLock struct {
	lock sync.RWMutex
}

func (this *RWLock) LockWrite(call func()) {
	defer this.lock.Unlock()
	this.lock.Lock()
	call()
}

func (this *RWLock) LockRead(call func()) {
	defer this.lock.RUnlock()
	this.lock.RLock()
	call()
}

var lock RWLock{}
func TestTreadLock3(){
	lock.LockWrite(func() {
		...
	})
	lock.LockRead(func() {
		...
	})
}

12. atomic 和读写锁的性能对比


var rwlock myserver.RWLock

const uniqueIdAccMax uint64 = 1000000

const GenUniqueId64Panic = "GenUniqueId64_acc_overflow"

func GenUniqueId64WithLock() int64 {

	var timeUnix int64
	rwlock.LockWrite(func() {

		nowTime := time.Now().Unix()
		if nowTime == lastTime {
			uniqueIdAcc++
		} else {
			lastTime = nowTime
			uniqueIdAcc = 0
		}
		acc := uniqueIdAcc

		if acc >= uniqueIdAccMax {
			panic(GenUniqueId64Panic)
		}

		timeUnix = int64((nowTime-1593426002)*int64(uniqueIdAccMax) + int64(acc))
	})
	return int64(timeUnix)

}

var alock int32=0
func GenUniqueId64WithAtomic() int64 {

	var timeUnix int64
	//加锁
	for{
		if(atomic.CompareAndSwapInt32(&alock,0,1)){
			break
		}
	}

		nowTime := time.Now().Unix()
		if nowTime == lastTime {
			uniqueIdAcc++
		} else {
			lastTime = nowTime
			uniqueIdAcc = 0
		}
		acc := uniqueIdAcc

		if acc >= uniqueIdAccMax {
			panic(GenUniqueId64Panic)
		}

		timeUnix = int64((nowTime-1593426002)*int64(uniqueIdAccMax) + int64(acc))
	
	//解锁
	atomic.StoreInt32(&alock,0)
	
	return int64(timeUnix)

}

在个人笔记本上并发测试，耗时如下，可以看出并发越高，atomic性能越不如lock。另外经过反复测试，发现atomic的耗时波动非常大，不如lock稳定。

func BenchmarkGenUniqueId64(b *testing.B) {
	var wg sync.WaitGroup
	count:=1
	wg.Add(count)
	for k:=0;k<count;k++{
		go func() {
			for i := 0; i < 100000; i++ {
				GenUniqueId64()
			}
			wg.Done()
		}()
	}
	wg.Wait()
}

func BenchmarkGenUniqueId64_2(b *testing.B) {
	var wg sync.WaitGroup
	count:=1
	wg.Add(count)
	for k:=0;k<count;k++{
		go func() {
			for i := 0; i < 100000; i++ {
				GenUniqueId64_2()
			}
			wg.Done()
		}()
	}
	wg.Wait()
}

测试结果：

count == 1:
BenchmarkGenUniqueId640.00660 ns/op
BenchmarkGenUniqueId64_20.00330 ns/op
count == 2:
BenchmarkGenUniqueId640.0240 ns/op
BenchmarkGenUniqueId64_20.0280 ns/op
count == 3:
BenchmarkGenUniqueId640.0500 ns/op
BenchmarkGenUniqueId64_20.0730 ns/op
count == 4:
BenchmarkGenUniqueId640.0790 ns/op
BenchmarkGenUniqueId64_20.120 ns/op
count == 6:
BenchmarkGenUniqueId640.139 ns/op
BenchmarkGenUniqueId64_20.201 ns/op
count == 8:
BenchmarkGenUniqueId640.197 ns/op
BenchmarkGenUniqueId64_20.398 ns/op

13. 单元测试

go的单元测试推荐goland内置单元测试功能。goland内置提供生成表单驱动单元测试的功能，提供单元测试覆盖率统计。

14.Go内存泄漏分析的坑

这几天观察项目内存泄漏问题时，发现内存占用居高不下，以为有严重的内存泄漏问题，但是细查之后并没有什么发现，怀疑go内存回收方面可能有奇怪的设定。后来参考下文，发现确实如此，使用 debug.FreeOSMemory() 强制返还系统内存，内存占用立即降到 135MB，反复返回测试同样稳定在135MB。说明没有明显的内存泄漏问题。

参考 Go内存泄漏？不是那么简单!

windyuuy
关注
专栏目录
Go语言学习笔记.pdf
12-30
Go语言是一种开源编程语言，具有简单易学、高性能、跨平台等特性，目前已经成为构建高效、可靠的应用程序的重要选择...随着对Go语言不断深入的学习和实践，开发者将能够充分体验到它的简洁、高效和强大的系统编程能力。
韩顺平_Go语言核心编程完整版笔记.zip
08-22
通过这份笔记，读者不仅可以学习到Go语言的基本语法和编程技巧，还能了解到Go语言在实际开发中的最佳实践和陷阱，这对于成为一名合格的Go语言开发者至关重要。同时，由于是基于韩顺平老师的课程整理，因此笔记应该会...
JSON、Protobuf、Thrift、MessagePack 对比和开发指南
weixin_34247155的博客
09-10 511
主流序列化协议优缺点和网站推荐 JSON 优点 1 简单易用开发成本低2 跨语言3 轻量级数据交换4 非冗长性（对比xml标签简单括号闭环） 缺点 1 体积大，影响高并发2 无版本检查，自己做兼容3 片段的创建和验证过程比一般的XML复杂4 缺乏命名空间导致信息混合 总结：最简单最通用的应用协议，使用广泛，开发效率高，性能相对较低，维护成本较高。 Protobuf Protobuf是一种以有效并可...
推荐文章：探索现代数据库管理新境界 —— modernc.org/ql
最新发布
gitblog_00838的博客
08-24 709
推荐文章：探索现代数据库管理新境界 —— modernc.org/ql qlgithub.com/cznic/ql has moved to modernc.org/ql项目地址:https://gitcode.com/gh_mirrors/ql1/ql 在快速发展的技术浪潮中，找到一款既符合高效开发需求，又能灵活适应各类场景的数据库查询语言工具至关重要。今天，我们要向大家推荐的是从githu...
探索现代C编程的新境界：ModernC.org/b 项目深度解析
gitblog_00045的博客
05-31 311
探索现代C编程的新境界：ModernC.org/b 项目深度解析 bgithub.com/cznic/b has moved to modernc.org/b项目地址:https://gitcode.com/gh_mirrors/b/b 项目介绍 欢迎来到一个技术革新之旅 —— ModernC.org/b，一个从GitHub.com/cznic/b迁移而来的开源宝藏。随着项目的档案化和路径的更新...
【优化】序列化库的选择(FlatBuffers,ProtoBuf,MessagePack,Json)
m0_73915763的博客
08-29 697
在我接手的上一个项目里，也是使用的json来做为序列化库，当时对newtonsoft Json狠狠的吐槽了一把，它的性能有多么多么的差，尤其是在一些低端机上，GC Alloc和调用耗时都很大，当然， 这也与当时加载的云控的数据量有关。最近开了新的项目，因为要重新搭建一套框架，所以在涉及到大量配置表需要解析的时候，就要考虑选择哪一种序列化库了，其实有大量的项目，现在还是在使用json库来来做为数据交换的格式，足够的稳定，成熟，明文，方便阅读。===========下面是详细的废话==============
MsgPack和Protobuf
brook0344的专栏
11-05 764
MsgPack可以在C++下序列化类，Protobuf只能在C#下序列化类。
[笔记][尚硅谷韩顺平Go语言核心编程][01]1
08-03
简介:Go 语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率，使用一个表达式来形容 Go 语言： Go = C + Python ,
Golang 笔记 第四版 高清版.zip
09-20
《Golang学习笔记第四版》是由雨痕编著的一份详尽的Go语言教程，针对初学者和进阶者提供了全面且深入的学习材料。这份笔记以其高清版的形式，旨在为读者提供清晰、易读的学习体验。Go语言，又称Golang，是Google在...
go语言学习笔记.zip
09-09
Go语言，又称Golang，是Google在2009年推出的一种开源编程语言，由Robert Griesemer、Rob Pike及Ken Thompson设计。它的设计目标是简单、高效、可移植，并且具有良好的并发性能，适用于构建大规模的网络服务和分布式...
msgpackgen：用于Go的MessagePack序列化器和代码生成器。 msgpack.org [开始]
02-17
用于Go的MessagePack代码生成器 msgpackgen提供了的代码生成工具和序列化库。 一个显着的特征是它易于维护并且运行非常快。 快速开始 在源文件（例如main.go）中，包括以下指令： //go:generate msgpackgen or //go:generate go run github.com/shamaton/msgpackgen 并在您的shell中运行以下命令： go generate 它将生成一个.go文件进行序列化，默认文件为resolver.msgpackgen.go 。 您可以调用一种方法来使用生成的代码。 func main () { // this method is defined in resolver.msgpackgen.go RegisterGeneratedResolver () // ... your code
MessagePack, Protocol Buffers和Thrift序列化框架原理和比较说明
jimmee的专栏
04-09 571
  第1部分 messagepack说明 1.1messagepack的消息编码说明 为什么messagepack比json序列化使用的字节流更少， 可通过图1-1、图1-2有个直观的感觉。    图1- 1 messagepack与json的格式对比1   图1- 2 messagepack与json的格式对比2 messagepack的具体的消息格式如图1-3所示，...
msgpack和protobuf的对比
weixin_30826095的博客
08-03 1278
msgpack和protobuf的对比 msgpack的序列化速度比protobuf要快一些，但反序列化要比protobuf要慢一些，但总体都接近msgpack可以直接序列化类对象，但protobuf需要先写描述映射文件(.proto)msgpack支持的基本类型比protobuf支持的要全面些protobuf的描述文件无法实现类的继承（不知V2.0以上会如何）然而，msgpack在unity下...
移动场景下通信协议Json,FlatBuffers、ProtocolBuffers、MessagePack选优
fjgui的博客
11-15 925
写文章注册登录 首页 下载App 移动场景下通信协议FlatBuffers、ProtocolBuffers、MessagePack选优   爱唱歌的王小猫 关注 2017.04.05 19:26 字数 2828 阅读 562评论 0喜欢 2 大家都知道JSON是纯文本协议，优点是可读性高，使用
了解一下ProtoBuf
蜜糖的代码注释
02-21 418
序列化与反序列化 我们在进行网络通信调用的时候，总是需要将内存的数据块经过序列化，转换成为一种可以通过网络流进行传输的格式。而这种格式在经过了传输之后再经过序列化，能还原成我们预想中的数据结构。 那么我们对于这种用于中间网络传输的数据格式就有一定的要求。首先它可以准确地描述数据内容，在此基础上我们则希望它尽量的小。 最开始流行起来的是XML，可扩展标记语言。由于它可以用来标记数据、定义数据类型，所以用户可以自己定义数据自己的语言，从而让对不同的数据结构化成统一的格式称为了可能。 而另外一个我们熟知的
关于MessagePack的一些记录
Moyiii的专栏
04-08 331
MessagePack做的更直接，直接看你Value的值用几位可以表示，8位，16位，还是32位，那我就标记3种不同的类型信息，然后吧Value按照对应的字节直接写入后边。因为ProtoBuf有MSB的概念，特别对于比较大的数，至少要浪费2-3位的MSB，如果这2-3位被MsgPack用来做type信息，实际上二者在空间上是差不多的。但实际上，MsgPack应该还是节省了一些。这样的好处是节省内存空间，缺点是，比较难去做字段扩展，一旦字段顺序改变，或者增删，基本上很难和过去的数据结构进行兼容。
golang MessagePack 序列化
oToyix的博客
07-27 357
MessagePack 是一个基于二进制高效的对象序列化类库。 go get github.com/vmihailenco/msgpack/v5
Go : 常用库MsgPack的简介与实践
GIS摆渡人
11-17 1004
官网： https://msgpack.org/MessagePack是一种有效的二进制序列化格式。它使您可以在JSON等多种语言中交换数据。但是它更快，更小。小整数被编码为单个字节，典型的短字符串除了本身之外，仅需要一个额外的字节。msgpack会将数据打包成二进制的数据，它的数据格式与json类似，但是在存储时对数字、多字节字符、数组等都做了很多优化，减少了无用的字符，二进制格式，也保证不用字符化带来额外的存储空间的增加，所以在很大程度上减少来传输数据的大小。
Go语言学习笔记高清：从入门到实践
"Go语言学习笔记高清版是由雨痕编写的，该笔记详细记录了作者从2012年初开始学习Go语言的过程，随着时间的推移，不断更新和补充内容，涵盖了Go语言的基础知识、语法特性、函数设计、类型系统、控制结构、自定义类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值