接纳最迅速的职场机会

从现在开始，努力学习吧！本文《接纳最迅速的职场机会》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

请考虑这个问题。

目前我有一种方法可以完成一项工作：

for {
  var result string 
  var resultok bool
  result, resultok = worker1(job) 
  if resultok {
     // go on to other things
  }
  ...
}

假设我们现在有另一种机制，可能能够更快地完成这项工作 - 让我们称之为 worker2。请注意，在某些情况下，worker1 可能会更快。

启动这两个工作人员并接受第一个成功完成的工作人员的结果的惯用方法是什么？

我知道 select 机制，但它不关心 resultok bool。

select {
case <- c1:
  // worker1 finished
case <- c2:
  // worker2 finished
case <- time.After(10 * time.Second):
  // we need to move on
}

如有任何建议，我们将不胜感激！

正确答案

通常，这是通过让每个工作人员在同一通道上传递结果并从该通道接收（一次）来解决的。谁更快，谁的结果就被使用。通过例如“向其他缓慢的员工发出信号”也是一个好主意。使用 context.Context（不再需要他们的工作，他们应该尽快中止）。

如果您只从通道接收一次，则必须注意不要阻止慢速工作人员，以防他们最终完成工作并尝试发送结果：他们可能会永远被阻止。因此，通道应该有足够大的缓冲区，以免阻塞工作人员，或者工作人员应使用具有 default 分支的 select 语句进行发送，以便在发送操作无法执行时不会被阻塞。

如果工作人员产生的结果不可接受（例如发生错误），工作人员当然可以决定不发送任何结果。当然，还要小心，因为如果所有的worker都失败了，就不会发送任何结果，因此接收方可能会永远等待。这可以通过使用超时来避免，或者让工作人员发送指示失败的结果（接收者必须处理该结果，在这种情况下必须继续接收，直到收到好的结果或没有更多结果出现）。

使用代码的示例：

func main() {
    result, err := RunConcurrent(1000, TimeConsumingWork)
    fmt.Println("result =", result, "error =", err)
}

type workFn func(ctx context.Context, input any) (any, error)

// RunConcurrent executes the workFn on `n` amount of goroutines
func RunConcurrent(n int, fn workFn) (any, error) {

    wg := sync.WaitGroup{}
    wg.Add(n)

    resultChan := make(chan any, n) // there are potentially `n` results

    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // this will signal other routines to stop

    for i := 0; i < n; i++ {
        go func(v any) { // run function as in new routine
            defer wg.Done() // signal this routine is done

            result, err := fn(ctx, v)
            if err != nil {
                return
            }

            select { // try to store result on result channel. If ctx.Done, stop trying.
            case resultChan <- result:
            case <-ctx.Done():
            }
        }(i)
    }

    go func() {
        wg.Wait()
        close(resultChan) // DO NOT CLOSE before ALL routines are done. This is an easy way to create a deadlock...
    }()

    v, ok := <-resultChan // check if result is valid and not the result of closed channel
    if !ok {
        return nil, errors.New("no results")
    }
    return v, nil
}

func TimeConsumingWork(ctx context.Context, input any) (any, error) {
    simulatedExecutionTime := time.Duration(10+rand.Intn(50)) * time.Millisecond

    select { // do time consuming work, until context is done
    case <-time.After(simulatedExecutionTime):
        if rand.Intn(2) == 0 {
            return nil, errors.New("simulated a random error")
        }
        return input, nil
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《接纳最迅速的职场机会》文章吧，也可关注golang学习网公众号了解相关技术文章。