1. 程式人生 > >go-time簡解

go-time簡解

go語言的time包

組成

  • time.Duration(時長,耗時)
  • time.Time(時間點)
  • time.C(放時間點的管道)[ Time.C:=make(chan time.Time) ]

time包裡有2個東西,一個是時間點,另一個是時長 
時間點的意思就是“某一刻”,比如 2000年1月1日1點1分1秒 那一刻(後臺記錄的是unix時間,從1970年開始計算) 
時長就是某一刻與另一刻的差,也就是耗時

函式

Sleep函式

time.Sleep(time.Duration) 
表示睡多少時間,睡覺時,是阻塞狀態

 
  1. fmt.Println("start sleeping...")

  2. time.Sleep(time.Second)

  3. fmt.Println("end sleep.")

  4. //【結果】列印start sleeping後,等了正好1秒後,列印了end sleep

  5. //會阻塞,Sleep時,什麼事情都不會做

time.sleep

After函式

time.After(time.Duration) 
和Sleep差不多,意思是多少時間之後,但在取出管道內容前不阻塞

 
  1. fmt.Println("the 1")

  2. tc:=time.After(time.Second) //返回一個time.C這個管道,1秒(time.Second)後會在此管道中放入一個時間點(time.Now())

  3. //時間點記錄的是放入管道那一刻的時間值

  4. fmt.Println("the 2")

  5. fmt.Println("the 3")

  6. <-tc //阻塞中,直到取出tc管道里的資料

  7. fmt.Println("the 4")

  8. //【結果】立即列印123,等了1秒不到一點點的時間,列印了4,結束

  9. //列印the 1後,獲得了一個空管道,這個管道1秒後會有資料進來

  10. //列印the 2,(這裡可以做更多事情)

  11. //列印the 3

  12. //等待,直到可以取出管道的資料(取出資料的時間與獲得tc管道的時間正好差1秒鐘)

  13. //列印the 4

time.After1

 
  1. fmt.Println("the 1")

  2. tc:=time.After(time.Second) //返回一個time.C這個管道,1秒(time.Second)後會在此管道中放入

  3. //一個時間點(time.Now()),時間點記錄的是放入管道那一刻的時間值

  4. fmt.Println("the 2")

  5. fmt.Println("the 3")

  6. time.Sleep(time.Second*0.5)//這裡是假設這個Println動作執行了半秒鐘

  7. fmt.Println("the 4")

  8. time.Sleep(time.Second*0.5)//這裡是假設這個Println動作執行了半秒鐘

  9. fmt.Println("the 5")

  10. fmt.Println("the 6")

  11. fmt.Println("the 7")

  12. <-tc //阻塞中,直到取出tc管道里的資料

  13. fmt.Println("the 8")

  14. //【結果】立即列印1和2,花了半秒列印了3和4,然後又立即列印了5678,結束

  15. //這裡的<-tc是立即能獲得資料的

  16. //因為早在執行差不多Print 6的時候,管道內已經有資料了

  17. //當gorotine線把資料丟到管道中後,它自己阻塞了(具體請了解goroutine)

time.After2

AfterFunc函式

time.AfterFunc(time.Duration,func()) 
和After差不多,意思是多少時間之後在goroutine line執行函式

 
  1. f := func() {

  2. fmt.Println("Time out")

  3. }

  4. time.AfterFunc(1*time.Second, f)

  5. time.Sleep(2 * time.Second) //要保證主線比子線“死的晚”,否則主線死了,子線也等於死了

  6. //【結果】運行了1秒後,打印出timeout,又過了1秒,程式退出

  7. //將一個間隔和一個函式給AfterFunc後

  8. //間隔時間過後,執行傳入的函式

time.AfterFunc

由於f函式不是在Main Line執行的,而是註冊在goroutine Line裡執行的 
所以一旦後悔的話,需要使用Stop命令來停止即將開始的執行,如果已經開始執行就來不及了

 
  1. houhui := true

  2. f := func() {

  3. fmt.Println("Time out")

  4. }

  5. ta := time.AfterFunc(2*time.Second, f)

  6. time.Sleep(time.Second)

  7. if houhui {

  8. ta.Stop()

  9. }

  10. time.Sleep(3 * time.Second) //要保證主線比子線“死的晚”,否則主線死了,子線也等於死了

  11. //【結果】運行了3秒多一點點後,程式退出,什麼都不列印

  12. //註冊了個f函式,打算2秒後執行

  13. //過了1秒後,後悔了,停掉(Stop)它

Tick函式

time.Tick(time.Duration) 
和After差不多,意思是每隔多少時間後,其他與After一致

 
  1. fmt.Println("the 1")

  2. tc:=time.Tick(time.Second) //返回一個time.C這個管道,1秒(time.Second)後會在此管道中放入一個時間點,

  3. //1秒後再放一個,一直反覆,時間點記錄的是放入管道那一刻的時間

  4. for i:=1;i<=2;i++{

  5. <-tc

  6. fmt.Println("hello")

  7. }

  8. //每隔1秒,列印一個hello

time.Tick

time.Time的方法(time.Time自己獨有的函式)

Before & After方法

判斷一個時間點是否在另一個時間點的前面(後面),返回true或false

 
  1. t1:=time.Now()

  2. time.Sleep(time.Second)

  3. t2:=time.Now()

  4. a:=t2.After(t1) //t2的記錄時間是否在t1記錄時間的**後面**呢,是的話,a就是true

  5. fmt.Println(a) //true

  6. b:=t2.Before(t1) //t2的記錄時間是否在t1記錄時間的**前面**呢,是的話,b就是true

  7. fmt.Println(b) //false

Sub方法

兩個時間點相減,獲得時間差(Duration)

 
  1. t1:=time.Now()

  2. time.Sleep(time.Second)

  3. t2:=time.Now()

  4. d:=t2.Sub(t1) //時間2減去時間1

  5. fmt.Println(d) //列印結果差不多為1.000123幾秒,因為Sleep無法做到精確的睡1秒

  6. 後發生的時間 減去 先發生時間,是正數

Add方法

拿一個時間點,add一個時長,獲得另一個時間點

 
  1. t1:=time.Now() //現在是12點整(假設),那t1記錄的就是12點整

  2. t2:=t1.Add(time.Hour) //那t1的時間點 **加上(Add)** 1個小時,是幾點呢?

fmt.Println(t2) //13點(呵呵)​​​​​​​

 

原帖地址:https://blog.csdn.net/zhonglinzhang/article/details/45913147?utm_source=blogxgwz3