Go 大神技巧宝典(Go Guru Tips)

package main

import "fmt"

// producer 生成 0..n-1 并发送，发送完毕后由发送方关闭 channel。
func producer(n int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out) // 关闭动作必须由发送方完成
		for i := 0; i < n; i++ {
			out <- i
		}
	}()
	return out
}

func main() {
	total := 0
	// 用 for range 消费，channel 关闭后自动退出循环
	for v := range producer(5) {
		total += v
	}
	fmt.Println("sum:", total)
}

package main

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

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	// 关键习惯：拿到 cancel 立刻 defer，保证任何退出路径都执行取消
	defer cancel()

	results := make(chan string, 2)
	for i := 0; i < 2; i++ {
		go func(id int) {
			select {
			case <-time.After(3 * time.Second):
				results <- fmt.Sprintf("worker %d 完成", id)
			case <-ctx.Done():
				results <- fmt.Sprintf("worker %d 被取消: %v", id, ctx.Err())
			}
		}(i)
	}

	time.Sleep(100 * time.Millisecond) // 模拟主流程提前结束
	cancel()                           // 通知所有子任务退出

	for i := 0; i < 2; i++ {
		fmt.Println(<-results)
	}
}

package main

import (
	"fmt"
	"time"
)

// orDone 合并 done 与 src：done 关闭时，返回的 channel 立即关闭。
func orDone(done <-chan struct{}, src <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for {
			select {
			case <-done:
				return
			case v, ok := <-src:
				if !ok {
					return
				}
				// 二次 select：即使 send 阻塞也能感知取消
				select {
				case out <- v:
				case <-done:
					return
				}
			}
		}
	}()
	return out
}

func main() {
	done := make(chan struct{})
	src := make(chan int)

	// 模拟一个「不可取消、每 10ms 产出一个数」的外部数据源
	go func() {
		for i := 1; i <= 100; i++ {
			src <- i
			time.Sleep(10 * time.Millisecond)
		}
	}()

	// 消费者 25ms 后决定不再等待
	go func() {
		time.Sleep(25 * time.Millisecond)
		close(done)
	}()

	for v := range orDone(done, src) {
		fmt.Println("收到:", v)
	}
	fmt.Println("消费者已提前退出，没有读完 100 个数据")
}

package main

import (
	"fmt"
	"sync"
)

// generate 生成待处理的数据。
func generate(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, n := range nums {
			out <- n
		}
	}()
	return out
}

// square 对每个输入求平方，模拟一个处理阶段。
func square(in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for v := range in {
			out <- v * v
		}
	}()
	return out
}

// fanIn 把多个输入 channel 合并成一个输出 channel。
func fanIn(ins ...<-chan int) <-chan int {
	var wg sync.WaitGroup
	out := make(chan int)

	wg.Add(len(ins))
	for _, in := range ins {
		go func(c <-chan int) {
			defer wg.Done()
			for v := range c {
				out <- v
			}
		}(in)
	}

	// 所有输入结束后关闭输出 channel，让消费者安全退出
	go func() {
		wg.Wait()
		close(out)
	}()
	return out
}

func main() {
	// 扇出：同一个数据源分发给两个 worker 并行处理
	gen := generate(1, 2, 3, 4)
	ch1 := square(gen)
	ch2 := square(gen)

	// 扇入：合并两个结果 channel
	for v := range fanIn(ch1, ch2) {
		fmt.Println(v)
	}
}

package main

import (
	"fmt"
	"sync"
	"time"
)

// worker 从 jobs 取任务，结果写入 results。
func worker(id int, jobs <-chan int, results chan<- int) {
	for j := range jobs {
		time.Sleep(10 * time.Millisecond) // 模拟耗时操作
		results <- j * 2
	}
}

func main() {
	const numJobs = 5
	jobs := make(chan int, numJobs)
	results := make(chan int, numJobs)

	// 启动 3 个 worker
	var wg sync.WaitGroup
	for w := 1; w <= 3; w++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			worker(id, jobs, results)
		}(w)
	}

	// 提交任务后关闭队列，worker 消费完自然退出
	for j := 1; j <= numJobs; j++ {
		jobs <- j
	}
	close(jobs)

	// 所有 worker 结束后再关闭结果 channel
	go func() {
		wg.Wait()
		close(results)
	}()

	for r := range results {
		fmt.Println(r)
	}
}

package main

import (
	"context"
	"errors"
	"fmt"
	"sync"
)

// runGroup 是 errgroup 的最小标准库实现：
// 并发运行多个函数，第一个返回非 nil 错误的函数会触发取消。
func runGroup(ctx context.Context, fns ...func(ctx context.Context) error) error {
	ctx, cancel := context.WithCancel(ctx)
	defer cancel() // 全部结束后兜底取消，防止泄漏

	var (
		wg    sync.WaitGroup
		once  sync.Once
		first error
	)
	wg.Add(len(fns))
	for _, fn := range fns {
		go func(f func(ctx context.Context) error) {
			defer wg.Done()
			if err := f(ctx); err != nil {
				once.Do(func() {
					first = err // 只记录第一个错误
					cancel()    // 通知兄弟任务退出
				})
			}
		}(fn)
	}
	wg.Wait()
	return first
}

func main() {
	ctx := context.Background()
	err := runGroup(ctx,
		func(ctx context.Context) error {
			return errors.New("任务 1 失败")
		},
		func(ctx context.Context) error {
			// 感知到兄弟任务失败，等待取消并退出
			<-ctx.Done()
			return ctx.Err()
		},
	)
	fmt.Println("group err:", err)
}

package main

import (
	"fmt"
	"sync"
)

// DB 模拟一个进程内只初始化一次的全局资源。
type DB struct{ addr string }

var (
	db     *DB
	dbOnce sync.Once
)

// getDB 并发安全地惰性初始化唯一实例。
func getDB() *DB {
	dbOnce.Do(func() {
		fmt.Println("初始化数据库连接...")
		db = &DB{addr: "127.0.0.1:3306"}
	})
	return db
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			_ = getDB() // 并发调用，但初始化只发生一次
		}()
	}
	wg.Wait()
	fmt.Println("所有 goroutine 拿到同一个实例:", db.addr)
}

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup

	// 正确：在启动 goroutine 之前 Add
	for i := 1; i <= 3; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done() // 保证任何退出路径都会 Done
			time.Sleep(10 * time.Millisecond)
			fmt.Println("任务", id, "完成")
		}(i)
	}

	wg.Wait() // 阻塞到计数归零
	fmt.Println("全部完成")
}

package main

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

// worker 同时监听任务与取消信号，保证任何情况下都能退出。
func worker(ctx context.Context, jobs <-chan int) {
	for {
		select {
		case j, ok := <-jobs:
			if !ok {
				return // 任务 channel 已关闭，正常退出
			}
			fmt.Println("处理:", j)
		case <-ctx.Done():
			return // 被取消，提前退出
		}
	}
}

func main() {
	before := runtime.NumGoroutine()

	ctx, cancel := context.WithCancel(context.Background())
	jobs := make(chan int) // 无缓冲，且没有任务会发来
	go worker(ctx, jobs)

	time.Sleep(50 * time.Millisecond) // 模拟一段时间后决定关闭
	cancel()                          // 触发 worker 退出
	time.Sleep(20 * time.Millisecond) // 等 worker 收尾

	after := runtime.NumGoroutine()
	fmt.Printf("goroutine 数量: before=%d after=%d\n", before, after)
	if after == before {
		fmt.Println("没有 goroutine 泄漏")
	}
}

package main

import (
	"fmt"
	"sync"
)

// SafeCounter 用 RWMutex 保护并发读多写少的计数器。
type SafeCounter struct {
	mu    sync.RWMutex // 读者可并发，写者独占
	value int
}

func (c *SafeCounter) Inc() {
	c.mu.Lock() // 写者用写锁
	defer c.mu.Unlock()
	c.value++
}

func (c *SafeCounter) Value() int {
	c.mu.RLock() // 读者用读锁，可并发
	defer c.mu.RUnlock()
	return c.value
}

func main() {
	c := SafeCounter{}
	var wg sync.WaitGroup

	// 10 个写者，各写 100 次
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 100; j++ {
				c.Inc()
			}
		}()
	}

	// 5 个读者并发读
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 50; j++ {
				_ = c.Value()
			}
		}()
	}

	wg.Wait()
	fmt.Println("最终值:", c.Value()) // 10 个写者各 100 次
}

package main

import (
	"fmt"
	"time"
)

func main() {
	// 正确做法：NewTicker + defer Stop()
	ticker := time.NewTicker(10 * time.Millisecond)
	defer ticker.Stop() // 退出时释放底层定时器

	stop := make(chan struct{})
	go func() {
		time.Sleep(35 * time.Millisecond)
		close(stop) // 模拟业务上需要停止
	}()

	count := 0
loop:
	for {
		select {
		case <-ticker.C:
			count++
			fmt.Println("tick", count)
		case <-stop:
			fmt.Println("收到停止信号")
			break loop
		}
	}
	fmt.Println("共 tick", count, "次")
}

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
	"time"
)

func main() {
	const max = 3
	sem := make(chan struct{}, max) // 令牌容量 = 最大并发数

	var (
		wg      sync.WaitGroup
		current atomic.Int64 // 当前并发数
		maxSeen atomic.Int64 // 观测到的峰值并发
	)

	for i := 1; i <= 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()

			sem <- struct{}{}        // 获取令牌，满了就阻塞，从而限流
			defer func() { <-sem }() // 归还令牌

			n := current.Add(1) // 进入临界区
			defer current.Add(-1)
			if n > maxSeen.Load() {
				maxSeen.Store(n)
			}

			time.Sleep(5 * time.Millisecond) // 模拟任务
			fmt.Println("任务", id, "完成")
		}(i)
	}

	wg.Wait()
	fmt.Printf("峰值并发数: %d（限制 %d）\n", maxSeen.Load(), max)
}

// iota：在 const 块内按行自动递增的计数器，适合定义枚举与位标志。
package main

import "fmt"

// 位标志：每个常量占一个独立的二进制位，可组合。
// 注意：新的 const 块会重置 iota，因此把零值单独放一个块。
type Flag uint8

const FlagNone Flag = 0

const (
	FlagRead  Flag = 1 << iota // 1
	FlagWrite                  // 2
	FlagExec                   // 4
)

// 字节大小：用 1 << (10 * iota) 生成 KB、MB、GB……（Effective Go 经典用法）
type ByteSize float64

const (
	_           = iota // 跳过第 0 个值
	KB ByteSize = 1 << (10 * iota)
	MB
	GB
)

// 状态枚举：跳过一个值，再继续自增。
const (
	StateUnknown = iota // 0，留作零值哨兵
	_
	StateRunning = iota // 2
	StateStopped        // 3
)

func main() {
	fmt.Println(FlagRead, FlagWrite, FlagExec)
	fmt.Println(FlagRead|FlagExec == 5) // 组合位标志
	fmt.Println(KB, MB, GB)
	fmt.Println(StateRunning, StateStopped)
}

// defer：LIFO 执行；参数在 defer 语句处立即求值，闭包捕获变量则延迟取值。
package main

import "fmt"

func main() {
	// LIFO：先注册的后执行
	defer fmt.Println("第一个 defer（后打印）")
	defer fmt.Println("第二个 defer（先打印）")

	// 参数立即求值：x 在 defer 处被复制为 1
	x := 1
	defer fmt.Println("立即求值结果:", x)
	x = 99

	// 闭包捕获变量：函数体执行时才读取 x，此时 x 已是 99
	defer func() { fmt.Println("闭包捕获结果:", x) }()
}

// recover 只在 defer 中有效：把 panic 转为返回值（error），而非直接崩溃。
package main

import (
	"errors"
	"fmt"
)

// safeRun 用命名返回值承接 recover 结果，把 panic 转换为 error。
func safeRun(fn func() error) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("捕获到 panic: %v", r)
		}
	}()
	return fn()
}

func main() {
	boom := func() error {
		return errors.New("正常业务错误")
	}
	panicFn := func() error {
		panic("内部爆炸") // 只有 defer 中的 recover 才能拦住它
	}

	fmt.Println(safeRun(boom))    // 返回普通 error
	fmt.Println(safeRun(panicFn)) // 返回转换后的 error
}

// 接口隐式实现：类型无需声明 implements，只要方法集匹配即可满足接口。
package main

import (
	"fmt"
	"io"
)

// Greeter 是我们自定义的接口。
type Greeter interface {
	Greet() string
}

// Person 没有任何 `implements Greeter` 声明，只是碰巧有 Greet 方法。
type Person struct {
	Name string
}

func (p Person) Greet() string {
	return "你好，" + p.Name
}

// 复用标准库接口：io.Writer 也是隐式实现，无需显式声明。
type Buffer struct {
	data []byte
}

func (b *Buffer) Write(p []byte) (int, error) {
	b.data = append(b.data, p...)
	return len(p), nil
}

func main() {
	var g Greeter = Person{Name: "Ada"} // 编译通过即说明满足接口
	fmt.Println(g.Greet())

	var buf Buffer
	var w io.Writer = &buf // Buffer 自动满足 io.Writer
	w.Write([]byte("hello"))
	fmt.Println(string(buf.data))
}

// 类型断言 comma-ok idiom：安全地从接口取出具体值，失败返回零值+false，不 panic。
package main

import "fmt"

func main() {
	var i any = 42

	// 推荐写法：始终用 comma-ok 形式
	if v, ok := i.(int); ok {
		fmt.Println("是 int:", v)
	}

	// 失败分支：断言到错误类型，ok 为 false，v 是 string 的零值
	if v, ok := i.(string); ok {
		fmt.Println("是 string:", v)
	} else {
		fmt.Println("不是 string，零值为:", v)
	}

	// 反面教材：单返回值形式在类型不匹配时会 panic
	// _ = i.(string) // panic: interface conversion
}

// 类型 switch：根据接口动态类型走不同分支，分支内变量自动具备具体类型。
package main

import "fmt"

// describe 展示用类型 switch 处理"任何类型"。
func describe(v any) string {
	switch x := v.(type) {
	case nil:
		return "空值"
	case int:
		return fmt.Sprintf("整数 %d", x)
	case string:
		return fmt.Sprintf("字符串 %q", x)
	case []byte:
		return fmt.Sprintf("字节切片 %d 字节", len(x))
	default:
		return fmt.Sprintf("未知类型 %T", v)
	}
}

func main() {
	fmt.Println(describe(nil))
	fmt.Println(describe(42))
	fmt.Println(describe("go"))
	fmt.Println(describe([]byte{1, 2}))
	fmt.Println(describe(3.14))
}

// 结构体嵌入：匿名嵌入复用字段与方法，替代继承实现"组合优于继承"。
package main

import "fmt"

type Person struct {
	Name string
	Age  int
}

// 说话是 Person 的方法。
func (p Person) Say() string {
	return fmt.Sprintf("我是 %s，今年 %d 岁", p.Name, p.Age)
}

// Employee 匿名嵌入 Person，其字段与方法被"提升"到外层。
type Employee struct {
	Person  // 匿名嵌入（embedded field）
	Salary  float64
	Company string
}

// 覆盖 Say：外层方法遮蔽提升的同名方法。
func (e Employee) Say() string {
	return e.Person.Say() + "，" + e.Company + " 员工"
}

func main() {
	emp := Employee{
		Person:  Person{Name: "Ada", Age: 30},
		Salary:  20000,
		Company: "ACME",
	}
	// 提升字段：emp.Name 等价于 emp.Person.Name
	fmt.Println(emp.Name, emp.Age)
	// 遮蔽后：调用的是 Employee 自己的 Say，内部复用 Person.Say
	fmt.Println(emp.Say())
	// 显式访问嵌入层的方法
	fmt.Println(emp.Person.Say())
}

// 方法值（method value）与方法表达式（method expression）。
package main

import "fmt"

type Counter struct {
	n int
}

// 计数并返回当前值。
func (c *Counter) Inc() int {
	c.n++
	return c.n
}

// 单方法接口，用于演示方法值可赋值给接口。
type Incrementer interface {
	Inc() int
}

func main() {
	c := Counter{}

	// 方法值：接收者被绑定，可直接当普通函数反复调用
	inc := c.Inc
	fmt.Println(inc(), inc(), inc()) // 1 2 3

	// 方法表达式：接收者作为显式参数，类型为 func(*Counter) int
	incFn := (*Counter).Inc
	fmt.Println(incFn(&c)) // 4

	// 方法值可赋给匹配的接口，便于当作回调注入
	var incI Incrementer = &c
	fmt.Println(incI.Inc()) // 5
}

// 函数式选项（Functional Options）：用可变参数的配置函数定制构造，保持默认值。
package main

import (
	"fmt"
	"time"
)

type Server struct {
	host    string
	port    int
	timeout time.Duration
	debug   bool
}

// Option 是配置函数：接收 *Server 并就地修改。
type Option func(*Server)

// WithPort 设置端口。
func WithPort(p int) Option {
	return func(s *Server) { s.port = p }
}

// WithTimeout 设置超时。
func WithTimeout(d time.Duration) Option {
	return func(s *Server) { s.timeout = d }
}

// WithDebug 开启调试日志。
func WithDebug(on bool) Option {
	return func(s *Server) { s.debug = on }
}

// NewServer 应用默认值后按顺序应用选项。
func NewServer(host string, opts ...Option) *Server {
	s := &Server{
		host:    host,
		port:    8080, // 默认端口
		timeout: 5 * time.Second,
	}
	for _, opt := range opts {
		opt(s)
	}
	return s
}

func main() {
	defaultSrv := NewServer("127.0.0.1")
	customSrv := NewServer("0.0.0.0", WithPort(9090), WithTimeout(2*time.Second), WithDebug(true))

	fmt.Printf("默认服务: host=%s port=%d timeout=%v debug=%v\n",
		defaultSrv.host, defaultSrv.port, defaultSrv.timeout, defaultSrv.debug)
	fmt.Printf("定制服务: host=%s port=%d timeout=%v debug=%v\n",
		customSrv.host, customSrv.port, customSrv.timeout, customSrv.debug)
}

// 泛型：用类型约束（constraint/类型集合）写出可复用的类型安全代码。
package main

import "fmt"

// Number 用类型集合（type set）定义约束：底层类型是 int 或 float64 的类型。
type Number interface {
	~int | ~float64
}

// Sum 对任意满足 Number 约束的切片求和。
func Sum[T Number](vals []T) T {
	var total T
	for _, v := range vals {
		total += v
	}
	return total
}

// 也可以用 `~` 修饰符让自定义类型（type MyInt int）也满足约束。
func Max[T ~int | ~float64](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))
	fmt.Println(Sum([]float64{1.5, 2.5}))
	fmt.Println(Max(3, 7), Max(2.1, 1.9))
}

// 循环变量捕获陷阱：Go 1.22 起每轮迭代的循环变量都是新变量，闭包各捕获各的。
package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	nums := []int{1, 2, 3, 4}

	// Go 1.22+：每个 goroutine 捕获本轮的值，输出 1 2 3 4（乱序但各不重复）
	// Go 1.21 及更早（或 go.mod 声明 <1.22）：全部输出 4 4 4 4
	for _, n := range nums {
		wg.Add(1)
		go func() {
			defer wg.Done()
			fmt.Print(n, " ")
		}()
	}
	wg.Wait()
	fmt.Println()
}