何时在netty中使用Unpooled(when to use Unpooled in netty)

 这样写的代码会产生一个死锁。 但是，渠道不一定要关闭。 有多种方法可以解决此问题。 
 
 例如，你可以通过以下方法替换for / select循环： 
 
n := len(requests)
for r := range ch {
    processResponse(r)
    n--
    if n == 0 {
        break
    }
}
 
 这里我们假设潜在的超时在每个goroutine中进行管理。 
 
 另一个真正依赖关闭频道的解决方案可以写成如下： 
 
func asyncHttpGets(requests []HttpRequest) {

    ch := make(chan *HttpResponse)
    var wg sync.WaitGroup
    for _, request := range requests {
        wg.Add(1)
        go func(r HttpRequest) {
            defer wg.Done()
            resp, err := http.Get(r.url)
            ch <- &HttpResponse{r, resp, err}
        }(request)
    }

    go func() {
        wg.Wait()
        close(ch)
    }()
    for r := range ch {
        processResponse(r)
    }
}
 
 请注意，比较初始代码，请求变量不是从goroutine访问的，而是作为参数传递的。 因此，通过通道发布的输出数据结构是一致的。 这是初始代码中的一个问题。 有关此特定主题的更多信息，请访问： https ： //github.com/golang/go/wiki/CommonMistakes 
 
 另一种解决方案是使用原子计数器计数goroutine中的响应，并在计数器达到极限时明确关闭通道。 但是处理同步/原子常常容易出错，所以在这里可能不是个好主意。 
 
 最后，有时您需要获得更多控制权才能正确管理超时，错误等... Tomb包可以帮助您以安全的方式管理goroutines的生命周期。 
 
 请参阅https://github.com/go-tomb/tomb/tree/v2 

The code, written like this, will produce a deadlock. But, the channel does not have necessarily to be closed. There are multiple ways to solve this issue.
 
For instance, you could replace the for/select loop by:
 
n := len(requests)
for r := range ch {
    processResponse(r)
    n--
    if n == 0 {
        break
    }
}
 
Here we assume that the potential timeouts are managed in each goroutine.
 
Another solution, which really relies on closing the channel could be written as follows:
 
func asyncHttpGets(requests []HttpRequest) {

    ch := make(chan *HttpResponse)
    var wg sync.WaitGroup
    for _, request := range requests {
        wg.Add(1)
        go func(r HttpRequest) {
            defer wg.Done()
            resp, err := http.Get(r.url)
            ch <- &HttpResponse{r, resp, err}
        }(request)
    }

    go func() {
        wg.Wait()
        close(ch)
    }()
    for r := range ch {
        processResponse(r)
    }
}
 
Note that compared the initial code, the request variable is not accessed from the goroutine, but passed as a parameter. The output data structure posted via the channel is therefore consistent. This was an issue in the initial code. See more information about this specific topic at: https://github.com/golang/go/wiki/CommonMistakes
 
Yet another solution would be to count the responses in the goroutines using an atomic counter, and explicitly close the channel when the counter reaches the limit. But dealing with sync/atomic is often error-prone, so it is probably not a good idea here.
 
Finally, sometimes you need to get more control in order to properly manage timeouts, errors, etc ... The tomb package can help you to manage the lifecycle of the goroutines in a safe way.
 
See https://github.com/go-tomb/tomb/tree/v2