go 中 channel select reflect 使用

uccs2024-03-26 13:26

channel

无缓冲区的 channel 会阻塞，直到有 goroutine 读取数据

初始化 channel，使用 make 函数：

  • 有缓冲区：ch := make(chan int, 10)

    go 复制代码 
    func main() {
  ch := make(chan int, 10)
  var wg sync.WaitGroup
  wg.Add(1)
  go func() {
    defer wg.Done()
    ch <- 1
    fmt.Println("goroutine1 done")  // 会立即执行
  }()
  time.Sleep(5 * time.Second)
  num := <-ch
  fmt.Println(num)
  wg.Wait()
}

  • 无缓冲区：ch := make(chan int)

    go 复制代码 
    func main() {
  ch := make(chan int)
  var wg sync.WaitGroup
  wg.Add(1)
  go func() {
    defer wg.Done()
    ch <- 1
    fmt.Println("goroutine1 done")  // 不会立即执行，等待 5 秒后在执行
  }()
  time.Sleep(5 * time.Second)
  num := <-ch
  fmt.Println(num)
  wg.Wait()
}

channel 循环

go 复制代码 
// channel 是引用类型，所以这里不需要传递指针
func worker(ch chan int, wg *sync.WaitGroup) {
  defer wg.Done()
  // channel 使用后需要关闭，否则是出现死锁
  defer close(ch)
  for i := 0; i < 50; i++ {
    ch <- i * i
  }
}
func main() {
  ch := make(chan int, 100)
  var wg sync.WaitGroup
  wg.Add(1)
  go worker(ch, &wg)
  // 通过 range 循环 channel
  for num := range ch {
    fmt.Println(num)
  }
  wg.Wait()
}

channel 注意事项

未初始化的 channel 不能对其进行读写操作，否则会报错 all goroutines are asleep - deadlock!

go 复制代码 
var ch chan int
ch <- 1  // 写报错：all goroutines are asleep - deadlock!
n := <-ch // 读报错：all goroutines are asleep - deadlock!
fmt.Println(n)

关闭的 channel 不能再进行写操作，否则会报错 panic: send on closed channel

go 复制代码 
ch := make(chan int, 100)
close(ch)
ch <- 1  // channel 关闭后，在关闭的 channel 写数据，会报错：panic: send on closed channel

关闭的 channel 是可以读取的，读取到的数据是 channel 的零值

go 复制代码 
func main() {
  ch := make(chan int, 100)
  ch <- 1
  close(ch)
  // channel 关闭后，如果还有数据，可以继续读取
  // 如果 ok 为 true，说明 channel 还没有关闭
  n, ok := <-ch
  fmt.Println(ok) // true
  fmt.Println(n)  // 1
}
go 复制代码 
func main() {
  ch := make(chan int, 100)
  close(ch)
  // 如果 ok 为 false，说明 channel 已经关闭
  n, ok := <-ch
  fmt.Println(ok) // false
  fmt.Println(n)  // 1
}

channel 实现 WaitGroup

  1. 为什么用 defer 向 ch 中写入空结构体
    • 保证 goroutine 无论是正常执行完还是发生 panic 都能发送信号
  2. 在读取 channel 数据时，如果 channel 中还没有数据，channel 会被卡住
go 复制代码 
func main() {
  ch := make(chan struct{})
  for i := 0; i < 2; i++ {
    go func(i int) {
      // 用 defer 保证 goroutine 执行完后，wg.Done()
      defer func() {
        ch <- struct{}{}
      }()
      time.Sleep(2 * time.Second)
      fmt.Println("i:", i)
    }(i)
  }
  for i := 0; i < 2; i++ {
    <-ch
  }
  fmt.Println("main end")
}

channel 限流

有缓冲的 channel，如果缓冲区已满的话，会被阻塞，所以下面的代码会 4 个一组的打印

go 复制代码 
func main() {
  ch := make(chan struct{}, 4)
  var wg sync.WaitGroup
  for i := 0; i < 20; i++ {
    ch <- struct{}{}
    wg.Add(1)
    go func(i int) {
      defer func() {
        wg.Done()
        <-ch
      }()
      time.Sleep(2 * time.Second)
      fmt.Println("i:", i)  // 会 4 个一组的输出
    }(i)
  }
  wg.Wait()
  fmt.Println("main end")
}

不过这里要注意，缓冲区已满的话会阻塞，但如果缓冲区刚好够写入数据时，是不会阻塞的

所以下面的代码，最后 16、17、18、19 是不会被打印的

go 复制代码 
func main() {
  ch := make(chan struct{}, 4)
  for i := 0; i < 20; i++ {
    ch <- struct{}{}
    go func(i int) {
      defer func() {
        <-ch
      }()
      time.Sleep(2 * time.Second)
      fmt.Println("i:", i)
    }(i)
  }
  fmt.Println("main end")
}

channel 实现锁

利用 channel 缓冲区已满需要等待的特性实现锁

  1. 缓冲区如果设置为 1 时，需要先写入数据，再读取数据，才能实现锁

    go 复制代码 
    func main() {
  // 缓冲区为 1，只能写入一个数据
  ch := make(chan struct{}, 1)
  var wg sync.WaitGroup
  var counter int
  for i := 0; i < 20; i++ {
    wg.Add(1)
    go func() {
      defer wg.Done()
      ch <- struct{}{} // 先写入数据
      counter++
      <-ch             // 再读取数据
    }()
  }
  wg.Wait()
  fmt.Println(counter)
}

  2. 缓冲区随便设置多少，但要预先写入一条数据，且只能写入一条数据

    • 如果不预先写入数据，会出现死锁
    • 如果预先写入多条数据，会出现数据竞争
    • 因为预先写入一条数据时，当缓冲区满了的话，就会阻塞，然后一条一条的释放，达到锁的效果
    go 复制代码 
    func main() {
  ch := make(chan struct{}, 100)
  var wg sync.WaitGroup
  var counter int
  ch <- struct{}{} // 预先写入一条数据
  for i := 0; i < 200000; i++ {
    wg.Add(1)
    go func() {
      defer wg.Done()
      <-ch           // 再读取数据
      counter++
      ch <- struct{}{}  // 再写入数据，当缓冲区满的话，就无法写入数据了，需要等待前面的数据释放
    }()
  }
  wg.Wait()
  fmt.Println(counter)
}

select

for 循环中的 select 内部如果有 break 只能跳出 select 语句，不能跳出 for 循环，如果想跳出 for 循环，需要指定 label

go 复制代码 
func main() {
  ch1 := make(chan int, 100)
  wg := sync.WaitGroup{}
  wg.Add(1)
  go func() {
    defer wg.Done()
    defer close(ch1)
    for i := 0; i < 10; i++ {
      ch1 <- i
      time.Sleep(1 * time.Second)
    }
  }()
  timeout := time.After(5 * time.Second)
loop:
  for {
    select {
    case v, ok := <-ch1:
      if !ok {
        // 不指定 label，默认跳出 select
        break loop
      }
      println(v)
    case <-timeout:
      println("timeout")

    }
  }
  wg.Wait()
}

如果有多个 case 满足条件，select 会随机选择一个执行：

  • 如果有 default 语句，当 case 都不满足条件时，会执行 default 语句
  • 如果没有 default 语句，当 case 都不满足条件时，select 会阻塞

下面例子是两个 goroutine，一个每隔 1 秒向 ch1 写入数据，一个每隔 2 秒向 ch2 写入数据，select 会随机选择一个 case 执行，如果 8 秒内还没有执行完，会执行 timeout 语句，跳出 for 循环

go 复制代码 
func main() {
  ch1 := make(chan int, 10)
  ch2 := make(chan int, 10)

  wg := sync.WaitGroup{}
  wg.Add(1)
  go func() {
    defer wg.Done()
    defer close(ch1)
    for i := 0; i < 10; i++ {
      ch1 <- i
      time.Sleep(1 * time.Second)
    }
  }()

  wg.Add(1)
  go func() {
    defer wg.Done()
    defer close(ch2)
    for i := 0; i < 10; i++ {
      ch2 <- i
      time.Sleep(2 * time.Second)
    }
  }()
  timeout := time.After(8 * time.Second)

loop:
  for {
    select {
    case v, ok := <-ch1:
      if !ok {
        ch1 = nil
        break
      }
      fmt.Printf("ch1: %d\n", v)
    case v, ok := <-ch2:
      if !ok {
        ch2 = nil
        break
      }
      fmt.Printf("ch2: %d\n", v)
    case <-timeout:
      println("timeout")
      break loop
    }
    if ch1 == nil && ch2 == nil {
      println("break")
      break
    }
  }
  wg.Wait()
}

reflect

利用 reflect 实现 json 序列化

reflect.MakeSlice

MakeSlice 和 make([]int, 1) 效果差不多，不过 MakeSlice 创建的是 reflect.Value 类型的切片，代码如下：

go 复制代码 
sliceType := reflect.TypeOf([]int{})
// 或者
sliceType = reflect.SliceOf(reflect.TypeOf(int(0)))
slice := reflect.MakeSlice(sliceType, 10, 10)

设置值：

go 复制代码 
slice.Index(0).SetInt(int64(1))

追加值：

go 复制代码 
slice = reflect.Append(slice, reflect.ValueOf(2), reflect.ValueOf(3)) // 追加值
slice = reflect.AppendSlice(slice, slice) // 追加切片

转换成普通的 slice：

go 复制代码 
ss := slice.Interface().([]int)

reflect.MakeMap

初始化 makeMap

go 复制代码 
mapType := reflect.TypeOf([]int{})
// 或者
mapType = reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(""))
m := reflect.MakeMap(reflect.TypeOf(map[string]string{}))

设置值：

go 复制代码 
m.SetMapIndex(reflect.ValueOf("key"), reflect.ValueOf("value"))

迭代：

go 复制代码 
iter := m.MapRange()
for iter.Next() {
  fmt.Println(iter.Key(), iter.Value())
}

转换成普通的 map：

go 复制代码 
mm := m.Interface().(map[string]string)

reflect.MakeFunc

go 复制代码 
intType := reflect.TypeOf(0)
funcType := reflect.FuncOf([]reflect.Type{intType, intType}, []reflect.Type{intType}, false)
  // 或者
funcType := reflect.TypeOf(func(int, int) int { return 0 })
f := reflect.MakeFunc(funcType, func(args []reflect.Value) []reflect.Value {
  return []reflect.Value{reflect.ValueOf(int(args[0].Int() + args[1].Int()))}
})
fmt.Println(f.Call([]reflect.Value{reflect.ValueOf(1), reflect.ValueOf(2)})[0].Int())
相关推荐
2401_857636395 分钟前
计算机课程管理平台：Spring Boot与工程认证的结合
java·spring boot·后端
也无晴也无风雨1 小时前
深入剖析输入URL按下回车，浏览器做了什么
前端·后端·计算机网络
2401_857610034 小时前
多维视角下的知识管理：Spring Boot应用
java·spring boot·后端
代码小鑫5 小时前
A027-基于Spring Boot的农事管理系统
java·开发语言·数据库·spring boot·后端·毕业设计
颜淡慕潇6 小时前
【K8S问题系列 | 9】如何监控集群CPU使用率并设置告警？
后端·云原生·容器·kubernetes·问题解决
独泪了无痕6 小时前
WebStorm 如何调试 Vue 项目
后端·webstorm
怒放吧德德7 小时前
JUC从实战到源码：JMM总得认识一下吧
java·jvm·后端
代码小鑫8 小时前
A025-基于SpringBoot的售楼管理系统的设计与实现
java·开发语言·spring boot·后端·毕业设计
前端SkyRain8 小时前
后端SpringBoot学习项目-项目基础搭建
spring boot·后端·学习
梦想画家8 小时前
理解Rust 生命周期、所有权和借用机制
开发语言·后端·rust
热门推荐
01聊聊 Python 中的同步原语，为什么有了 GIL 还需要同步原语02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03Windows10安装PCL1.14.0及点云配准04C++——超强级病毒代码05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07硬件预取之空间预取08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09Coze扣子平台完整体验和实践（附国内和国际版对比）10【SCS-CN】SCS-CN模型中CN值的确定