Golang自带的HttpClient超时机制怎么实现

//来自src/context/example_test.go
funcExampleWithValue(){
	typefavContextKeystring

	f:=func(ctxcontext.Context,kfavContextKey){
免费云主机域名
		ifv:=ctx.Value(k);v!=nil{
			fmt.Println("foundvalue:",v)
			return
		}
		fmt.Println("keynotfound:",k)
	}

	k:=favContextKey("language")
	ctx:=context.WithValue(context.Background(),k,"Go")

	f(ctx,k)
	f(ctx,favContextKey("color"))

	//Output:
	//foundvalue:Go
	//keynotfound:color
}

//来自src/context/example_test.go
gen:=func(ctxcontext.Context)
然后通过 context.WithCancel 生成一个可取消的 Context，传入 gen 方法，直到 gen 返回 5 时，调用 cancel 取消 gen 方法的执行。

//来自src/context/example_test.go
ctx,cancel:=context.WithCancel(context.Background())
defercancel()//cancelwhenwearefinishedconsumingintegers

forn:=rangegen(ctx){
	fmt.Println(n)
	ifn==5{
		break
	}
}
//Output:
//1
//2
//3
//4
//5

这么看起来，可以简单理解为在一个协程的循环中埋入结束标志，另一个协程去设置这个结束标志。

//来自src/context/example_test.go
funcExampleWithTimeout(){
	//Passacontextwithatimeouttotellablockingfunctionthatit
	//shouldabandonitsworkafterthetimeoutelapses.
	ctx,cancel:=context.WithTimeout(context.Background(),shortDuration)
	defercancel()

	select{
	case

	client:=http.Client{
		Timeout:10*time.Second,
	}
	
	//来自src/net/http/client.go
	typeClientstruct{
	//...省略其他字段
	//Timeoutspecifiesatimelimitforrequestsmadebythis
	//Client.Thetimeoutincludesconnectiontime,any
	//redirects,andreadingtheresponsebody.Thetimerremains
	//runningafterGet,Head,Post,orDoreturnandwill
	//interruptreadingoftheResponse.Body.
	//
	//ATimeoutofzeromeansnotimeout.
	//
	//TheClientcancelsrequeststotheunderlyingTransport
	//asiftheRequest'sContextended.
	//
	//Forcompatibility,theClientwillalsousethedeprecated
	//CancelRequestmethodonTransportiffound.New
	//RoundTripperimplementationsshouldusetheRequest'sContext
	//forcancellationinsteadofimplementingCancelRequest.
	Timeouttime.Duration
}

翻译一下注释：Timeout 包括了连接、redirect、读取数据的时间，定时器会在 Timeout 时间后打断数据的读取，设为0则没有超时限制。

	client:=http.Client{
		Timeout:10*time.Minute,
	}
	resp,err:=client.Get("http://127.0.0.1:81/hello")

//来自src/net/http/client.go
deadline=c.deadline()

//来自src/net/http/client.go
stopTimer,didTimeout:=setRequestCancel(req,rt,deadline)

登录后复制

//来自src/net/http/client.go
varcancelCtxfunc()
ifoldCtx:=req.Context();timeBeforeContextDeadline(deadline,oldCtx){
	req.ctx,cancelCtx=context.WithDeadline(oldCtx,deadline)
}

同时，再起一个定时器，当超时时间到了之后，将 timedOut 设置为 true，再调用 doCancel()，doCancel() 是调用真正 RoundTripper （代表一个 HTTP 请求事务）的 CancelRequest，也就是取消请求，这个跟实现有关。

//来自src/net/http/client.go
timer:=time.NewTimer(time.Until(deadline))
vartimedOutatomicBool

gofunc(){
	select{
	case
Go 默认 RoundTripper CancelRequest 实现是关闭这个连接

//位于src/net/http/transport.go
//CancelRequestcancelsanin-flightrequestbyclosingitsconnection.
//CancelRequestshouldonlybecalledafterRoundTriphasreturned.
func(t*Transport)CancelRequest(req*Request){
	t.cancelRequest(cancelKey{req},errRequestCanceled)
}

//位于src/net/http/transport.go
for{
	select{
	case
代码的开头监听 ctx.Done，如果超时则直接返回，使用 for 循环主要是为了请求的重试。

//位于src/net/http/transport.go
//Queueforidleconnection.
ifdelivered:=t.queueForIdleConn(w);delivered{
	//...
	returnpc,nil
}

如果没有空闲连接，起个协程去异步建立，建立成功再通知主协程

//位于src/net/http/transport.go
//Queueforpermissiontodial.
t.queueForDial(w)

再接着是一个 select 等待连接建立成功、超时或者主动取消，这就实现了在连接过程中的超时

//位于src/net/http/transport.go
//Waitforcompletionorcancellation.
select{
case

//位于src/net/http/transport.go
gopconn.readLoop()
gopconn.writeLoop()

//位于src/net/http/transport.go
func(pc*persistConn)writeLoop(){
	deferclose(pc.writeLoopDone)
	for{
		select{
		casewr:=