go官方标准编译器中实现的优化锦集汇总-Go夜读

最新推荐文章于 2026-06-16 18:17:41 发布
转载 最新推荐文章于 2026-06-16 18:17:41 发布 · 520 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
原文链接：https://www.bilibili.com/video/BV1YZ4y1K7w2
收录于
Golang

当前文章被收录于：

Golang
1 篇文章 0 人学习
订阅专栏 查看详情
本文介绍了Go语言的多项优化内容，包括字符串与字节切片转换、循环操作、结构体值处理、接口值包裹等方面的优化。还阐述了BCE（Bounds Check Elimination）优化，即编译器在某些情形下可避免不必要的下标越界检查，提升程序运行效率，有时需人为引导。

感谢 Go夜读
感谢 Go101

优化1

紧跟 range 关键字的从字符串到字节切片的转换

package main

import (
	"strings"
	"testing"
)

var gogogo = strings.Repeat("Go", 1024)

func f() {
	for range []byte(gogogo) {
	}
}

func g() {
	bs := []byte(gogogo)
	for range bs {
	}
}

func TestT1(t *testing.T) {
	t.Log(testing.AllocsPerRun(1, f)) // 0
	t.Log(testing.AllocsPerRun(1, g)) // 1
}

优化2

映射元素 读取 索引语法中被用做键值的从字节切片到字符串的转换

package main

var name = bytes.Repeat([]byte{'x'}, 33)

var m, s = make(map[string]string, 10), ""

func f() {
	s = m[string(name)]
}

func g() {
	key := string(name)
	s = m[key]
}

func h() {
	m[string(name)] = "Golang"
}

func TestT2(t *testing.T) {
		t.Log(testing.AllocsPerRun(1, f)) // 0
		t.Log(testing.AllocsPerRun(1, g)) // 1
		t.Log(testing.AllocsPerRun(1, h)) // 1
}

优化3

一个字符串比较表达式中被用做比较值的从字节切片到字符串的转换

package main

import "testing"

// optimize 3

var x = []byte{1023: 'x'}
var y = []byte{1023: 'y'}
var b bool

func f() {
	b = string(x) != string(y)
}

func g() {
	sx, sy := string(x), string(y)
	b = sx == sy
}

func TestT3(t *testing.T) {
		t.Log(testing.AllocsPerRun(1, f)) // 0
		t.Log(testing.AllocsPerRun(1, g)) // 2
}

优化4

含 非空字符串常量 的字符串衔接表达式中的从字节切片到字符串的转换

package main

import "testing"

// optimize 4

var x = []byte{1023: 'x'}
var y = []byte{1023: 'y'}
var s string

func f() {
	s = ("-" + string(x) + string(y))[1:]
}

func g() {
	s = string(x) + string(y)
}

func TestT4(t *testing.T) {
	t.Log(testing.AllocsPerRun(1, f)) // 1
	t.Log(testing.AllocsPerRun(1, g)) // 3
}

优化5

[]rune(aString) 转换的时间和空间复杂度都是O(n), 但是len([]rune(aString))中的此转换不许开辟内存

package main

import (
	"strings"
	"testing"
)

// optimize 5

var GoGoGo = strings.Repeat("Go", 100)

func f() {
	_ = len([]rune(GoGoGo))
}

func g() {
	_ = len([]byte(GoGoGo))
}

func TestT5(t *testing.T) {
	t.Log(testing.AllocsPerRun(1, f)) // 0
	t.Log(testing.AllocsPerRun(1, g)) // 1
}

优化6

字符串先切表达式只需开辟一次内存, 无论需要衔接多少个字符串

package main

import "testing"

// optimize 6

var x, y, z, w = "Hello ", "world! ", "Let's ", "Go!"
var s string

func f() {
	s = x + y + z + w
}

func g() {
	s = x + y
	s += z
	s += w
}

func TestT6(t *testing.T) {
	t.Log(testing.AllocsPerRun(1, f)) // 1
	t.Log(testing.AllocsPerRun(1, g)) // 3
}

优化7

for i:=range anArrayOrSlice {anArrayOrSlice[i] = zeroElement} 形式将被优化为一个内部的memclr操作

package main

import "testing"

// optimize 7

const N = 1024 * 100

var a [N]int

func clearArray() {
	for i := range a {
		a[i] = 0
	}
}

func clearSlice() {
	s := a[:]
	for i := range s {
		s[i] = 0
	}
}

func clearArrayPtr() {
	for i := range &a {
		a[i] = 0
	}
}

func BenchmarkT71(b *testing.B) {
	for i := 0; i < b.N; i++ {
		clearArray()
	}
}

func BenchmarkT72(b *testing.B) {
	for i := 0; i < b.N; i++ {
		clearSlice()
	}
}

func BenchmarkT73(b *testing.B) {
	for i := 0; i < b.N; i++ {
		clearArrayPtr()
	}
}

// Test Result

// goos: windows
// goarch: amd64
// pkg: github.com/gin-gonic/examples/grpc
// BenchmarkT71
// BenchmarkT71-4   	   53283	     22134 ns/op
// BenchmarkT72
// BenchmarkT72-4   	   53474	     22192 ns/op
// BenchmarkT73
// BenchmarkT73-4   	   27148	     41292 ns/op
// PASS
// coverage: [no statements]
//
// Process finished with exit code 0

优化8

for k = range m {delete(m, k)} 形式将被优化为一个内部的map清空操作

优化9

尺寸不大于4个原生字(即int) 并且字段数不超过4个的结构体值被视为是小尺寸值

package main

import "testing"

// optimize 9

type S1 struct{ a int }
type S2 struct{ a, b int }
type S3 struct{ a, b, c int }
type S4 struct{ a, b, c, d int }
type S5 struct{ a, b, c, d, e int }
type S6 struct{ a, b, c, d, e, f int }

var ss1, ss2, ss3, ss4, ss5, ss6 = make([]S1, 1000), make([]S2, 1000), make([]S3, 1000),
	make([]S4, 1000), make([]S5, 1000), make([]S6, 1000)
var x1, x2, x3, x4, x5, x6 int

func Benchmark_Range1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, v := range ss1 {
			x1 = v.a
		}
	}
}

func Benchmark_Range2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, v := range ss2 {
			x2 = v.a
		}
	}
}

func Benchmark_Range3(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, v := range ss3 {
			x3 = v.a
		}
	}
}

func Benchmark_Range4(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, v := range ss4 {
			x4 = v.a
		}
	}
}

func Benchmark_Range5(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, v := range ss5 {
			x5 = v.a
		}
	}
}

func Benchmark_Range6(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, v := range ss6 {
			x6 = v.a
		}
	}
}

// goos: windows
// goarch: amd64
// pkg: github.com/gin-gonic/examples/grpc
// Benchmark_Range1
// Benchmark_Range1-4   	 3486524	       332 ns/op
// Benchmark_Range2
// Benchmark_Range2-4   	 2941167	       409 ns/op
// Benchmark_Range3
// Benchmark_Range3-4   	 1824019	       658 ns/op
// Benchmark_Range4
// Benchmark_Range4-4   	 2939377	       411 ns/op
// Benchmark_Range5
// Benchmark_Range5-4   	  352924	      3447 ns/op
// Benchmark_Range6
// Benchmark_Range6-4   	  307684	      3710 ns/op
// PASS
// coverage: [no statements]
//
// Process finished with exit code 0

优化10

接口值包裹指针值比包裹其他类型的值要快 , 因为少开辟一次内存

package main

import "testing"

// optimize 10

var p, p2 = new([100]int), new([100]int)
var ip interface{}

func Benchmark_BoxPointer(b *testing.B) {
	for i := 0; i < b.N; i++ {
		ip = p
	}
}

func Benchmark_PointerAssert(b *testing.B) {
	for i := 0; i < b.N; i++ {
		p = ip.(*[100]int)
	}
}

func Benchmark_PointerAssign(b *testing.B) {
	for i := 0; i < b.N; i++ {
		p = p2
	}
}

// goos: windows
// goarch: amd64
// pkg: github.com/gin-gonic/examples/grpc
// Benchmark_BoxPointer
// Benchmark_BoxPointer-4      	1000000000	         0.807 ns/op
// Benchmark_PointerAssert
// Benchmark_PointerAssert-4   	1000000000	         0.891 ns/op
// Benchmark_PointerAssign
// Benchmark_PointerAssign-4   	1000000000	         0.662 ns/op
// PASS
// coverage: [no statements]
//
// Process finished with exit code 0

优化11

接口值包裹0-255的整数也很快 1.15开始

从Go工具链1.15开始, 在Go运行时内部维护着一个0-255的小数组. 但包裹0-255的整数时, 将直接包裹此数组的相应元素的指针而少开辟一次内存.
但是比直接包裹指针还是慢一点

package main

import "testing"

var x, y = 255, 256
var iy, ix interface{}

func Benchmark_x(b *testing.B) {
	for i := 0; i < b.N; i++ {
		ix = x
	}
}

func Benchmark_y(b *testing.B) {
	for i := 0; i < b.N; i++ {
		iy = y
	}
}

// goos: windows
// goarch: amd64
// pkg: github.com/gin-gonic/examples/grpc
// Benchmark_x
// 1.14
// Benchmark_x-4   	59999100	        17.4 ns/op
// 1.15
// Benchmark_x-4   	59999100	        2.98 ns/op
// Benchmark_y
// Benchmark_y-4   	70463887	        17.2 ns/op
// PASS
// coverage: [no statements]

BCE (Bounds Check Elimination) 优化

Go是一门内存安全的语言. 检查下标越界是保证内存安全的重要举措之一. 但另一方面检查下标越界也耗费一些CPU计算. 事实上绝大部分的下标越界检查都不会发现有问题的. 这就是维护内存安全的代价.
在某些情形下, 编译器在代码编译阶段可以确定某些下标越界检查是不必要的从而可以避免这些检查, 这样将提升程序运行效率
编译器并不总是足够的聪明, 有时需要人为干预引导编译器来消除一些下标越界检查.

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Go进阶概览 -【4.3 编译器的优化与调试】
Swxctx
09-13 1172
编译器优化在之前的章节我们有提到过，当时我们讲解了局部优化。 本节我们将进行更多的讲解，了解编译器的优化也可以帮助我们提高开发效率，在开发中即解决一些使用问题。
GoLang之Go内存管理及优化
weixin_52690231的博客
05-14 1843
GoLang之Go内存管理及优化
go语言笔记
weixin_45371595的博客
12-25 602
go语言笔记 单元测试除用来测试逻辑算法是否符合预期外，还承担着监控代码质量的责任 1、单侧要点 测试代码须放在当前包以"test.go"结尾的文件 ，测试命令忽略以"“或”."开头的测试文件，正常编译操作会忽略测试文件。 func main(){ var any interface{} any = 1 fmt.Println(any) any = "hello" fmt.Println(any) any = false fmt.Println(any) /*输出 PS D:\Go代码>
go test单元测试
专注技术分享
08-31 879
test代码命名规则 文件名要以 ‘_test’ 结尾 测试函数以 ‘Test’ 开头 实例 被测函数testMe.go package main func f1(n int) int{ if n == 0{ return 0 } if n == 1{ return 1 } return f1(n - 1) +f1(n -...
Go 官方标准编译器中所做的优化
techdashen的博客
08-30 1312
5.[]rune(aString)转换的时间和空间复杂度都是O(n),但len([]rune(aString))中的此转换 不需要开辟内存。9.尺寸不大于4个原生字(即int),并且字段数不超过4个的结构体值被视为是小尺寸值。2.映射元素读取索引语法中被用做键值的 从字节切片到字符串的转换；3.字符串比较表达式中被用做比较值的 从字节切片到字符串的转换。10.接口值包裹 指针值 比 包裹 其他类型的值 要快。的字符串衔接表达式中的 从字节切片到字符串的转换。关键字的 从字符串到字节切片的转换；
go语言编译优化
q1454739828的博客
03-25 1531
go语言编译优化 go语言能够快速编译成二进制可执行文件，能够加速程序的发布和安装流程。下面我们将编译选项和第三方压缩工具两方面来介绍如何有效地减小 Go 语言编译后的体积。 下面我们写一个简单的测试工程来测试不同方式的效果 下面的程序启动一个RPC服务， package main import ( "log" "net/http" "net/rpc" ) // 编译优化 type Result struct { Num, Ans int } type Calc int func (calc
Go夜读项目完整指南：从源码阅读到技术社区的7年成长之路
最新发布
gitblog_00729的博客
06-16 513
Go夜读是一个专注于Go语言学习的开源技术社区，通过每周四晚上的线上直播分享，为全球Gopher提供高质量的Go语言技术交流平台。这个项目从2018年3月21日启动至今，已经成长为拥有超过10000星标的知名开源社区，成为Go开发者不可错过的技术学习资源库。 ## 📈 发展历程：从线下小聚到万人社区 Go夜读的成长历程是一个典型的开源社区发展故事。项目最初只是几个Go爱好者的线下技术交流活动
Go夜读内存对齐：结构体布局与性能优化技巧
gitblog_00478的博客
10-14 692
你是否曾疑惑为什么Go结构体的大小总是比字段总和大？为什么调整字段顺序能减少内存占用？为什么在32位系统操作64位变量可能引发panic？本文将通过图解和实战案例，深入解析Go内存对齐的底层原理，带你掌握结构体布局优化的核心技巧，让代码既高效又安全。 ## 内存对齐的价值：为什么不能忽视 内存对齐是计算机系统的底层要求，指数据在内存中的起始地址必须是特定值的倍数。现代CPU访问内存时并非逐个字...
go每日新闻--2020-08-16
韩亚军的博客
08-17 469
go 语言中文网(每日资讯)_2020-08-16 一、Go 语言中文网 Go 语言爱好者周刊：第 56 期 — 最全 LeetCode 刷题指南 面试题：设计具备 putAll 功能的哈希表，时间复杂度限定 O(1) Facebook 对 Golang 依赖注入的实现 【面试必备】刨根问底系列之 https 到底是如何防篡改的？ 二、亚军进化史 Go 技术日报(2020-08-15) 三、Go 夜读 【下周三预告】第 102 期官方标准编译器中实现的优化集锦 四、Bingo Huang 【思维.
go语言最全优化技巧总结，值得收藏！
QcloudCommunity的博客
08-23 1310
导语|本文总结了在维护go基础库过程中，用到或者见到的一些性能优化技巧，现将一些理解梳理撰写成文，和大家探讨。一、常规手段（一）sync.Pool临时对象池应该是对可读性影响最小且优化...
Go性能优化及实践
qq_62215764的博客
01-19 1137
本文主要介绍了Go语言性能优化，包括自动内存管理，Go内存管理，编译器与静态分析，编译器优化，并对上述优化建议进行实践，包括Balanced GC优化对象分配，Beast Mode等。
GO内存支配&编译器优化
youcpdd的博客
01-19 462
1.Go内存管理—分块2.Go内存管理—缓存3.Go对象分配的性能问题
Go语言中的性能考虑和优化
csjds的专栏
12-30 1724
我们将深入探讨三个关键领域：分析并发代码、识别瓶颈以及实施负载均衡和可扩展性策略。通过本文，您将对如何优化您的Go代码以达到最佳性能有一个坚实的了解。
Go 语言性能优化指南
Keep coding！
04-16 908
继上次课程的高质量编程内容讲解，本次课程主要介绍了在满足正确性、可靠性、健壮性、可读性等质量因素的前提下提高程序效率的性能优化建议；性能优化分析工具；以及性能调优的实战案例，分享了业务优化、基础库优化和 Go 语言优化的流程和方式 …
Go 从编译到执行
Lamb的博客
11-29 853
Go语言（也称为Golang）自从2009年由Google发布以来，已成为现代软件开发中不可或缺的一部分。设计者Rob Pike, Ken Thompson和Robert Griesemer致力于解决多核处理器、网络系统和大型代码库所引发的现实世界编程问题。我们将深入探讨Go语言在运行和编译方面的核心思考点。
【字节跳动青训营】Go编译器优化
大河之犬的博客
05-14 903
将被调用函数的函数体的副本替换到调用位置上，同时重写代码以反映参数的绑定。
Golang编译优化——稀疏条件常量传播
yelvens的博客
05-08 1768
常量传播（constant propagation）是一种转换，对于给定的关于某个变量xxx和一个常量ccc的赋值x←cx←c，这种转换用ccc来替代以后出现的xxx的引用，只要在这期间没有出现另外改变xxx值的赋值。如下图a的CFG所示，基本块B1中的指令b←3b←3将常量3赋给bbb，并且CFG中没有其他对bbb的赋值。图b是对图a做常量传播的结果，此时bbb。
Go语言编译器优化技术的研究与展望
kjj987的博客
03-23 395
在早期版本中，编译器注重语言特性的实现和基础功能的完善，对优化的重视程度相对较低。未来，随着人工智能、新兴硬件架构等技术的发展，Go语言编译器有望在优化策略、对新兴技术的支持以及跨平台编译等方面取得突破，为Go语言在更多领域的广泛应用提供更强大的技术支持，推动Go语言生态系统的持续繁荣和发展。例如，对于x86架构的处理器，编译器会充分利用其丰富的指令集，选择合适的指令来实现程序功能，同时考虑指令的并行性和流水线效率，通过指令调度优化技术，调整指令执行顺序，减少指令间的依赖和等待时间，提高代码执行的并行度。
2. Go 性能调优之 —— 编译优化
weixin_33769207的博客
09-11 2469
原文链接：https://github.com/sxs2473/go...本文使用 Creative Commons Attribution-ShareAlike 4.0 International 协议进行授权许可。 编译优化 本节介绍Go编译器执行的三个重要优化。 逃逸分析 内联 死码消除 Go 编译器的历史 Go 编译器在200...
go语言的测试覆盖（2）
Bruce
08-03 1028
今天讲一下go语言的test coverage是如何实现的。 上篇讲到了go语言1.2之前对于测试覆盖的支持，使用了比较“传统”的做法，也就是对于二进制文件的analysis和instrument。 从go v1.2开始，新的测试覆盖工具使用了完全不同的方法。思路非常简单：在编译之前重写源文件，在源文件中加入一些instrument，然后编译和执行被修改的源文件，得到覆盖的统计信息。重写源文件其实不难，得益于go强大的命令行工具 - 它负责从源文件编译，到执行测试，直到程序的执行全盘搞定 - 所以在这个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值