Golang应用程序性能优化技巧分享

2023-05-15 08:05:39 优化应用程序性能

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.Println("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 := 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)
		waitGroup.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-

访问单个对象需要磁盘操作，这会破坏程序的效率。使用缓冲输入/输出将有效地提高您的应用程序速度，它必须读取和写入更大的数据块。

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与其他库相比，在编码和解码方面都非常快。通过使用自动代码生成来提高性能或使用专用接口，它更容易实现，但敢于坚持与并且是简单接口的兼容性。另外它高度兼容系统json库，所以你可以快速在你的项目中进行替换使用。它采用对象池，避免反射等手段进行优化，以后的章节中我们将重点介绍反射的优化技术。

14.预分配切片

当您的需求达到其当前容量时，Golang 会自动分配内存。在重新分配期间，系统会在数据移动到新位置时新的内存。为了避免这种内存浪费和不必要的垃圾收集，您应该尽可能预分配足够的使用内存。切片不是List,所以不要以为 var s =[]int={}，以后直接append就好了，因为不断的扩容会带来无穷的性能损害。

15. 对map能使用 int就别string

如果您的应用程序使用map，那么您应该在可以使用int作为key时就不要用string作为key。

四、总结

可靠性和应用程序性能都很重要。永远记住，应用程序性能速度是以毫不费力、开发时间和持续维护为代价的。如果您要构建 Golang 应用程序，了解上述提高 Golang 应用程序性能的提示和技巧将有助于您进行有效的应用程序开发。

以上就是Golang应用程序性能优化技巧分享的详细内容，更多关于Golang程序性能优化的资料请关注其它相关文章！

相关文章