fmt.Println(time.Now().Unix())
# 1389058332

fmt.Println(time.Now().Format("2006-01-02 15:04:05")) // 這是個奇葩,必須是這個時間點, 據說是go誕生之日, 記憶方法:6-1-2-3-4-5
# 2014-01-07 09:42:20

str_time := time.Unix(1389058332, 0).Format("2006-01-02 15:04:05")
fmt.Println(str_time)
# 2014-01-07 09:32:12

the_time := time.Date(2014, 1, 7, 5, 50, 4, 0, time.Local)
unix_time := the_time.Unix()
fmt.Println(unix_time)
# 389045004

the_time, err := time.Parse("2006-01-02 15:04:05", "2014-01-08 09:04:41")
if err == nil {
unix_time := the_time.Unix()
fmt.Println(unix_time) 
}
# 1389171881

<-time.Tick(time.Second)
<-time.After(time.Second)
<-time.NewTicker(time.Second).C
<-time.NewTimer(time.Second).C
time.AfterFunc(time.Second, func() { /*do*/ })
time.Sleep(time.Second)

func NewTicker(d Duration) *Ticker {
 if d <= 0 {
 panic(errors.New("non-positive interval for NewTicker"))
 }
 c := make(chan Time, 1)
 t := &Ticker{
 C: c,
 r: runtimeTimer{
 // when(d)返回一個runtimeNano() + int64(d)的未來時(到期時間)
 //runtimeNano運行時當前納秒時間
 when: when(d),
 period: int64(d), // 被喚醒的時間
 f:  sendTime, // 時間到期后的回調函數
 arg: c,  // 時間到期后的斷言參數
 },
 }
 // 將新的定時任務添加到時間堆中
 // 編譯器會將這個函數翻譯為runtime.startTimer(t *runtime.timer)
 // time.runtimeTimer翻譯為runtime.timer
 startTimer(&t.r)
 return t

func startTimer(t *timer) {
 if raceenabled {
 racerelease(unsafe.Pointer(t))
 }
 addtimer(t)
}

func addtimer(t *timer) {
 lock(&timers.lock)
 addtimerLocked(t)
 unlock(&timers.lock)
}

// 使用鎖將計時器添加到堆中
// 如果是第一次運行此方法則啟動timerproc
func addtimerLocked(t *timer) {
 if t.when < 0 {
 t.when = 1<<63 - 1
 }
 // t.i i是定時任務數組中的索引
 // 將新的定時任務追加到定時任務數組隊尾
 t.i = len(timers.t)
 timers.t = append(timers.t, t)
 // 使用數組實現的四叉樹最小堆根據when(到期時間)進行排序
 siftupTimer(t.i)
 // 如果t.i 索引為0
 if t.i == 0 {
 if timers.sleeping {
 // 如果還在sleep就喚醒
 timers.sleeping = false
 // 這里基于OS的同步，并進行OS系統(tǒng)調用
 // 在timerproc()使goroutine從睡眠狀態(tài)恢復
 notewakeup(&timers.waitnote)
 }
 if timers.rescheduling {
 timers.rescheduling = false
 // 如果沒有定時器，timerproc()與goparkunlock共同sleep
 // goready這里特殊說明下，在線程創(chuàng)建的堆棧，它比goroutine堆棧大。
 // 函數不能增長堆棧，同時不能被調度器搶占
 goready(timers.gp, 0)
 }
 }
 if !timers.created {
 timers.created = true
 go timerproc() //這里只有初始化一次
 }
}

// Timerproc運行時間驅動的事件。
// 它sleep到計時器堆中的下一個。
// 如果addtimer插入一個新的事件，它會提前喚醒timerproc。
func timerproc() {
 timers.gp = getg()
 for {
 lock(&timers.lock)
 timers.sleeping = false
 now := nanotime()
 delta := int64(-1)
 for {
 if len(timers.t) == 0 {
 delta = -1
 break
 }
 t := timers.t[0]
 delta = t.when - now
 if delta > 0 {
 break // 時間未到
 }
 if t.period > 0 {
 // 計算下一次時間
        // period被喚醒的間隔
 t.when += t.period * (1 + -delta/t.period)
 siftdownTimer(0)
 } else {
 // remove from heap
 last := len(timers.t) - 1
 if last > 0 {
  timers.t[0] = timers.t[last]
  timers.t[0].i = 0
 }
 timers.t[last] = nil
 timers.t = timers.t[:last]
 if last > 0 {
  siftdownTimer(0)
 }
 t.i = -1 // 標記移除
 }
 f := t.f
 arg := t.arg
 seq := t.seq
 unlock(&timers.lock)
 if raceenabled {
 raceacquire(unsafe.Pointer(t))
 }
 f(arg, seq)
 lock(&timers.lock)
 }
 if delta < 0 || faketime > 0 {
 // 沒有定時器，把goroutine sleep。
 timers.rescheduling = true
 // 將當前的goroutine放入等待狀態(tài)并解鎖鎖。
 // goroutine也可以通過呼叫goready(gp)來重新運行。
 goparkunlock(&timers.lock, "timer goroutine (idle)", traceEvGoBlock, 1)
 continue
 }
 // At least one timer pending. Sleep until then.
 timers.sleeping = true
 timers.sleepUntil = now + delta
 // 重置
 noteclear(&timers.waitnote)
 unlock(&timers.lock)
 // 使goroutine進入睡眠狀態(tài)，直到notewakeup被調用，
 // 通過notewakeup 喚醒
 notetsleepg(&timers.waitnote, delta)
 }
}