显然在Go语言1.3中http.客户端有超时字段

client := http.Client{
    Timeout: 5 * time.Second,
}
client.Get(url)

这对我来说已经够了。

您需要使用自己的传输设置自己的客户端，该传输使用围绕DialTimeout的自定义拨号功能。
类似于（完全 * 未经测试 *）this：

var timeout = time.Duration(2 * time.Second)

func dialTimeout(network, addr string) (net.Conn, error) {
    return net.DialTimeout(network, addr, timeout)
}

func main() {
    transport := http.Transport{
        Dial: dialTimeout,
    }

    client := http.Client{
        Transport: &transport,
    }

    resp, err := client.Get("http://some.url")
}

如果您希望对每个请求执行此操作，则为了简洁起见，忽略错误处理：

ctx, cncl := context.WithTimeout(context.Background(), time.Second*3)
defer cncl()

req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "https://google.com", nil)

resp, _ := http.DefaultClient.Do(req)

为了补充Volker的答案，如果您还想设置除连接超时之外的读/写超时，可以执行如下操作

package httpclient

import (
    "net"
    "net/http"
    "time"
)

func TimeoutDialer(cTimeout time.Duration, rwTimeout time.Duration) func(net, addr string) (c net.Conn, err error) {
    return func(netw, addr string) (net.Conn, error) {
        conn, err := net.DialTimeout(netw, addr, cTimeout)
        if err != nil {
            return nil, err
        }
        conn.SetDeadline(time.Now().Add(rwTimeout))
        return conn, nil
    }
}

func NewTimeoutClient(connectTimeout time.Duration, readWriteTimeout time.Duration) *http.Client {

    return &http.Client{
        Transport: &http.Transport{
            Dial: TimeoutDialer(connectTimeout, readWriteTimeout),
        },
    }
}

这段代码已经过测试，正在生产中运行。完整的测试要点可以在这里找到https://gist.github.com/dmichael/5710968
请注意，您需要为每个请求创建一个新客户端，因为conn.SetDeadline引用了time.Now()中的未来某个时间点

又急又脏的道：

http.DefaultTransport.(*http.Transport).ResponseHeaderTimeout = time.Second * 45

这是一个没有任何协调的全局状态的变化。但是它可能对你的url提取器来说是好的。否则创建一个http.RoundTripper的私有示例：

var myTransport http.RoundTripper = &http.Transport{
        Proxy:                 http.ProxyFromEnvironment,
        ResponseHeaderTimeout: time.Second * 45,
}

var myClient = &http.Client{Transport: myTransport}

resp, err := myClient.Get(url)
...

未对上述内容进行测试。

在Go http模块中有几个客户端超时，并且有一些关于当前答案的超时示例。
这里有一张图片说明客户端超时，请参阅The complete guide to Go net/http timeouts

有两种方法可以设置HTTP请求的超时

• http.Client

client := http.Client{
    Timeout: 3 * time.Second,
}
resp, err := client.Do(req)

• 上下文

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, URL)

The difference between them为

• 使用上下文是特定于请求的，而使用客户端超时可能应用于所有请求传递到客户端具有的Do方法。
• 如果您希望将deadline/timeout专门用于每个请求，则使用context，否则，如果您希望每个出站请求都有1个超时，则使用client timeout就足够了。

timeout := time.Duration(5 * time.Second)
transport := &http.Transport{Proxy: http.ProxyURL(proxyUrl), ResponseHeaderTimeout:timeout}

这可能会有所帮助，但请注意，ResponseHeaderTimeout仅在建立连接后启动。