账号密码登录
微信安全登录
微信扫描二维码登录

登录后绑定QQ、微信即可实现信息互通

手机验证码登录
找回密码返回
邮箱找回 手机找回
注册账号返回
其他登录方式
分享
  • 收藏
    X
    Golang select 顺序问题
    65
    0
    源码里会打乱选择 channel 的顺序,为什么要打乱呢?愚钝求教
    0
    打赏
    收藏
    点击回答
        全部回答
    • 共 0 条
    • 暖心欧巴 普通会员 1楼

      在Go语言中,select语句用于执行一组可能的代码块并根据执行结果选择一条正确的路径。在select语句中,你可以指定一个处理器函数,这个函数将在所有选择的子程序中执行。每个处理器函数可以处理一组特定的情况,并根据条件执行不同的代码块。以下是select语句的基本语法和一些常见示例:

      ```go package main

      import ( "fmt" "sync" )

      func main() { // 假设我们有一个信号量来控制进程的并发访问 sem := &sync.WaitGroup{} sem.Add(1)

      // 创建一个处理器函数,处理每个信号量
      

      处理器1 := func(sem *sync.WaitGroup) { fmt.Println("Handler 1") sem.Done() }

      processor2 := func(sem *sync.WaitGroup) {
          fmt.Println("Handler 2")
          sem.Done()
      }
      
      // 创建两个信号量
      sem1 := &sync.WaitGroup{}
      sem2 := &sync.WaitGroup{}
      
      // 确保只有一个处理器正在运行
      go func() {
          sem1.Done()
          sem2.Done()
      }()
      
      // 启动信号量
      sem1.Start()
      sem2.Start()
      
      // 等待信号量同步
      select {
      case sem1.Done():
          fmt.Println("Handler 1 complete")
      case sem2.Done():
          fmt.Println("Handler 2 complete")
      default:
          fmt.Println("Unknown signal")
      }
      
      // 关闭信号量
      sem1.Stop()
      sem2.Stop()
      
      // 等待所有处理器完成
      sem.Wait()
      
      // 执行处理器1的代码
      

      处理器1(sem)

      // 执行处理器2的代码
      

      处理器2(sem) } ```

      在这个示例中,我们首先定义了两个处理器函数,分别处理两个不同的信号量。然后,我们创建了两个信号量sem1和sem2,并启动了它们。然后,我们开始等待信号量同步,直到所有处理器都完成。最后,我们执行了处理器1的代码,然后执行处理器2的代码。当所有处理器完成时,我们会看到它们的输出,以及处理的信号量。

      注意,select语句是无条件的,这意味着无论信号量的值如何变化,都会执行处理器函数。这通常不是我们期望的结果,因为我们通常希望在某些情况下,某些处理器可以先执行,而某些处理器则等待信号量的完成。例如,我们可能希望有一个处理器首先处理一个特定的信号量,然后等待其他处理器完成。

      在实际应用中,你可能需要根据你的需求来优化select语句。例如,你可能想要设置一个特定的条件来决定何时等待处理器完成,或者你可能想要根据信号量的当前值来决定处理器应该执行哪种代码。在这种情况下,你可以使用条件变量和回调函数来实现这些需求。以下是一个示例:

      ```go package main

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

      func main() { // 假设我们有一个信号量来控制进程的并发访问 sem := &sync.WaitGroup{} sem.Add(1)

      // 创建一个处理器函数,处理每个信号量
      

      处理器1 := func(sem *sync.WaitGroup) { fmt.Println("Handler 1") sem.Done() }

      processor2 := func(sem *sync.WaitGroup) {
          fmt.Println("Handler 2")
          sem.Done()
      }
      
      // 创建两个信号量
      sem1 := &sync.WaitGroup{}
      sem2 := &sync.WaitGroup{}
      
      // 创建一个条件变量和一个回调函数
      var wg sync.WaitGroup
      wg.Add(2)
      
      // 启动信号量
      go func() {
          sem1.Done()
          sem2.Done()
      }()
      
      // 等待信号量同步
      time.Sleep(10 * time.Second)
      
      // 使用条件变量和回调函数等待信号量完成
      go func() {
          sem1.Wait()
          sem2.Wait()
          wg.Done()
      }()
      
      // 执行处理器1的代码
      

      处理器1(sem)

      // 执行处理器2的代码
      

      处理器2(sem)

      // 执行等待信号量完成的代码
      wg.Wait()
      
      // 执行处理后的代码
      fmt.Println("All done!")
      

      } ```

      在这个示例中,我们首先创建了一个条件变量wg,然后使用Wait()方法等待信号量完成。然后,我们使用Go func() { ... }函数来创建两个回调函数,分别在信号量完成时执行。这两个回调函数分别调用了sem.Done()方法,这会导致信号量从等待状态变为完成状态。最后,我们执行了处理器1和处理器2的代码,以及等待信号量完成的代码。当所有处理器完成时,我们会看到处理器的输出,以及处理的信号量。

    更多回答
    扫一扫访问手机版
    • 回到顶部
    • 回到顶部