[go]time包

time常用api

// time包
now := time.Now() 
fmt.Printf("current time:%v
", now) //2019-12-04 21:37:22.138938 +0800 CST m=+0.000109570

//格式化时间
year := now.Year()
month := now.Month()
day := now.Day()
hour := now.Hour()
minute := now.Minute()
send := now.Second()
fmt.Printf("%02d-%02d-%02d %02d:%02d:%02d
", year, month, day ,hour, minute, send)

//格式化时间
now := time.Now()
timeStr := now.Format("2006/01/02 15:04:05")  //go诞⽣于2006-01-02 15:04:05
fmt.Printf("time:%s
", timeStr)

//格式化时间
now := time.Now()
timeStr := fmt.Sprintf("%02d/%02d/%02d %02d:%02d:%02d
", now.Year(), now.Month(), now.Day() ,now.Hour(), now.Minute(), now.Second())
fmt.Printf("time:%s
", timeStr)

//时间戳
timestamp := time.now().Unix() //unix时间戳,int64

timeObj := time.Unix(timestamp, 0)
year := timeObj.Year()
month := timeObj.Month()
day := timeObj.Day()
hour := timeObj.Hour()
minute := timeObj.Minute()
send := timeObj.Second()

fmt.Printf("current timestamp:%d
", timestamp)
fmt.Printf("%02d-%02d-%02d %02d:%02d:%02d
", year, month, day ,hour, minute, send)

//时间常量
fmt.Printf("nano second:%d
", time.Nanosecond)
fmt.Printf("micro second:%d
", time.Microsecond)
fmt.Printf("mili second:%d
", time.Millisecond)
fmt.Printf("second:%d
", time.Second)

//给出时间字符串 计算时间差
const TIME_LAYOUT = "2006/01/02 15:04:05" //时间格式模版，跟时间字符串格式一致
str := "2018/09/10 00:00:00"
t, _ := time.Parse(TIME_LAYOUT, str) //将时间转换为
fmt.Println(t)
fmt.Println(t.Sub(time.Now()).Milliseconds()) //-38929603501

//给出时间戳转换为时间

var ts int64= 1575467403
u := time.Unix(ts, 0)
fmt.Println(u)

//睡1s

time.Sleep(time.Second)
<-time.NewTimer(time.Second).C
<-time.After(time.Second)

// 定时+回调(setTimeout)

time.AfterFunc(time.Second, func() {
	println("after 1s cb")
})
time.Sleep(time.Second*3)

// 周期定时(setInterval)

ticker := time.Tick(1*time.Second)
for i := range ticker {
	fmt.Printf("%v
", i)
	processTask()
}

// 周期定时(setInterval)

for  {
	<-time.NewTicker(time.Second).C
	println(1)
}

timer.Stop()            //清除定时器
timer.Reset(time.Second)//重置定时器

//比较时间早晚(返回bool)

time.Now().Before(time.Now()) //true, 在这个时间之前吗
time.Now().After(time.Now())
time.Now().Equal(time.Now())

//计算耗时

t := time.Now()
latency := time.Since(t)

//获取随机数
rand.Seed(time.Now().UnixNano()) //确保执行多次生成的随机数不同
fmt.Println(rand.Intn(200))
fmt.Println(rand.Intn(200))

//随机睡眠多久
rand.Intn(200) //随机获取200内整数
time.Duration(rand.Intn(200)) //强制转换为Duration即类型, type Duration int64

time.Sleep(time.Duration(10 * time.Millisecond)
time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)

timer源码

// Timer源码
type Timer struct {
	C <-chan Time
	r runtimeTimer
}


func NewTimer(d Duration) *Timer {
	c := make(chan Time, 1)
	t := &Timer{
		C: c,
		r: runtimeTimer{
			when: when(d),
			f:    sendTime,
			arg:  c,
		},
	}
	startTimer(&t.r)
	return t
}

tickTimer

func main() {
	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()
	done := make(chan bool)
	go func() {
		time.Sleep(10 * time.Second)
		done <- true
	}()
	for {
		select {
		case <-done:
			fmt.Println("Done!")
			return
		case t := <-ticker.C:
			fmt.Println("Current time: ", t)
		}
	}
}

//源码
type Ticker struct {
	C <-chan Time // The channel on which the ticks are delivered.
	r runtimeTimer
}

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:   when(d),
			period: int64(d),
			f:      sendTime,
			arg:    c,
		},
	}
	startTimer(&t.r)
	return t
}