目录
- 一、概述
- 二、关于性能优化的方向
- 延迟问题
- 资源效率
- 算法效率
- 三、提高 golang 应用程序性能的最佳实践
- 1. 并行化 CPU 工作
- 2.观察你的超时
- 3. 使 I/O 操作异步
- 4.减少Goroutines的使用
- 5. 使用无锁算法
- 6. 使用已编译的正则表达式
- 7.避免使用cgo
- 8.不要在热点分配内存
- 9.用好sync.RWMutex
- 10. 在文本格式上使用二进制 -
- 11. 利用缓冲 I/O-
- 12. 更喜欢使用 StringBuffer 或 StringBuilder-
- 13. 选择 Protocol Buffers 和 MessagePack
- 14.预分配切片
- 15. 对map能使用 int就别string
- 四、总结
一、概述
随着科技的进步，人人都想要快速的应用，用户想要快速的交付，开发者想要快速的性能，创业者想要两者兼而有之。这就需要优化您的应用程序性能。您需要提高应用程序的速度和性能，使其成为市场上最好的。您想要优化 Golang 应用程序的主要原因有两个——资源效率和改善操作延迟。您的应用程序的最终目标应该是它不需要太多资源而继续等待操作。尽管您的 Golang 应用程序太复杂以至于无法执行其中一项任务，但它必须依赖另一项任务，这样一来，它就变成了一个死循环的依赖项。本文将讨论一些关于提高 Golang 应用程序性能的最佳实践。
二、关于性能优化的方向
延迟问题
延迟优化需要分析程序的瓶颈。主要目的在于优化特定功能的延迟。当您提高程序的资源效率时，延迟会自动改善。然而，改善延迟可能需要增加资源消耗。故此，我们需要意识到程序的瓶颈和热点，并同时处理这些问题。
资源效率
您可以提高应用程序性能以优化资源使用。程序的某些部分比其他部分需要更多的资源，您应该为您的应用程序找到这样的热点。如 CPU、带宽或内存。
算法效率
通常程序可以采用不同的算法来执行相同的操作，但效率往往因为各种因素不一而产生不一样的效果，所以通过实施算法优化，我们可以最大限度地提高应用程序的性能。
三、提高 Golang 应用程序性能的最佳实践
1. 并行化 CPU 工作
同步需要花费大量时间，当您使用可用内核并行工作时，它肯定会优化 Golang 应用程序性能。这是线性加速应用程序执行的重要一步。这也属于Golang相对于其他语言的天然优势（自带弹药库）。另外并行不一定最优，但能并行的场景，必然对我们有利，因为Golang天生丽质。
下面我们以计算也给目录的文件总大小为例。分别以非并行和并行两种方式进行对比
//非并行版本
package main
import (
"fmt"
"io/ioutil"
"log"
"path/filepath"
"time"
)
const (
//目标目录
TargetPath = "G:\\go"
)
// 递归计算目录下所有文件
func walkDir(path string, fileSize chan<- int64) {
fmt.Printf("\rwalk ... %s\n", path)
entries, err := ioutil.ReadDir(path)
if err != nil {
log.Fatal(err)
return
}
for _, e := range entries {
if e.IsDir() {
walkDir(filepath.Join(path, e.Name()), fileSize)
} else {
fileSize <- e.Size()
}
}
}
func main() {
//文件大小chennel
fileSize := make(chan int64)
//文件总大小
var sizeCount int64
//文件数目
var fileCount int
//计算目录下所有文件占的大小总和
go func() {
walkDir(TargetPath, fileSize)
defer close(fileSize)
}()
t := time.Now()
for size := range fileSize {
fileCount++
sizeCount += size
}
fmt.Printlhttp://www.devze.comn("used time: " + time.Since(t).String())
fmt.Printf("total size: %.1fGB\nfile count: %d\n", float64(sizeCount)/1e9, fileCount)
}
//-------------结果---------------
used time: 41.6566073s
total size: 8.5GB
file count: 416088
//并行版本
package main
import (
"fmt"
"io/ioutil"
"log"
"path/filepath"
"sync"
"time"
)
const (
//goTest目录
TargetPath = "G:\\go"
)
var waitGroup sync.WaitGroup
var ch = make(chan struct{}, 255)
// 递归计算目录下所有文件
func walkDir(path string, fileSize chan<- int64) {
defer waitGroup.Done()
fmt.Printf("\rwalk ... %s\n", path)
ch <- struct{}{} //限制并发量
entries, err := ioutil.ReadDir(path)
<-ch
if err != nil {
log.Fatal(err)
return
}
for _, e www.devze.com:= range entries {
if e.IsDir() {
waitGroup.Add(1)
go walkDir(filepath.Join(path, e.Name()), fileSize)
} else {
fileSize <- e.Size()
}
}
}
func main() {
//文件大小chennel
fileSize := make(chan int64)
//文件总大小
var sizeCount int64
//文件数目
var fileCount int
//计算目录下所有文件占的大小总和
waitGroup.Add(1)
go walkDir(TargetPath, fileSize)
go func() {
defer close(fileSize)
waitGr开发者_JAVAoup.Wait()
}()
t := time.Now()
for size := range fileSize {
fileCount++
sizeCount += size
}
fmt.Println("used time: " + time.Since(t).String())
fmt.Printf("total size: %.1fGB\nfile count: %d\n", float64(sizeCount)/1e9, fileCount)
}
//-------------结果---------------
used time: 7.3528287s
total size: 8.5GB
file count: 416088
很明显，我们采用并行方式后，程序的运行效率提升了接近6倍，所以，我们在适当场景下使用合适的方式进行并行编程，就能为我们程序带来意想不到的效果。当然上面的代码有些瑕疵，例如goroutine的创建不应该手动，而应该使用协程池等方式。
2.观察你的超时
通常，输入输出操作需要更多时间，从而导致延迟。要克服这个问题，您应该避免在不知道其将消耗的时间的情况下执行任何 I/O 任务。在为每个网络请求设置超时之前，您应该使用 SetDeadline、SetReadDeadline 和 SetWriteDeadline。
3. 使 I/O 操作异步
最常见的瓶颈是由于网络事务和文件输入/输出执行造成的。因此，为了优化您的 Golang 应用程序性能，您可以使独立的 I/O 异步。以这种方式，此类操作并行运行并改善下游延迟。此外，您可以使用 sync.WaitGroup 来同步多个 I/O 操作。
4.减少Goroutines的使用
使用 Goroutines 非常便宜且易于使用，这让我们觉得它几乎是免费的。但 goroutines 确实会占用大量内存，从而影响应用程序性能。通常，Go 开发人员会在不计算或不知道何时退出的情况下创建无限的 goroutine。因此，建议您仅在知道 goroutine 何时退出时才启动它。采用协程池来进行管理，我们不再赘述如何创建一个协程池，其他章节中我们将重点介绍。
5. 使用无锁算法
您应该避免同步，因为它会导致竞争。为了提高延迟和效率，您应该防止互斥。许多无锁解决方案可用于一些常见的数据结构。如果确实需要锁，你首选的应该为atomic,然后才为mutex。
6. 使用已编译的正则表达式
有些程序可能会多次使用同一个正则表达式，如果在每次使用前都编译正则表达式，应用程序会很低效。因此，对于重复匹配，您应该使用已编译的正则表达式。 性能差距还是很明显的，需要注意。
7.避免使用cgo
Go 程序可以通过使用 cgo 调用 C 库。但是cgo函数的开销很大，它在运行过程中会消耗线程，就像阻塞I/O一样。您不应该在紧密循环之间调用 C 代码。为了 Golang 应用程序的最佳性能，最好避免使用 cgo。后续的文章中我们将介绍如何优化cgo的性能。（既然不得不用，那么将如何用好cgo)
8.不要在热点分配内存
当您创建新对象时，系统会消耗内存和 CPU 周期，从而增加延迟。它占用GC效率，所以频繁创建对象可不是个好事情，尤其是在热点地区。因此，只要有可能，您应该重用对象，考虑sync.Pool
9.用好sync.RWMutex
同步的重对象的完全锁定，goroutines 需要等待很长时间。因此在读多写少的场景中，优先考虑sync.RWMutex
10. 在文本格式上使用二进制 -
两种二进制文本格式在 PostgresSQL 中均有效。但是二进制比文本格式快。使用二进制形式时，仅在从网络字节序转换时才需要处理。因此，对于 PostgresSQL 服务器，二进制格式比文本格式的传输效率更高。
11. 利用缓冲 I/O-
访问单个对象需要磁盘操作，这会破坏程序的效率。php使用缓冲输入/输出将有效地提高您的应用程序速度，它必须读取和写入更大的数据块。
12. 更喜欢使用 StringBuffer 或 StringBuilder-
使用“+”和“+=”运算符，系统在每次赋值时分配一个新字符串。为了克服这种低效率，您应该使用 StringBuffer 和 StringBuilder 来快速执行您的程序。具体见我另一篇文章：再论Golang字符串拼接问题
13. 选择 Protocol Buffers 和 MessagePack
避免使用官方提供的Gob 和 jsON 作为序列化反序列化方案，因为它们使用了反射，实现的方式相当丑陋。我们推荐应该使用 Protocol Buffers 和 MessagePack作为二进制的序列化方案，当然你非要用json序列化和反序列化，我们给出社区中给出的两种技术方案，都对JSON的操作进行性能上的优化。
1.sonic
sonic 是字节跳动开源的一款 Golang JSON 库，基于即时编译（Just-In-Time Compilation）与向量化编程（Single Instruction Multiple Data）技术，大幅提升了 Go 程序的 JSON 编解码性能。同时结合 lazy-load 设计思想，它也为不同业务场景打造了一套全面高效的 API。自 2021 年 7 月份发布以来， sonic 已被抖音、今日头条等业务采用，累计为字节跳动节省了数十万 CPU 核。
项目地址：sonic
2.go-json
go-json与其他库相比，在编码和www.devze.com解码方面都非常快。 通过使用自动代码生成来提高性能或使用专用接口，它更容易实现，但敢于坚持与 并且是简单接口的兼容性。另外它高度兼容系统json库，所以你可以快速在你的项目中进行替换使用。它采用对象池，避免反射等手段进行优化，以后的章节中我们将重点介绍反射的优化技术。
14.预分配切片
当您的需求达到其当前容量时，Golang 会自动分配内存。在重新分配期间，系统会在数据移动到新位置时新的内存。为了避免这种内存浪费和不必要的垃圾收集，您应该尽可能预分配足够的使用内存。切片不是List,所以不要以为 var s =[]int={}，以后直接append就好了，因为不断的扩容会带来无穷的性能损害。
15. 对map能使用 int就别string
如果您的应用程序使用map，那么您应该在可以使用int作为key时就不要用string作为key。
四、总结
可靠性和应用程序性能都很重要。永远记住，应用程序性能速度www.devze.com是以毫不费力、开发时间和持续维护为代价的。如果您要构建 Golang 应用程序，了解上述提高 Golang 应用程序性能的提示和技巧将有助于您进行有效的应用程序开发。
以上就是Golang应用程序性能优化技巧分享的详细内容，更多关于Golang程序性能优化的资料请关注我们其它相关文章！
加载中,请稍侯......
精彩评论