Go on Inkwell Corner

go net/http 学习笔记

Sun, 07 Dec 2025 14:18:38 +0800

概述

在使用 Go 开发时几乎都会用到 net/http 标准库。但是，对库的内部实现不了解，仅限于会用。遇到问题容易懵，比如：

长连接和短连接有什么区别？具体什么实现原理？
net/http 如何处理并发请求？
net/http 有用到缓存吗？缓存用来干什么？
……

单个问题各个击破，不如深入梳理下 net/http 标准库一网打尽。本文将深入学习 net/http 标准库，力图做到知其然知其所以然。

go ants pool 协程池学习笔记

Mon, 24 Nov 2025 12:08:38 +0800

概述

使用 Go 开发并发程序很容易，一个 go 关键字就可以启动协程处理任务。Go 创建一个 goroutine 只需要 2K 内存空间，并且 go 协程上下文信息仅存储在两个寄存器中，对于 Go 运行时来说，切换上下文特别快。

go sync.pool 学习笔记

Sun, 09 Nov 2025 18:35:38 +0800

概述

sync.pool 对象池可以用来复用临时对象，减少内存压力，降低 GC 压力。

示例

基本用法

 1type Worker struct{}  
 2  
 3func (w *Worker) Name() string {  
 4    return "worker"  
 5}  
 6  
 7func main() {  
 8    workerPool := sync.Pool{New: func() interface{} {  
 9       return Worker{}  
10    }}  
11  
12    worker := workerPool.Get().(Worker)  
13    defer workerPool.Put(worker)  
14  
15    name := worker.Name()  
16    fmt.Println(name)  
17}

sync.pool 是单对象池，不是多对象池。基本使用方法是 Get 和 Put 方法，Get 用来从对象池中取对象，Put 用来将不用的对象放回对象池中。

go 源码编译流程

Sun, 27 Jul 2025 22:18:38 +0800

Go 源码编译流程

Go 编译源代码需要经过编译，链接过程。通过以下示例看 Go (Go 版本为 v1.24.1)语言是如何编译源码的。

首先，代码目录结构如下：

 1➜  demo1 git:(main) ✗ tree ./
 2./
 3├── cmd
 4│   └── app1
 5│       └── main.go
 6└── pkg
 7    └── pkg1
 8        └── pkg1.go
 9
10// main.go
11package main
12
13import "github.com/TroyXia/effective-go-book/chapter3/demo1/pkg/pkg1"
14
15func main() {
16	pkg1.Func1()
17}
18
19// pkg1.go
20package pkg1
21
22import "fmt"
23
24func Func1() {
25	fmt.Println("pkg1.Func1 invoked")
26}

编译 app1 main.go 为可执行文件：

Go runtime 调度器精讲（十一）：总览全局

Tue, 17 Sep 2024 10:15:38 +0800

前言

前面用了十讲介绍了 Go runtime 调度器，这一讲结合一些图在总览下 Go runtime 调度器。

状态转换图

首先是 Goroutine 的状态转换图：

大部分转移路径前面几讲也介绍过，这里就不继续介绍了(下同)。

Go runtime 调度器精讲（十）：异步抢占

Mon, 16 Sep 2024 20:20:38 +0800

前言

前面介绍了运行时间过长和系统调用引起的抢占，它们都属于协作式抢占。本讲会介绍基于信号的真抢占式调度。

在介绍真抢占式调度之前看下 Go 的两种抢占式调度器：

Go runtime 调度器精讲（九）：系统调用引起的抢占

Mon, 16 Sep 2024 12:01:38 +0800

前言

第八讲介绍了当 goroutine 运行时间过长会被抢占的情况。这一讲继续看 goroutine 执行系统调用时间过长的抢占。

系统调用时间过长的抢占

看下面的示例：

 1func longSyscall() {
 2	timeout := syscall.NsecToTimeval(int64(5 * time.Second))
 3	fds := make([]syscall.FdSet, 1)
 4
 5	if _, err := syscall.Select(0, &fds[0], nil, nil, &timeout); err != nil {
 6		fmt.Println("Error:", err)
 7	}
 8
 9	fmt.Println("Select returned after timeout")
10}
11
12func main() {
13	threads := runtime.GOMAXPROCS(0)
14	for i := 0; i < threads; i++ {
15		go longSyscall()
16	}
17
18	time.Sleep(8 * time.Second)
19}

longSyscall goroutine 执行一个 5s 的系统调用，在系统调用过程中，sysmon 会监控 longSyscall，发现执行系统调用过长，会对其抢占。

Go runtime 调度器精讲（八）：运行时间过长的抢占

Mon, 16 Sep 2024 01:10:38 +0800

前言

在 Go runtime 调度器精讲（七）：案例分析一文我们介绍了一个抢占的案例。从案例分析抢占的实现，并未涉及到源码层面。本文将继续从源码入手，看 Go runtime 调度器是如何实现抢占逻辑的。

Go runtime 调度器精讲（七）：案例分析

Sun, 15 Sep 2024 18:21:38 +0800

前言

前面用了六讲介绍 Go runtime 调度器，这一讲我们看一个关于调度 goroutine 的程序案例分析下调度器做了什么。需要说明的是，这个程序和抢占有关，抢占目前为止还没有介绍到，如果看不懂也没有关系，有个印象就行。

Go runtime 调度器精讲（六）：非 main goroutine 运行

Sat, 14 Sep 2024 18:40:38 +0800

前言

在 Go runtime 调度器精讲（三）：main goroutine 创建介绍了 main goroutine 的创建，文中我们说 main goroutine 和非 main goroutine 有区别。当时卖了个关子并未往下讲，这一讲我们会继续介绍非 main goroutine (也就是 go 关键字创建的 goroutine，后文统称为 gp) 的运行，并且把这个关子解开，说一说它们的区别在哪儿。

Go runtime 调度器精讲（五）：调度策略

Sat, 14 Sep 2024 12:38:38 +0800

前言

在第四讲我们介绍了 main goroutine 是如何运行的。其中针对 main goroutine 介绍了调度函数 schedule 是怎么工作的，对于整个调度器的调度策略并没有介绍，这点是不完整的，这一讲会完善调度器的调度策略部分。

Go runtime 调度器精讲（四）：运行 main goroutine

Fri, 13 Sep 2024 17:24:38 +0800

前言

皇天不负有心人，终于我们到了运行 main goroutine 环节了。让我们走起来，看看一个 goroutine 到底是怎么运行的。

运行 goroutine

稍微回顾下前面的内容，第一讲 Go 程序初始化，介绍了 Go 程序是怎么进入到 runtime 的，随之揭开 runtime 的面纱。第二讲，介绍了调度器的初始化，要运行 goroutine 调度器是必不可少的，只有调度器准备就绪才能开始工作。第三讲，介绍了 main goroutine 是如何创建出来的，只有创建一个 goroutine 才能开始运行，否则执行代码无从谈起。这一讲，我们继续介绍如何运行 main goroutine。

Go runtime 调度器精讲（三）：main goroutine 创建

Fri, 13 Sep 2024 11:23:38 +0800

前言

回顾下上一讲的内容。主线程 m0 蓄势待发，准备干活。g0 为 m0 提供了执行环境，P 和 m0 绑定，为 m0 提供活，也就是 goroutine。那么问题来了，活呢？哪里有活给 m0 干？

Go runtime 调度器精讲（二）：调度器初始化

Wed, 11 Sep 2024 18:27:38 +0800

前言

上一讲介绍了 Go 程序初始化的过程，这一讲继续往下看，进入调度器的初始化过程。

接着上一讲的执行过程，省略一些不相关的代码，执行到 runtime/asm_amd64.s:rt0_go:343L：

1(dlv) si
2        asm_amd64.s:343 0x45431c*       8b442418        mov eax, dword ptr [rsp+0x18]       // [rsp+0x18] 存储的是 argc 的值，eax = argc
3        asm_amd64.s:344 0x454320        890424          mov dword ptr [rsp], eax            // 将 argc 移到 rsp，[rsp] = argc
4        asm_amd64.s:345 0x454323        488b442420      mov rax, qword ptr [rsp+0x20]       // [rsp+0x20] 存储的是 argv 的值，rax = [rsp+0x20]
5        asm_amd64.s:346 0x454328        4889442408      mov qword ptr [rsp+0x8], rax        // 将 argv 移到 [rsp+0x8]，[rsp+0x8] = argv
6        asm_amd64.s:347 0x45432d        e88e2a0000      call $runtime.args                  // 调用 runtime.args 处理栈上的 argc 和 argv
7        asm_amd64.s:348 0x454332        e8c9280000      call $runtime.osinit                // 调用 runtime.osinit 初始化系统核心数
8        asm_amd64.s:349 0x454337        e8e4290000      call $runtime.schedinit

上述指令调用 runtime.args 处理函数参数，接着调用 runtime.osinit 初始化系统核心数。runtime.osinit 在 runtime.os_linux.go 中定义：

Go runtime 调度器精讲（一）：Go 程序初始化

Wed, 11 Sep 2024 11:43:38 +0800

前言

本系列将介绍 Go runtime 调度器。要学好 Go 语言，runtime 运行时是绕不过去的，它相当于一层“操作系统”对我们的程序做“各种类型”的处理。其中，调度器作为运行时的核心，是必须要了解的内容。本系列会结合 Go plan9 汇编，深入到 runtime 调度器的源码层面去看程序运行时，goroutine 协程创建等各种场景下 runtime 调度器是如何工作的。

Go plan9 汇编：内存对齐和递归

Mon, 02 Sep 2024 10:29:38 +0800

前言

在 Go plan9 汇编系列文章中，介绍了函数和函数栈的调用。这里继续看内存对齐和递归调用方面的内容。

内存对齐

直接上示例：

 1type temp struct {
 2	a bool
 3	b int16
 4	c []string
 5}
 6
 7func main() {
 8	var t = temp{a: true, b: 1, c: []string{}}
 9	fmt.Println(unsafe.Sizeof(t))
10}

输出：

Go plan9 汇编：说透函数栈

Mon, 02 Sep 2024 00:35:38 +0800

前言

函数是 Go 的一级公民，本文从汇编角度出发看看我们常用的一些函数在干什么。

函数

main 函数

在 main 函数中计算两数之和如下：

1package main
2
3func main() {
4	x, y := 1, 2
5	z := x + y
6	print(z)
7}

使用 dlv 调试函数(不了解 dlv 的请看 Go plan9 汇编: 打通应用到底层的任督二脉)：

Go plan9 汇编：手写汇编

Sun, 01 Sep 2024 17:17:38 +0800

前言

在 Go plan9 汇编: 打通应用到底层的任督二脉一文中介绍了从应用程序到汇编指令的转换。本文将结合汇编和 Go 程序实现手写基本的汇编指令，以加深对 Go plan9 汇编的了解。

Go plan9 汇编: 打通应用到底层的任督二脉

Sat, 31 Aug 2024 17:46:38 +0800

前言

作为一个严肃的 Gopher，了解汇编是必须的。本汇编系列文章会围绕基本的 Go 程序介绍汇编的基础知识。

Go 程序到汇编

首先看一个简单到令人发指的示例：

Go 互斥锁 Mutex 源码分析(二)

Sat, 24 Aug 2024 13:27:38 +0800

前言

在 Go 互斥锁 Mutex 源码分析(一) 一文中分析了互斥锁的结构和基本的抢占互斥锁的场景。在学习锁的过程中，看的不少文章是基于锁的状态解释的，个人经验来看，从锁的状态出发容易陷入细节，了解锁的状态转换过一段时间就忘，难以做到真正的理解。想来是用静态的方法分析动态的问题导致的。在实践中发现结合场景分析互斥锁对笔者来说更加清晰，因此有了 Go 互斥锁 Mutex 源码分析(一)，本文接着结合不同场景分析互斥锁。

Go 互斥锁 Mutex 源码分析(一)

Fri, 23 Aug 2024 15:41:38 +0800

前言

锁作为并发编程中的关键一环，是应该要深入掌握的。

锁

示例

实现锁很简单，示例如下：

 1var global int
 2
 3func main() {
 4	var mu sync.Mutex
 5	var wg sync.WaitGroup	
 6
 7	for i := 0; i < 2; i++ {
 8		wg.Add(1)
 9		go func(i int) {
10			defer wg.Done()
11			mu.Lock()
12			global++
13			mu.Unlock()
14		}(i)
15	}
16
17	wg.Wait()
18	fmt.Println(global)
19}

输出：