為什么需要超時控制

1. 簡介

本文將介紹為什么需要超時控制，然后詳細介紹Go語言中實現超時控制的方法。其中，我們將討論time包和context包實現超時控制的具體方式，并說明兩者的適用場景，以便在程序中以更合適的方式來實現超時控制，提高程序的穩定性和可靠性。

2. 為什么需要超時控制

超時控制可以幫助我們避免程序無限期地等待某個操作完成或者防止程序因為某些原因導致資源泄漏。具體來說，超時控制有以下幾個優點：

避免無限期等待：如果某個操作需要等待一段時間，但如果超過了這個時間還沒有完成，那么程序可能就需要停止等待并采取其他措施，比如返回錯誤或者取消操作。超時處理可以讓程序避免無限期等待，從而提高程序的健壯性和可靠性。
防止資源泄漏：如果程序某個操作一直處于等待狀態，那么可能會導致資源被一直占用，從而造成資源泄漏。超時控制可以讓程序在一定時間內完成操作，如果超時則釋放資源，從而避免資源泄漏。
提高程序響應速度：有些操作可能需要很長時間才能完成，這可能會導致程序在等待過程中變得不響應。超時控制可以讓程序在一定時間內完成操作，如果超時則采取其他措施，從而提高程序的響應速度。

基于以上幾點原因，我們可以看出來，在某些場景下，超時控制在程序執行過程中必不可少。那么，在Go語言中，有哪些方式可以實現超時控制呢？

3. 超時控制的方法

3.1 time包實現超時控制

time包提供了多種方式來實現超時控制，包括time.After函數、time.NewTimer函數以及time.AfterFunc函數，使用它們可以實現超時控制，下面以time.NewTimer函數為例，說明如何使用其time包實現超時控制。代碼示例如下:

// 創建一個定時器
timer := time.NewTimer(5 * time.Second)
defer timer.Stop()

// 使用一個channel來監聽任務是否已完成
ch := make(chan string, 1)     
go func() {         
// 模擬任務執行，休眠5秒         
    time.Sleep(2* time.Second)         
    ch <- "hello world"     
}()

// 通過select語句來等待結果,任務正常返回
select {
case <-ch:
    fmt.Println("任務正常完成")
  // ch 已經接收到值，走正常處理邏輯
case <-timer.C:
    fmt.Println("已超時")
  // 超時，走超時邏輯
}

在這里例子中，我們使用 time.NewTimer 方法創建一個定時器，超時時間為2秒鐘。然后在 select 語句中使用來等待結果，哪個先返回就使用哪個。

如果操作在2秒鐘內完成，那么任務正常完成；如果操作超過2秒鐘仍未完成，此時select語句中<-timer.C將接收到值，走超時處理邏輯。

3.2 context實現超時控制

Context 接口是 Go 語言標準庫中提供的一個上下文（Context）管理機制。它允許在程序的不同部分之間傳遞上下文信息，并且可以通過它實現超時控制、取消操作以及截斷操作等功能。其中，Context接口存在一個timerCtx的實現，其可以設定一個超時時間，在到達超時時間后，timerCtx對象的 done channel 將會被關閉。

當需要判斷是否超時時，只需要調用 context 對象的 Done 方法，其會返回timerCtx對象中的done channel，如果有數據返回，則說明已經超時。基于此，我們便可以實現超時控制。代碼示例如下:

// 創建一個timerCtx，設置超時時間為3秒     
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)     
// 調用cancel函數,釋放占用的資源  
defer cancel()

// 使用一個channel來監聽任務是否已完成
ch := make(chan string, 1)     
go func() {         
// 模擬任務執行，休眠5秒         
    time.Sleep(2* time.Second)         
    ch <- "hello world"     
}()

// 通過select語句來等待結果,任務正常返回
select {
    case <-ctx.Done():
        fmt.Println("timeout")
    case result := <-ch:
        fmt.Println(result)
}

這里通過context.WithTimeout創建一個timerCtx，設定好超時時間，超時時間為3s。然后啟動一個協程來執行具體的業務邏輯。

之后通過select語句，對timerCtx和業務執行結果同時進行監聽，當任務處理超時時，則執行超時邏輯；如果任務在超時前完成，則執行正常處理流程。通過這種方式，實現了請求的超時處理。

4. 適用場景分析

從上文可以看出，time和 timerCtx都可以用于實現超時控制，但是事實上兩者的適用場景其實是不太相同的。在某些場景下,超時控制并不適合使用time來實現，而是使用timerCtx來實現更為合適。而在某些場景下，其實兩種實現方式均可。

下面我簡單介紹幾種常見的場景，然后對其來進行分析，從而能夠在合適的場景下使用恰當得實現。

4.1 簡單超時控制

舉個例子，假設我們需要從一個遠程服務獲取一些數據，我們可以使用Go標準庫中的http包進行網絡請求，大概請求函數如下:

func makeRequest(url string) (string, error) {
   // 請求數據
}

此時為了避免請求響應時間過長，導致程序長時間處于等待狀態，此時我們需要對這個函數實現超時處理，確保程序能夠及時響應其他請求，而不是一直等待。

為了實現這個目的，此時可以使用time包或者timerCtx來實現超時控制。在makeRequest函數中實現超時控制，這里代碼展示與第三點超時控制的方法中的代碼示例大體相同，這里不再贅述。而且，查看上面代碼示例，我們也可以看出來timer或者timerCtx在這個場景下，區別并不大，此時是可以相互替換的。

因此，對于這種控制某個函數的執行時間的場景，是可以任意挑選time或者timerCtx其中一個來實現的。

4.2 可選超時控制

這里我們實現一個方法，用于建立網絡連接，用戶調用該方法時，傳入待建立連接的地址列表，然后該方法通過遍歷傳入的地址列表，并針對每一個地址進行連接嘗試，直到連接成功或者所有地址都嘗試完成。函數定義如下:

func dialSerial(ras addrList) (Conn, error){
   // 執行建立網絡連接的邏輯
}

基于此，在這個函數的基礎上，實現一個可選的超時控制的功能。如果用戶調用該方法時，有指定超時時間的話，此時便進行超時控制；如果未指定超時時間的話，此時便無需執行超時控制。這里分別使用time包以及context實現。

首先對于time包實現可選的超時控制，可以通過函數參數傳遞定時器來實現可選的超時控制。具體地說，可以將定時器作為一個time.Timer類型的參數傳遞給函數，然后在函數中使用select監聽time.Timer是超時；如果沒有傳遞定時器實例，則默認不進行超時控制，代碼實現如下所示:

func dialSerial(timeout time.Timer, ras addrList) (Conn, error){
   // 執行建立網絡連接的邏輯，對每個地址嘗試建立連接時，先檢查是否超時
   for i, ra := range ras {
          // 通過這里來進行超時控制,首先先判斷是否傳入定時器實例
          if timeout != nil {
              select {
              // 監聽是否超時
              case <-timeout.C:
                  return nil, errors.New("timeout")
              default:
              }
          }
         // 執行后續建立網絡連接的邏輯          
   }
}

接著則是使用timerCtx來實現超時控制的實現，可以通過函數傳遞一個context.Context接口的參數來實現超時控制。

具體來說，用戶可以傳遞一個context.Context接口的實現，如果有指定超時時間，則傳入一個timerCtx的實現；如果無需超時控制，此時可以傳入context.Background，其永遠不會超時。然后函數中通過調用Done方法來判斷是否超時，從而實現超時控制。代碼實現如下:

func dialSerial(ctx context.Context, ras addrList) (Conn, error){
   // 執行建立網絡連接的邏輯，對每個地址嘗試建立連接時，先檢查是否超時
   for i, ra := range ras {
       select {
       case <-ctx.Done():
          return nil, &OpError{Op: "dial", Net: sd.network, Source: sd.LocalAddr, Addr: ra, Err: mapErr(ctx.Err())}
       default: 
       }
       // 執行建立網絡連接的邏輯
   }
}

查看上述代碼中，dialSerial函數實現可選超時控制，看起來只是傳入參數不同，一個是傳入定時器time.Timer實例，一個是傳入context.Context接口實例而已，但是實際上不僅僅如此。

首先是代碼的可讀性上來看，傳入time.Timer實例來實現超時控制，并非Go中常見的實現方式，用戶不好理解；而對于context.Context接口來說，其被廣泛使用，如果要實現超時控制，用戶只需要傳入一個timerCtx實例即可，用戶使用起來沒有額外的心智負擔，代碼可讀性更強。

其次是對于整個Go語言的生態來說，context.Context接口在Go語言標準庫中得到廣泛使用，而且普遍超時控制都是使用timerCtx來實現的，如果此時傳入一個time.Timer實例，實際上是與整個Go語言的超時控制的格格不入的。以上面dialSerial方法為例，其建立網絡連接是需要調用底層函數來協助實現的，如:

func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa syscall.Sockaddr, ret error) {
    // 執行建立連接的邏輯
    switch err := connectFunc(fd.pfd.Sysfd, ra); err {
    // 未報錯,此時檢查是否超時
    case nil, syscall.EISCONN:
       select {
       case <-ctx.Done():
           // 如果已經超時,此時返回超時錯誤
          return nil, mapErr(ctx.Err())
       default:
       }
     }
}

而且剛好，該函數也是實現了可選的超時控制，而且是通過timerCtx來實現的，如果此時傳入的timerCtx已經超時，此時函數會直接返回一個超時錯誤。

如果上面dialSerial的超時控制是通過context.Context的接口實例來實現的話，此時調用函數時，直接將外部的Context實例作為參數傳入connect函數，外層調用也無需再檢查函數是否超時，代碼的可復用性更高。

相對的，如果dialSerial的超時控制是通過傳入定時器實現的，此時便無法很好利用connect方法已經實現的超時檢查的機制。

因此，綜上所述，使用 context.Context 接口作為可選的超時控制參數，相比于使用 time.Timer，更加適合同時也更加高效，與整個Go語言的實現也能夠更好得進行融合在一起。

4.3 總結

Context 和 Time 都是 Go 語言中實現超時控制的方法，它們各有優缺點，不能說哪一種實現更好，要根據具體的場景來選擇使用哪種方法。

在一些簡單的場景下，使用 Time 包實現超時控制可能更加方便，因為它的 API 更加簡單，只需要使用 time.After() 函數即可實現超時控制。

但是，如果涉及到在多個函數，或者是需要多個goroutine之間傳遞的話，此時使用Context來實現超時控制可能更加適合。

5.總結

本文介紹了需要超時控制的原因，主要是避免無限期等待，防止資源泄漏和提高程序響應速度這幾點內容。

接著我們介紹了Go語言中實現超時控制的方法，包括使用time實現超時控制以及使用context實現超時控制，并給出了簡單的代碼示例。

在接下來，我們便這兩種實現的適用場景進行分析，明確了在哪些場景下，適合使用time實現超時控制，以及在哪些場景下，使用timerCtx來實現更為高效。

基于此，完成了為什么需要超時控制的介紹，希望能夠讓大家在遇到需要超時控制的場景下，更好得去進行實現。

posted @ 2023-05-07 15:43 菜鳥額閱讀(119) 評論(0) 收藏舉報

刷新頁面返回頂部

菜鳥額