1. 簡介

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

2. 為什么需要超時控制

超時控制是指在進行網(wǎng)絡(luò)請求或者協(xié)程執(zhí)行等操作時，為了避免程序一直等待，造成資源浪費，我們需要對這些操作設(shè)置一個超時時間，在規(guī)定時間內(nèi)未完成操作，就需要停止等待或者終止操作。

例如，在進行網(wǎng)絡(luò)請求時，如果服務(wù)器端出現(xiàn)問題導致沒有及時響應(yīng)，客戶端可能會一直等待服務(wù)器的響應(yīng)，這樣會造成客戶端資源的浪費。

舉個簡單的例子，比如我們需要從遠程服務(wù)器獲取某個資源，我們可以使用以下代碼來進行實現(xiàn)：

func getResource() (Resource, error) {
    conn, err := net.Dial("tcp", "example.com:8888")
    if err != nil {
        return nil, err
    }
    defer conn.Close()
    // 發(fā)送請求并等待響應(yīng)
    _, err = conn.Write([]byte("GET /resource HTTP/1.1\r\nHost: example.com\r\n\r\n"))
    if err != nil {
        return nil, err
    }
    resp, err := ioutil.ReadAll(conn)
    if err != nil {
        return nil, err
    }
    // 解析響應(yīng)并返回資源
    return parseResource(resp)
}

但是如果遠程服務(wù)器在我們發(fā)送請求后一直沒有響應(yīng)，那么我們的程序就會一直等待，無法繼續(xù)執(zhí)行其他任務(wù)。

在某些情況下，這可能會導致程序的阻塞，從而影響程序的性能和穩(wěn)定性。因此，在進行網(wǎng)絡(luò)通信等操作時，尤其是在調(diào)用外部API或者訪問遠程服務(wù)器時，一定要使用超時控制。那么，在Go語言中，超時控制的實現(xiàn)方式有哪些呢？

3. 超時控制的方法

 3.1 time包實現(xiàn)超時控制    

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

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

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

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

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

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

3.2 context實現(xiàn)超時控制

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

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

// 創(chuàng)建一個timerCtx，設(shè)置超時時間為3秒     
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)     
// 調(diào)用cancel函數(shù),釋放占用的資源  
defer cancel()
// 使用一個channel來監(jiān)聽任務(wù)是否已完成
ch := make(chan string, 1)     
go func() {         
// 模擬任務(wù)執(zhí)行，休眠5秒         
    time.Sleep(2* time.Second)         
    ch <- "hello world"     
}()
// 通過select語句來等待結(jié)果,任務(wù)正常返回
select {
    case <-ctx.Done():
        fmt.Println("timeout")
    case result := <-ch:
        fmt.Println(result)
}

這里通過context.WithTimeout創(chuàng)建一個timerCtx，設(shè)定好超時時間，超時時間為3s。然后啟動一個協(xié)程來執(zhí)行具體的業(yè)務(wù)邏輯。

之后通過select語句，對timerCtx和業(yè)務(wù)執(zhí)行結(jié)果同時進行監(jiān)聽，當任務(wù)處理超時時，則執(zhí)行超時邏輯；如果任務(wù)在超時前完成，則執(zhí)行正常處理流程。通過這種方式，實現(xiàn)了請求的超時處理。

4. 適用場景分析

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

下面我簡單介紹幾種常見的場景，然后對其來進行分析，從而能夠在合適的場景下使用恰當?shù)脤崿F(xiàn)。

4.1 簡單超時控制

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

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

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

為了實現(xiàn)這個目的，此時可以使用time包或者timerCtx來實現(xiàn)超時控制。在makeRequest函數(shù)中實現(xiàn)超時控制，這里代碼展示與第三點超時控制的方法中的代碼示例大體相同，只需要將協(xié)程中sleep函數(shù)切換成具體的業(yè)務(wù)邏輯即可，這里不再贅述。而且，查看上面代碼示例，我們也可以看出來timer或者timerCtx在這個場景下，區(qū)別并不大，此時是可以相互替換的。

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

4.2 可選超時控制

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

func dialSerial(ras addrList) (Conn, error){
   // 執(zhí)行建立網(wǎng)絡(luò)連接的邏輯
}

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

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

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

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

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

func dialSerial(ctx context.Context, ras addrList) (Conn, error){
   // 執(zhí)行建立網(wǎng)絡(luò)連接的邏輯，對每個地址嘗試建立連接時，先檢查是否超時
   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: 
       }
       // 執(zhí)行建立網(wǎng)絡(luò)連接的邏輯
   }
}

查看上述代碼中，dialSerial函數(shù)實現(xiàn)可選超時控制，看起來只是傳入?yún)?shù)不同，一個是傳入定時器time.Timer實例，一個是傳入context.Context接口實例而已，但是實際上不僅僅如此。

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

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

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

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

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

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

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

總結(jié)

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

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

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

5.總結(jié)

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

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

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

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

以上就是深入了解Golang為什么需要超時控制的詳細內(nèi)容，更多關(guān)于Golang超時控制的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論