Go 高级特性#

1.1 defer机制#

• defer 的作用

  • 用来指定在函数返回前执行的代码
  • 主要用于资源释放（文件关闭、锁释放、数据库连接关闭）
  • 配合recover捕获panic

• defer 的执行顺序

  • LIFO（后进先出）顺序执行
  • 多个defer形成defer栈
  • 函数返回时从栈顶开始执行

• defer底层实现

  • Go 1.12及之前：所有defer在堆上分配
  • Go 1.13：引入栈上分配，提升性能
  • Go 1.14：引入开放编码（open-coded），进一步优化

1
type _defer struct {
2
    siz       int32    // 参数和返回值的内存大小
3
    started   bool     // defer是否已经开始执行
4
    heap      bool     // 是否分配在堆上
5
    openDefer bool     // 是否使用开放编码优化（Go 1.14+）
6
    sp        uintptr  // 栈指针，记录defer语句时的栈位置
7
    pc        uintptr  // 程序计数器，defer函数的返回地址
8
    fn        *funcval // defer延迟调用的函数
9
    _panic    *_panic  // 触发defer的panic结构体
10
    link      *_defer  // 链接到下一个defer，形成链表
11
}

• defer陷阱

  1
  // 陷阱1：循环中的defer
  2
  for i := 0; i < 1000; i++ {
  3
      defer file.Close() // 错误：defer在函数返回时才执行
  4
  }
  5
  
  6
  // 陷阱2：defer参数即时求值
  7
  func a() {
  8
      i := 0
  9
      defer fmt.Println(i) // 输出0，不是1
  10
      i++
  11
  }
  12
  
  13
  // 陷阱3：defer与返回值
  14
  func foo() (result int) {
  15
      defer func() {
  16
          result++ // 可以修改命名返回值
  17
      }()
  18
      return 0 // 最终返回1
  19
  }
  

1.2 panic和recover#

• panic机制

  • Go的运行时异常机制
  • 未被recover捕获会导致程序崩溃
  • 输出堆栈信息

• panic触发方式

  • 主动调用：panic("error message")
  • 运行时错误：
    • 空指针解引用
    • 数组/切片越界
    • 类型断言失败
    • 向已关闭的channel发送数据
    • 并发map读写

• panic执行流程

  1. 停止当前函数的正常执行
  2. 执行当前函数的所有defer（LIFO顺序）
  3. 返回调用者，重复步骤1-2
  4. 直到被recover捕获或程序终止

• recover使用规则

  • 必须在defer函数中直接调用
  • 只能捕获当前goroutine的panic
  • recover后从defer之后继续执行
  • 返回panic的值

1
func example() {
2
    defer func() {
3
        if r := recover(); r != nil {
4
            fmt.Println("Recovered:", r)
5
        }
6
    }()
7
    panic("something went wrong")
8
    fmt.Println("This won't execute")
9
}

2.1 channel基础#

• channel的作用

  • goroutine之间通信
  • 同步goroutine执行
  • 实现CSP并发模型

• channel底层结构

1
type hchan struct {
2
    qcount   uint           // 当前缓冲区中的元素数量
3
    dataqsiz uint           // 缓冲区的容量
4
    buf      unsafe.Pointer // 指向环形缓冲区
5
    elemsize uint16         // 元素大小
6
    closed   uint32         // 关闭标志
7
    elemtype *_type         // 元素类型
8
    sendx    uint           // 发送索引
9
    recvx    uint           // 接收索引
10
    recvq    waitq          // 等待接收的goroutine队列
11
    sendq    waitq          // 等待发送的goroutine队列
12
    lock     mutex          // 互斥锁
13
}

• 发送和接收流程
  • 发送：加锁 → 检查是否关闭 → 尝试直接发送给接收者 → 写入缓冲区 → 加入sendq等待
  • 接收：加锁 → 尝试从缓冲区读取 → 尝试从发送者接收 → 加入recvq等待

2.2 channel分类#

• 按方向分类

  1
  var ch1 chan int        // 双向channel
  2
  var ch2 <-chan int      // 只读channel
  3
  var ch3 chan<- int      // 只写channel
  4
  
  5
  // 双向可以转换为单向
  6
  ch1 = make(chan int)
  7
  ch2 = ch1  // 双向转只读
  8
  ch3 = ch1  // 双向转只写
  

• 按缓冲分类

  • 无缓冲channel：同步通信，发送和接收必须同时准备好

  1
  // 死锁示例
  2
  func main() {
  3
      ch := make(chan int)
  4
      ch <- 42  // 阻塞，等待接收者
  5
      <-ch      // 永远执行不到
  6
  }
  7
  
  8
  // 正确用法
  9
  func main() {
  10
      ch := make(chan int)
  11
      go func() {
  12
          ch <- 42
  13
      }()
  14
      fmt.Println(<-ch)
  15
  }
  

  • 有缓冲channel：异步通信，缓冲区满时发送阻塞，空时接收阻塞

2.3 channel操作#

• 关闭channel的影响

  • 向已关闭的channel发送：panic
  • 从已关闭的channel接收：返回零值和false
  • 重复关闭channel：panic
  • 关闭nil channel：panic

• 判断channel是否关闭

  1
  // 方法1：双返回值
  2
  value, ok := <-ch
  3
  if !ok {
  4
      fmt.Println("Channel closed")
  5
  }
  6
  
  7
  // 方法2：for range（推荐）
  8
  for value := range ch {
  9
      fmt.Println(value)
  10
  }
  11
  // channel关闭后自动退出
  12
  
  13
  // 方法3：select with default
  14
  select {
  15
  case v, ok := <-ch:
  16
      if !ok {
  17
          fmt.Println("Channel closed")
  18
      }
  19
  default:
  20
      fmt.Println("No data available")
  21
  }
  

3.1 context接口#

1
type Context interface {
2
    // Done返回一个channel，当context被取消或超时时关闭
3
    Done() <-chan struct{}
4

5
    // Err返回context结束的原因
6
    // context.Canceled：被取消
7
    // context.DeadlineExceeded：超时
8
    Err() error
9

10
    // Deadline返回context的截止时间
11
    // ok=false表示没有设置deadline
12
    Deadline() (deadline time.Time, ok bool)
13

14
    // Value返回context中的键值对
15
    Value(key interface{}) interface{}
16
}

3.2 context类型#

• context.Background()：根context，通常用于main函数
• context.TODO()：不确定使用哪个context时的占位符
• context.WithCancel()：可取消的context
• context.WithDeadline()：带截止时间的context
• context.WithTimeout()：带超时的context
• context.WithValue()：携带键值对的context

3.3 context最佳实践#

1
// 1. context应该作为第一个参数
2
func DoSomething(ctx context.Context, arg string) error
3

4
// 2. 不要存储context
5
type Server struct {
6
    // ctx context.Context // 错误
7
}
8

9
// 3. 传递请求范围的值，不传递可选参数
10
ctx = context.WithValue(ctx, "requestID", "12345") // 正确
11
// ctx = context.WithValue(ctx, "dbConfig", config) // 错误
12

13
// 4. 使用context控制goroutine生命周期
14
func worker(ctx context.Context) {
15
    for {
16
        select {
17
        case <-ctx.Done():
18
            return // 优雅退出
19
        default:
20
            // 执行工作
21
        }
22
    }
23
}

4.1 switch语句#

• 基本特性

  • 不需要break，自动终止
  • case可以是多个值：case 1, 2, 3:
  • case表达式运行时求值
  • switch后无表达式相当于switch true

• fallthrough

  • 强制执行下一个case（不判断条件）
  • 不能用在最后一个case
  • 不能用在类型switch中

• 类型switch

  1
  func typeSwitch(x interface{}) {
  2
      switch v := x.(type) {
  3
      case int:
  4
          fmt.Printf("int: %d\n", v)
  5
      case string:
  6
          fmt.Printf("string: %s\n", v)
  7
      case []int:
  8
          fmt.Printf("[]int: %v\n", v)
  9
      default:
  10
          fmt.Printf("unknown type: %T\n", v)
  11
      }
  12
  }
  

5.1 Go的面向对象#

• Go没有类和继承

  • 使用结构体代替类
  • 使用组合代替继承
  • 使用接口实现多态

• 方法接收者

  1
  // 值接收者
  2
  func (p Point) Distance() float64 {
  3
      // 不能修改p
  4
  }
  5
  
  6
  // 指针接收者
  7
  func (p *Point) Move(dx, dy float64) {
  8
      // 可以修改p
  9
  }
  

• 组合实现”继承”

  1
  type Animal struct {
  2
      Name string
  3
  }
  4
  
  5
  func (a Animal) Speak() {
  6
      fmt.Println("...")
  7
  }
  8
  
  9
  type Dog struct {
  10
      Animal // 嵌入
  11
      Breed string
  12
  }
  13
  
  14
  // Dog"继承"了Animal的Speak方法
  15
  // 可以"重写"（遮蔽）
  16
  func (d Dog) Speak() {
  17
      fmt.Println("Woof!")
  18
  }
  

• 接口实现多态

  1
  type Speaker interface {
  2
      Speak()
  3
  }
  4
  
  5
  // Dog和Cat都实现Speaker接口
  6
  func MakeSound(s Speaker) {
  7
      s.Speak() // 多态调用
  8
  }
  

6.1 反射基础#

• reflect.Type：类型信息
• reflect.Value：值信息
• reflect.TypeOf()：获取类型
• reflect.ValueOf()：获取值

6.2 反射三定律#

1. 反射可以从接口值得到反射对象
2. 反射可以从反射对象得到接口值
3. 要修改反射对象，值必须可设置（CanSet）

6.3 反射应用#

1
// 获取结构体字段信息
2
func inspectStruct(s interface{}) {
3
    t := reflect.TypeOf(s)
4
    v := reflect.ValueOf(s)
5

6
    for i := 0; i < t.NumField(); i++ {
7
        field := t.Field(i)
8
        value := v.Field(i)
9
        fmt.Printf("%s: %v (tag: %s)\n",
10
            field.Name, value, field.Tag)
11
    }
12
}
13

14
// 动态调用方法
15
func callMethod(obj interface{}, method string) {
16
    v := reflect.ValueOf(obj)
17
    m := v.MethodByName(method)
18
    if m.IsValid() {
19
        m.Call(nil)
20
    }
21
}