go - 确保一次仅处理一个请求，并丢弃其他传入的请求

Question

我有一个goroutine，我们称它为goProcessor，它处理来自其他goroutine的请求。goProcessor一次只能处理一个请求。如果有一个请求，我们称它为 req2 ，而goProcessor仍在处理先前的 req1 请求，这是必须丢弃的 req2 ，它只会丢失。
我已经使用无缓冲 channel 和select语句实现了这样的逻辑，但是我不确定是否可以有一种更简单，更优雅的方式来完成我想要的事情。我的解决方案的一个简单示例是

var c = make(chan string)

func main() {

    goRequest := func(request string, delay int) {
        time.Sleep(time.Duration(delay) * time.Second)
        fmt.Printf("Here I am request %v\n", request)
        select {
        case c <- request:
            fmt.Printf("%v sent\n", request)
        default:
            fmt.Printf("%v discarded\n", request)
        }
    }

    goProcessor := func() {
        for {
            msg := <-c
            fmt.Println("received", msg)
            time.Sleep(3 * time.Second)
            fmt.Println("processed", msg)
        }
    }

    go goRequest("First req", 1)
    go goRequest("Second req", 2)
    go goRequest("Third req", 5)
    go goProcessor()

    time.Sleep(10 * time.Second)

    fmt.Println("Main has finished")
}

Answer 1

您所做的工作非常完美和干净。您唯一可以简化的就是在for range中使用goProcessor()，如下所示:

for msg := range c {
    // ...
}

但除此之外，这是惯用的。
我可能会想到在这里使用“TryLock”。标准库中没有“TryLock”(为此提供了 3rd party libs)，但是在您的情况下使用它不是更简单或更惯用，因此您必须检查 TryLock()是否返回 true，并且必须将其解锁。而且，您仍然需要一个 channel 将结果发送到处理器，因此您的解决方案更加简单和简洁。