如果阻塞，如何将http.Serve放在自己的goroutine中？

http.Serve either returns an error as soon as it is called or blocks if successfully executing.

How can I make it so that if it blocks it does so in its own goroutine? I currently have the following code:

func serveOrErr(l net.Listener, handler http.Handler) error {
    starting := make(chan struct{})
    serveErr := make(chan error)
    go func() {
        starting <- struct{}{}
        if err := http.Serve(l, handler); err != nil {
            serveErr <- err 
        }   
    }()
    <-starting

    select {
    case err := <-serveErr:
        return err
    default:
        return nil
    }
}

This seemed like a good start and works on my test machine but I believe that there are no guarantees that serveErr <- err would be called before case err := <-serveErr therefore leading to inconsistent results due to a data race if http.Serve were to produce an error.

http.Serve either returns an error as soon as it is called or blocks if successfully executing

This assumption is not correct. And I believe it rarely occurs. http.Serve calls net.Listener.Accept in the loop – an error can occur any time (socket closed, too many open file descriptors etc.). It's http.ListenAndServe, usually being used for running http servers, which often fails early while binding listening socket (no permissions, address already in use).

In my opinion what you're trying to do is wrong, unless really your net.Listener.Accept is failing on the first call for some reason. Is it? If you want to be 100% sure your server is working, you could try to connect to it (and maybe actually transmit something), but once you successfully bound the socket I don't see it really necessary.

You could use a timeout on your select statement, e.g.

timeout := time.After(5 * time.Millisecond) // TODO: ajust the value
select {
case err := <-serveErr:
    return err
case _ := <- timeout:
    return nil
}

This way your select will block until serveErr has a value or the specified timeout has elapsed. Note that the execution of your function will therefore block the calling goroutine for up to the duration of the specified timeout.

Rob Pike's excellent talk on go concurrency patterns might be helpful.