Go on pemako

Go pprof 性能分析

Thu, 09 Apr 2026 20:00:00 +0800

pprof 是 Golang自带的一款开箱即用的性能监控和分析工具。 go的pprof提供了2个工具供我们使用，runtime/pprof中是它的源码，net/http/pprof对源码做了简单封装，能让你在http服务中直接使用。

它可以采样程序运行时的CPU、堆内存、Goroutine、锁竞争、阻塞调用、系统线程的使用情况。然后通过可视化终端或网页的形式展示给用户，用户可以通过列表、调用图、源码、火焰图、反汇编等视图去展示采集到的性能指标

使用步骤

1，在代码中使用 net/http/pprof 来开启，基于 HTTP Server 运行

import _ "net/http/pprof"

2，生产 profile 文件

# http 服务对外暴露的端口，可以是本地也可以是远程的地址
go tool pprof http://localhost:8090/debug/pprof/profile

3，使用 web ui 来查看 profile 文件

 go tool pprof -http localhost:6060 profile.gz

实际使用示例

# 第一步获取 profile 文件信息， 获取后可以直接命令行模式下查看
go tool pprof http://10.0.0.212:7866/debug/pprof/profile
Fetching profile over HTTP from http://10.0.0.212:7866/debug/pprof/profile
Saved profile in /Users/mako/pprof/pprof.polaris-server.samples.cpu.003.pb.gz
File: polaris-server
Type: cpu
Time: Jul 15, 2024 at 2:57pm (CST)
Duration: 30.03s, Total samples = 5.45s (18.15%)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof)


# 使用web ui 查看
go tool pprof -http localhost:6060 pprof.polaris-server.samples.cpu.003.pb.gz
Serving web UI on http://localhost:6060

效果

Go 代码规范

Thu, 09 Apr 2026 20:00:00 +0800

Golang 代码规范 #

[TOC]

1. 前言 #

为形成公司统一的 Go 编码风格，以保障公司项目代码的易维护性和编码安全性，特制定本规范。

本规范在 Google Golang 代码规范的基础上，根据腾讯实际情况进行了调整和补充。

每项规范内容，给出了要求等级，其定义为：

必须（Mandatory）：用户必须采用；
推荐（Preferable）：用户理应采用，但如有特殊情况，可以不采用；
可选（Optional）：用户可参考，自行决定是否采用；

目前本规范以 Gometalinter 工具落地，点击查看工具源码。

2. 代码风格 #

2.1 【必须】格式化 #

代码都必须用 gofmt 格式化。

2.2 【推荐】换行 #

建议一行代码不要超过120列，超过的情况，使用合理的换行方法换行。
例外场景：
- import 模块语句
- 工具生成代码
- struct tag

2.3 【必须】括号和空格 #

遵循 gofmt 的逻辑。
运算符和操作数之间要留空格。
作为输入参数或者数组下标时，运算符和运算数之间不需要空格，紧凑展示。

2.4 【必须】import 规范 #

使用 goimports 自动格式化引入的包名，import 规范原则上以 goimports 规则为准。
goimports 会自动把依赖包按首字母排序，并对包进行分组管理，通过空行隔开，默认分为本地包（标准库、内部包）、第三方包。
标准包永远位于最上面的第一组。
内部包是指不能被外部 import 的包，如 GoPath 模式下的包名或者非域名开头的当前项目的 GoModules 包名。

Go 内存管理

Thu, 09 Apr 2026 20:00:00 +0800

在 Go 或其他编程语言中，内存分配在堆（heap）和栈（stack）上有明显的区别。以下是两者的概念、特点和区别的详细说明：

栈（Stack）

栈内存是一种快速、高效的内存分配方式，通常用于存储函数调用期间的局部变量。

特点 • 内存分配： • 在函数调用时自动分配。 • 在函数返回时自动释放（自动管理）。 • 作用域： • 存储局部变量（比如函数内声明的变量）。 • 生命周期受限于函数作用域，函数退出后变量被销毁。 • 分配速度： • 分配速度快，因为栈是按顺序分配内存。 • 空间大小： • 通常栈空间有限（在 Go 中，栈的初始大小是 2KB，动态增长至 1GB）。 • 线程独立性： • 每个 Goroutine 都有自己的栈。

使用场景 • 存储函数的局部变量、参数和返回地址。 • 轻量、短期使用的内存。

堆（Heap）

堆内存是一种灵活的内存分配方式，适用于需要跨函数或长期使用的内存。

特点 • 内存分配： • 通过动态分配（如 new 或 make）申请。 • 不会自动释放，需要由垃圾回收器（GC）管理。 • 作用域： • 分配的内存可以在函数返回后继续存在（通常用于共享内存）。 • 分配速度： • 分配速度相对较慢，因为需要复杂的内存管理。 • 空间大小： • 堆的内存大小较大，但分配和回收消耗更多资源。 • 线程共享性： • 堆内存是全局共享的，所有 Goroutine 都可以访问。

Go 安全规范

Thu, 09 Apr 2026 20:00:00 +0800

通用类 #

1. 代码实现类 #

1.1 内存管理 #

1.1.1【必须】切片长度校验 #

在对slice进行操作时，必须判断长度是否合法，防止程序panic

// bad: 未判断data的长度，可导致 index out of range 
func decode(data [] byte) bool {
 if data[0] == 'F' && data[1] == 'U' && data[2] == 'Z' && data[3] == 'Z' && data[4] == 'E' && data[5] == 'R' {
 fmt.Println("Bad")
 return true
 }
 
 return false
}

// bad: slice bounds out of range
func foo() {
 var slice = []int{0, 1, 2, 3, 4, 5, 6}
 fmt.Println(slice[:10]) 
}

// good: 使用data前应判断长度是否合法 
func decode(data [] byte) bool {
 if len(data) == 6 {
 if data[0] == 'F' && data[1] == 'U' && data[2] == 'Z' && data[3] == 'Z' && data[4] == 'E' && data[5] == 'R' {
 fmt.Println("Good")
 return true
 }
 }
	
 return false
}

1.1.2【必须】nil指针判断 #

进行指针操作时，必须判断该指针是否为nil，防止程序panic，尤其在进行结构体Unmarshal时

type Packet struct {
 PackeyType uint8
 PackeyVersion uint8
 Data *Data
}

type Data struct {
 Stat uint8
 Len 	uint8
 Buf 	[8]byte
}

func (p *Packet) UnmarshalBinary(b []byte) error {
 if len(b) < 2 {
 return io.EOF
 }
 
 p.PackeyType = b[0]
 p.PackeyVersion = b[1]
 
 // 若长度等于2，那么不会new Data
 if len(b) > 2 {
 p.Data = new(Data)
 // Unmarshal(b[i:], p.Data)
 }
 
 return nil
}

// bad: 未判断指针是否为nil
func main() {
 packet := new(Packet)
 data := make([]byte, 2)
 if err := packet.UnmarshalBinary(data); err != nil {
 fmt.Println("Failed to unmarshal packet")
 return
 }
 
 fmt.Printf("Stat: %v\n", packet.Data.Stat)
}

// good: 判断Data指针是否未nil
func main() {
 
 packet := new(Packet)
 data := make([]byte, 2)
 
 if err := packet.UnmarshalBinary(data); err != nil {
 fmt.Println("Failed to unmarshal packet")
 return
 }
 
 if packet.Data == nil {
 return
 }
 
 fmt.Printf("Stat: %v\n", packet.Data.Stat)
}

1.1.3【必须】整数安全 #

在进行数字运算操作时，需要做好长度限制，防止外部输入运算导致异常：

Go 开源库

Thu, 09 Apr 2026 20:00:00 +0800

参考 #

bubbletea

仓库地址 term

github.com/pkg/term 是一个专业的终端和串口控制库，填补了 Go 标准库在底层终端操作方面的空白。它特别适合：

嵌入式系统开发
串口设备通信
交互式终端应用
工业控制系统
需要精确控制终端行为的应用程序

该库的核心价值在于提供了简洁的 Go 语言接口来访问复杂的 POSIX termios 功能，让开发者无需深入了解底层系统调用细节就能实现专业的终端和串口控制。

如果仅仅开发 CLI 工具推荐使用 golang.org/x/term

例如要开发一个需要用户在终端输入密码的 CLI 工具时，输入密码时不要显示出来可以这样处理

package main

import (
	"fmt"
	"os"

	"golang.org/x/term"
)

func main() {
	fmt.Print("请输入密码: ")

	// 使用 golang.org/x/term 的 ReadPassword 函数
	// 它会自动处理终端状态的保存和恢复,并隐藏输入
	password, err := term.ReadPassword(int(os.Stdin.Fd()))
	if err != nil {
		panic(err)
	}

	fmt.Println()
	fmt.Printf("密码 %v\n", string(password))
}

效果如下

➜ term-password go run ./main.go
请输入密码: 
密码 打印输入的密码

`x/term` vs `pkg/term` #

包	本质定位
golang.org/x/term	给 CLI 用的终端工具
github.com/pkg/term	给系统/串口/设备用的终端 & 串口控制库

golang.org/x/term 本质上是：通过系统调用，临时修改“终端驱动”的工作模式，让程序接管键盘输入和屏幕输出的解释权。它不操作屏幕、不画 UI、不拦截键盘硬件，它操作的是：内核里的 TTY（终端）状态机

Go 标准库

Thu, 09 Apr 2026 20:00:00 +0800

自定义 Transport
请求存在 302 跳转的时候支持携带上 cookie

type LogRedirects struct {
	Transport http.RoundTripper
}

func (l LogRedirects) RoundTrip(req *http.Request) (resp *http.Response, err error) {
	t := l.Transport
	if t == nil {
		t = http.DefaultTransport
	}
	resp, err = t.RoundTrip(req)
	if err != nil {
		return
	}
	switch resp.StatusCode {
	case http.StatusMovedPermanently, http.StatusFound, http.StatusSeeOther, http.StatusTemporaryRedirect:
		fmt.Println("Request Method", req.Method, "Request for", req.URL, "redirected with status", resp.StatusCode)
	}
	return
}

func login() {
	client := &http.Client{Transport: LogRedirects{}} // 记录中间每次 302 请求的跳转地址
	request, err := http.NewRequest("GET", "http://kuboard-dev.domob-inc.cn/login?state=%2F", nil)
	if err != nil {
		return
	}

	response, err := client.Do(request)
	if err != nil {
		return
	}
	defer response.Body.Close()

	reqURL := response.Request.URL.String()
	rParams := url.Values{}
	rParams.Add("login", "admin")
	rParams.Add("password", `{"password":"xxxx","passcode":""}`)
	request2, err := http.NewRequest("POST", reqURL, strings.NewReader(rParams.Encode()))
	request2.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	request2.Header.Set("Referer", reqURL)
	if err != nil {
		return
	}
	// 如果页面有重定向的时候cookie不会被携带，这里需要重新设置如下两行，可以在重定向后获取到请求的cookie信息
	jar, _ := cookiejar.New(nil)
	client = &http.Client{Jar: jar}
	response2, err := client.Do(request2)
	if err != nil {
		return
	}
	defer response2.Body.Close()

	for _, cookie := range response2.Request.Cookies() {
		fmt.Println(cookie.Name, cookie.Value, cookie.Expires)
	}
}

WithDeadline

package main

import (
	"context"
	"fmt"
	"time"
)

func dl2(ctx context.Context) {
	n := 1
	for {
		select {
		case <-ctx.Done():
			fmt.Println(ctx.Err())
			return
		default:
			fmt.Println("dl2 : ", n)
			n++
			time.Sleep(time.Second)
		}
	}
}

func dl1(ctx context.Context) {
	n := 1
	for {
		select {
		case <-ctx.Done():
			fmt.Println(ctx.Err())
			return
		default:
			fmt.Println("dl1 : ", n)
			n++
			time.Sleep(3 * time.Second)
		}
	}
}

func main() {
	// 设置deadline为当前时间之后的5秒那个时刻
	d := time.Now().Add(5 * time.Second)
	ctx, cancel := context.WithDeadline(context.Background(), d)
	defer cancel()
	go dl1(ctx)
	go dl2(ctx)
	for {
		select {
		case <-ctx.Done():
			fmt.Println("over", ctx.Err())
			return
		}
	}
}

WithTimeout

package main

import (
	"context"
	"fmt"
	"time"
)

func to1(ctx context.Context) {
	n := 1
	for {
		select {
		case <-ctx.Done():
			fmt.Println("to1 is over")
			return
		default:
			fmt.Println("to1 : ", n)
			n++
			time.Sleep(time.Second)
		}
	}
}

func main() {
	// 设置为6秒后context结束
	ctx, cancel := context.WithTimeout(context.Background(), 6*time.Second)
	defer cancel()
	go to1(ctx)
	n := 1
	for {
		select {
		case <-time.Tick(2 * time.Second):
			if n == 9 {
				return
			}
			fmt.Println("number :", n)
			n++
		}
	}
}

WithCancel

package main

import (
	"context"
	"fmt"
	"time"
)

func MyOperate1(ctx context.Context) {
	for {
		select {
		default:
			fmt.Println("MyOperate1", time.Now().Format("2006-01-02 15:04:05"))
			time.Sleep(2 * time.Second)
		case <-ctx.Done():
			fmt.Println("MyOperate1 Done")
			return
		}
	}
}
func MyOperate2(ctx context.Context) {
	fmt.Println("Myoperate2")
}
func MyDo2(ctx context.Context) {
	go MyOperate1(ctx)
	go MyOperate2(ctx)
	for {
		select {
		default:
			fmt.Println("MyDo2 : ", time.Now().Format("2006-01-02 15:04:05"))
			time.Sleep(2 * time.Second)
		case <-ctx.Done():
			fmt.Println("MyDo2 Done")
			return
		}
	}

}
func MyDo1(ctx context.Context) {
	go MyDo2(ctx)
	for {
		select {
		case <-ctx.Done():
			fmt.Println("MyDo1 Done")
			// 打印 ctx 关闭原因
			fmt.Println(ctx.Err())
			return
		default:
			fmt.Println("MyDo1 : ", time.Now().Format("2006-01-02 15:04:05"))
			time.Sleep(2 * time.Second)
		}
	}
}
func main() {
	// 创建 cancelCtx 实例
	// 传入context.Background() 作为根节点
	ctx, cancel := context.WithCancel(context.Background())
	// 向协程中传递ctx
	go MyDo1(ctx)
	time.Sleep(5 * time.Second)
	fmt.Println("stop all goroutines")
	// 执行cancel操作
	cancel()
	time.Sleep(2 * time.Second)
}

WithValue

package main

import (
	"context"
	"fmt"
	"time"
)

func v3(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println("v3 Done : ", ctx.Err())
			return
		default:
			fmt.Println(ctx.Value("key"))
			time.Sleep(3 * time.Second)
		}
	}
}

func v2(ctx context.Context) {
	fmt.Println(ctx.Value("key"))
	fmt.Println(ctx.Value("v1"))
	// 相同键,值覆盖
	ctx = context.WithValue(ctx, "key", "modify from v2")
	go v3(ctx)
}

func v1(ctx context.Context) {
	if v := ctx.Value("key"); v != nil {
		fmt.Println("key = ", v)
	}
	ctx = context.WithValue(ctx, "v1", "value of v1 func")
	go v2(ctx)
	for {
		select {
		default:
			fmt.Println("print v1")
			time.Sleep(time.Second * 2)
		case <-ctx.Done():
			fmt.Println("v1 Done : ", ctx.Err())
			return
		}
	}
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	// 向context中传递值
	ctx = context.WithValue(ctx, "key", "main")
	go v1(ctx)
	time.Sleep(10 * time.Second)
	cancel()
	time.Sleep(3 * time.Second)
}

参考:https://studygolang.com/articles/29504

源码分析阅读

Go 程序启动

Thu, 09 Apr 2026 20:00:00 +0800

本文由简悦 SimpRead 转码，原文地址 mp.weixin.qq.com

刚开始写这篇文章的时候，目标非常大，想要探索 Go 程序的一生：编码、编译、汇编、链接、运行、退出。它的每一步具体如何进行，力图弄清 Go 程序的这一生。

在这个过程中，我又复习了一遍《程序员的自我修养》。这是一本讲编译、链接的书，非常详细，值得一看！数年前，我第一次看到这本书的书名，就非常喜欢。因为它模仿了周星驰喜剧之王里出现的一本书 ——《演员的自我修养》。心向往之！

在开始本文之前，先推荐一位头条大佬的博客——《面向信仰编程》，他的 Go 编译系列文章，非常有深度，直接深入编译器源代码，我是看了很多遍了。博客链接可以从参考资料里获取。

理想很大，实现的难度也是非常大。为了避免砸了 “深度解密” 这个牌子，这次起了个更温和的名字，嘿嘿。

下面是文章的目录：

引入 #

我们从一个 HelloWorld 的例子开始：

package main
import "fmt"
func main() {
 fmt.Println("hello world")
}

当我用我那价值 1800 元的 cherry 键盘潇洒地敲完上面的 hello world 代码时，保存在硬盘上的 hello.go 文件就是一个字节序列了，每个字节代表一个字符。

用 vim 打开 hello.go 文件，在命令行模式下，输入命令：

:%!xxd

就能在 vim 里以十六进制查看文件内容：

最左边的一列代表地址值，中间一列代表文本对应的 ASCII 字符，最右边的列就是我们的代码。再在终端里执行 man ascii：

和 ASCII 字符表一对比，就能发现，中间的列和最右边的列是一一对应的。也就是说，刚刚写完的 hello.go 文件都是由 ASCII 字符表示的，它被称为 文本文件，其他文件被称为 二进制文件。

Go 语言基础

Thu, 09 Apr 2026 20:00:00 +0800

语言详解 #

类型 #

变量
- 使用 var 可以一次定义多个变量
- 简短模式 声明变量只能在函数内部使用
- 简短模式 并不总是重新定义变量，也可能是不分退化的赋值操作
  - 退化赋值的前提条件是:至少有一个新变量被定义，且必须是同一作用域
- 变量定义就要使用，否则编译会报错
命名
- 以字母或下划线开始，有多个字母数字和下划线组合而成，区分大小写
- 局部变量优先使用短名
- 不要使用保留关键字
- 专有名词通常全部大写，如 escapeHTML
- 首字母大写的为导出成员，可被包外引用，而小写则仅能在包内使用
- _ 空标识符，忽略占位符使用

常量

常量的值必须是编译期可确定的字符，字符串，数组或布尔值。可指定常量的类型，或由编译器通过初始化推断。

可在函数代码块中定义常量，不曾使用的常量不会引发编译错误
常量值也可以是某些编译器能计算出结果的表达式，如unsafe.Sizeof、len、cap 等

import "unsafe"
const (
 ptrSize = unsafe.Sizeof(uintptr(0))
 strSize = len("hello, world!")
)

在常量组中如果不指定类型和初始化值，则与上一行非空常量右值(表达式文本)相同

import "fmt"
func main() {
 const (
 x uint16 = 10
 y // 与上一行的 x 类型和值相同
 s = "abc"
 z // 与上面 s 类型和值相同
 )
 fmt.Printf("%T, %v\n", y, y) // uint16, 120
 fmt.Printf("%T, %v\n", z, z) // string, abc
}

借助iota 标识符实现一组自增常量值来事项枚举类型

const (
 _ = iota // 0
 KB = 1 << (10 * iota) // 1 << (10*1)
 MB // 1 << (10*2)
 GB // 1 << (10*3) 
)

// 可在多常量定义中使用多个 iota,他们各自单独计数，只需保证每组中每行常量的列数量相同即可
const (
 _, _ = iota, iota * 10 // 0, 0 * 10
 a, b // 1, 1 * 10
 c, d // 2, 2 * 10
)

// 如终端 iota 自增，则必须显示恢复。且后续自增值按行序递增
const (
 a = iota // 0
 b // 1
 c = 100 // 100
 d // 100
 e = iota // 4 (恢复 iota 自增，计数包括 c, d)
 f // 5
)

在实际编码中，建议用自定义类型实现用途明确的枚举类型

基本类型

Unsafe

Sun, 27 Apr 2025 12:50:41 +0800

unsafe 包学习 #

uintptr 和 unsafe.Pointer 的区别

unsafe.Pointer 只是单纯的通用指针类型，用于转换不同类型指针，它不可以参与指针运算
而 uintptr 是用于指针运算的，GC 不把 uintptr 当指针，也就是说 uintptr 无法持有对象， uintptr 类型的目标会被回收
unsafe.Pointer 可以和普通指针进行相互转换
unsafe.Pointer 可以和 uintptr 进行相互转换

示例 #

package main

import (
 "fmt"
 "unsafe"
)

type W struct {
 b int32
 c int64
}

func main() {
 var w = new(W)
 fmt.Println(w.b, w.c)

 // 通过指针运算给 b 变量赋值
 b := unsafe.Pointer(uintptr(unsafe.Pointer(w)) + unsafe.Offsetof(w.b))
 *((*int)(b)) = 100

 fmt.Println(w.b, w.c)
}


// uintptr(unsafe.Pointer(w)) 获取了 w 的指针起始值
// unsafe.Offsetof(w.b) 获取 b 变量的偏移量
// 两个相加就得到了 b 的地址值，将通用指针 Pointer 转换成具体指针 ((*int)(b))，通过 * 符号取值，然后赋值。*((*int)(b)) 相当于把 (*int)(b) 转换成 int 了，最后对变量重新赋值成 10，这样指针运算就完成了

Go on pemako

Go pprof 性能分析

Go 代码规范

Golang 代码规范 #

1. 前言 #

2. 代码风格 #

2.1 【必须】格式化 #

2.2 【推荐】换行 #

2.3 【必须】括号和空格 #

2.4 【必须】import 规范 #

Go 内存管理

Go 安全规范

通用类 #

1. 代码实现类 #

1.1 内存管理 #

1.1.1【必须】切片长度校验 #

1.1.2【必须】nil指针判断 #

1.1.3【必须】整数安全 #

Go 开源库

参考 #

x/term vs pkg/term #

Go 标准库

Go 程序启动

引入 #

Go 语言基础

语言详解 #

类型 #

Unsafe

unsafe 包学习 #

示例 #

`x/term` vs `pkg/term` #