Golang中time.After如何使用

本篇文章給大家分享的是有關Golang中time.After如何使用，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

Golang中的time.After的使用理解

關于在goroutine中使用time.After的理解， 新手在學習過程中的“此時此刻”的理解，錯誤還請指正。

先線上代碼：

package main

import (
 "fmt"
 "time"
)


func main() {
 //closeChannel()
 c := make(chan int)
 timeout := time.After(time.Second * 2) //
 t1 := time.NewTimer(time.Second * 3) // 效果相同 只執行一次
 var i int
 go func() {
 for {
 select {
 case <-c:
 fmt.Println("channel sign")
 return
 case <-t1.C: // 代碼段2
 fmt.Println("3s定時任務")
 case <-timeout: // 代碼段1
 i++
 fmt.Println(i, "2s定時輸出")
 case <-time.After(time.Second * 4): // 代碼段3
 fmt.Println("4s timeout。。。。") 
 default:    // 代碼段4
 fmt.Println("default")
 time.Sleep(time.Second * 1)
 }
 }
 }()
 time.Sleep(time.Second * 6)
 close(c)
 time.Sleep(time.Second * 2)
 fmt.Println("main退出")
}

主要有以上4點是我們平時遇到的。

首先遇到的問題是：

              如上的代碼情況下， 代碼段3處的case 永遠不執行， 無論main進程執行多久。這是為什么呢？

首先我們分析為啥不執行代碼段3， 而是程序一直執行的是default.  由此我們判斷：

                case <- time.After(time.Second)  :  

                是本次監聽動作的超時時間， 意思就說，只有在本次select 操作中會有效， 再次select 又會重新開始計時（從當前時間+4秒后）， 但是有default ，那case 超時操作，肯定執行不到了。

                那么問題就簡單了我們預先定義了計時操作：

                case <- timeout:

                    在goroutine開始前， 我們記錄了時間，在此時間3s之后進行操作。相當于定時任務， 并且只執行一次。 代碼段1和代碼段2 實現的結果都相同

針對以上問題解決后，我寫了一個小案例：

package main

import (
 "fmt"
 "time"
)

//發送者
func sender(c chan int) {
 for i := 0; i < 100; i++ {
 c <- i
 if i >= 5 {
 time.Sleep(time.Second * 7)
 } else {
 time.Sleep(time.Second)
 }
 }
}

func main() {
 c := make(chan int)
 go sender(c)
 timeout := time.After(time.Second * 3)
 for {
 select {
 case d := <-c:
 fmt.Println(d)
 case <-timeout:
 fmt.Println("這是定時操作任務 >>>>>")
 case dd := <-time.After(time.Second * 3):
 fmt.Println(dd, "這是超時*****")
 }

 fmt.Println("for end")
 }
}

執行結果：

要注意的是，雖然執行到i == 6時， 堵塞了，并且執行了超時操作， 但是下次select 依舊去除的是6

因為通道中已經發送了6,如果未取出，程序堵塞。

GOLANG中time.After釋放的問題

在謝大群里看到有同學在討論time.After泄漏的問題，就算時間到了也不會釋放，瞬間就驚呆了，忍不住做了試驗，結果發現應該沒有這么的恐怖的，是有泄漏的風險不過不算是泄漏，先看API的說明：

// After waits for the duration to elapse and then sends the current time
// on the returned channel.
// It is equivalent to NewTimer(d).C.
// The underlying Timer is not recovered by the garbage collector
// until the timer fires. If efficiency is a concern, use NewTimer
// instead and call Timer.Stop if the timer is no longer needed.
func After(d Duration) <-chan Time {
 return NewTimer(d).C
}

提到了一句The underlying Timer is not recovered by the garbage collector，這句挺嚇人不會被GC回收，不過后面還有條件until the timer fires，說明fire后是會被回收的，所謂fire就是到時間了，寫個例子證明下壓壓驚：

package main

import "time"

func main() {
 for {
  <- time.After(10 * time.Nanosecond)
 }
}

顯示內存穩定在5.3MB，CPU為161%，肯定被GC回收了的。當然如果放在goroutine也是沒有問題的，一樣會回收：

package main

import "time"

func main() {
 for i := 0; i < 100; i++ {
  go func(){
   for {
    <- time.After(10 * time.Nanosecond)
   }
  }()
 }
 time.Sleep(1 * time.Hour)
}

只是資源消耗會多一點，CPU為422%，內存占用6.4MB。因此：

Remark: time.After(d)在d時間之后就會fire，然后被GC回收，不會造成資源泄漏的。

那么API所說的If efficieny is a concern, user NewTimer instead and call Timer.Stop是什么意思呢？這是因為一般time.After會在select中使用，如果另外的分支跑得更快，那么timer是不會立馬釋放的(到期后才會釋放)，比如這種：

select {
 case time.After(3*time.Second):
  return errTimeout
 case packet := packetChannel:
  // process packet.
}

如果packet非常多，那么總是會走到下面的分支，上面的timer不會立刻釋放而是在3秒后才能釋放，和下面代碼一樣：

package main

import "time"

func main() {
 for {
  select {
  case <-time.After(3 * time.Second):
  default:
  }
 }
}

這個時候，就相當于會堆積了3秒的timer沒有釋放而已，會不斷的新建和釋放timer，內存會穩定在2.8GB，這個當然就不是最好的了，可以主動釋放：

package main

import "time"

func main() {
 for {
  t := time.NewTimer(3*time.Second)

  select {
  case <- t.C:
  default:
   t.Stop()
  }
 }
}

這樣就不會占用2.8GB內存了，只有5MB左右。因此，總結下這個After的說明：

• GC肯定會回收time.After的，就在d之后就回收。一般情況下讓系統自己回收就好了。

• 如果有效率問題，應該使用Timer在不需要時主動Stop。大部分時候都不用考慮這個問題的。

以上就是Golang中time.After如何使用，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。