只改变一个字符就能使 Golang 程序提速 42%

yycvip

在 Go 语言中，有时可以通过改变一个字符来显著提高程序的性能。这通常与编程语言的特性、内存管理、数据结构的使用等有关。一个常见的字符是“分配”（allocation）和“引用”相关的操作。

以下是几个不同的代码示例，展示了通过改变一个字符（或字符的位置）来优化 Go 程序的性能。

#示例 1：切片的传递方式#原始代码（使用切片）

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. )
   
7. 
   
8. func sum(s []int) int {
   
9.         total := 0
   
10.         for _, v := range s {
    
11.                 total += v
    
12.         }
    
13.         return total
    
14. }
    
15. 
    
16. func main() {
    
17.         start := time.Now()
    
18.         data := make([]int, 10000000)
    
19.         for i := 0; i < len(data); i++ {
    
20.                 data[i] = i
    
21.         }
    
22.        
    
23.         result := sum(data) // 这里是一个切片的传递
    
24.         fmt.Println(result)
    
25.         fmt.Println("Time taken:", time.Since(start))
    
26. }

复制代码

在这个示例中，sum 函数接收一个切片 s，在函数内部对其进行迭代。由于切片是引用类型，虽然它不会复制整个数组，但如果我们频繁传递大的切片，可能会造成额外的性能开销。

#优化后的代码（使用数组）

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. )
   
7. 
   
8. func sum(s *[10000000]int) int { // 这里改变了字符：使用指针
   
9.         total := 0
   
10.         for _, v := range *s {
    
11.                 total += v
    
12.         }
    
13.         return total
    
14. }
    
15. 
    
16. func main() {
    
17.         start := time.Now()
    
18.         data := [10000000]int{} // 使用数组而不是切片
    
19.         for i := 0; i < len(data); i++ {
    
20.                 data[i] = i
    
21.         }
    
22.        
    
23.         result := sum(&data) // 传递数组的指针
    
24.         fmt.Println(result)
    
25.         fmt.Println("Time taken:", time.Since(start))
    
26. }

复制代码

在这个优化中，我们通过将切片改为数组并使用指针传递，减少了内存分配的开销。通过这种方式，可以显著提高程序的性能。

#示例 2：使用:=和var#原始代码（使用var）

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. )
   
7. 
   
8. func main() {
   
9.         start := time.Now()
   
10.         var total int
    
11.         for i := 0; i < 10000000; i++ {
    
12.                 total += i
    
13.         }
    
14.         fmt.Println(total)
    
15.         fmt.Println("Time taken:", time.Since(start))
    
16. }

复制代码

在这个例子中，我们使用 var 声明变量 total。在大多数情况下，var 声明会引入初始化开销。

#优化后的代码（使用:=）

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. )
   
7. 
   
8. func main() {
   
9.         start := time.Now()
   
10.         total := 0 // 这里改变了字符：使用短变量声明
    
11.         for i := 0; i < 10000000; i++ {
    
12.                 total += i
    
13.         }
    
14.         fmt.Println(total)
    
15.         fmt.Println("Time taken:", time.Since(start))
    
16. }

复制代码

在这个优化中，total 使用短变量声明 := 语法进行初始化，减少了初始化的开销，尤其在大型循环中可能会带来微小的性能提升。

#示例 3：字符串拼接#原始代码（使用 +）

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. )
   
7. 
   
8. func main() {
   
9.         start := time.Now()
   
10.         s := ""
    
11.         for i := 0; i < 10000; i++ {
    
12.                 s += "a" // 这里用 `+` 进行字符串拼接
    
13.         }
    
14.         fmt.Println(s)
    
15.         fmt.Println("Time taken:", time.Since(start))
    
16. }

复制代码

在这个示例中，使用 + 来拼接字符串，每次都会分配新的内存，造成性能开销。

#优化后的代码（使用 strings.Builder）

1. 
   
2. package main
   
3. 
   
4. import (
   
5.         "fmt"
   
6.         "strings"
   
7.         "time"
   
8. )
   
9. 
   
10. func main() {
    
11.         start := time.Now()
    
12.         var builder strings.Builder
    
13.         for i := 0; i < 10000; i++ {
    
14.                 builder.WriteString("a") // 这里改变了字符：使用 strings.Builder
    
15.         }
    
16.         s := builder.String()
    
17.         fmt.Println(s)
    
18.         fmt.Println("Time taken:", time.Since(start))
    
19. }

复制代码

#最后

这些示例展示了在 Go 语言中，通过改变一个字符（或结构），可以显著提高程序性能。

这些性能提升通常与内存管理、数据结构的选择和运算效率有关。在实际开发中，关注这些细节可以帮助我们编写出更高效的代码。