Go time

• 时间包括时间值和时区，没有包含时区信息的时间是不完整的、有歧义的。

Golang内置的time包提供了时间的显示和测量的函数

功能	描述
time.Time	时间点
time.Duration	时间段
time.Location	时区
time.Timer	定时器
time.Ticker	周期触发定时的计时器
time.C	存放时间点的管道

时间点

time.Time

• 所有与时间相关的业务都是基于时间点而仰伸的，两个时间点组成一个时间段。

Golang内置的time时间包提供了一个数据类型time.Time作为值使用，以及显示、测量时间和日期的功能函数。

time.Time代表一个纳秒精度的时间点，其结构体包含三个字段：

type Time struct {
  wall uint64
  ext int64
  loc *Location
}

字段	类型	描述
wall	uint64	墙上时钟
ext	int64	时间模式
loc	*time.Location	时区，处理偏移量。

墙上时钟wall

如何正确的表示时间呢？最准确的时间计算是使用“原子振荡周期”所计算的物理时钟（Atomic Clock，原子钟），又被定义为标准时间（International Atomic Time）。

操作系统中存在两个不同的时钟，分别是墙上时钟（wall time/real time）和单调时钟（monotonic time），单调时钟是本机硬件的节拍数，不同机器没有可比性。由于石英钟本身的误差，时间会有闰秒等原因，因此单调时钟与墙上时钟是不一致的。

墙上时钟又称为时钟时间，是进程运行的时钟总量，其值与系统中同时运行的进程数量有关。进程从开始运行到结束，时钟走过的时间，包括进程在阻塞和等待状态的时间。

墙上时钟	大小
flag	1位
时间戳	33位
纳秒	30位

时间模式ext

分为：是否包含单调时钟、外部输入的时间

若时间模式ext包含单调时钟，则wall字段中会存在一个时间戳秒代表墙上时钟和一个时间戳纳秒代表墙上时钟。若时间模式ext不包含单调时钟，则wall字段中会包含一个时间戳纳秒代表墙上时钟，ext字段则包含一个时间戳秒代表墙上时钟。

time.Now

• time.Now()会返回当前本地时间对象

func time.Now() time.Time 

例如：

t := time.Now()
fmt.Println(t)

2021-04-18 17:05:22.9533522 +0800 CST m=+0.003019301

从时间对象中获取时间分量信息

时间分量	描述
t.Year()	年
t.Month()	月
t.Day()	日
t.Hour()	小时数
t.Minute()	分钟
t.Second()	秒数
t.Nanosecond()	纳秒

year := t.Year()
month := t.Month()
day := t.Day()
hour := t.Hour()
minute := t.Minute()
second := t.Second()
ns := t.Nanosecond()

fmt.Printf("year = %d, month = %d, day = %d, hour = %d, minute = %d, second = %d, ns = %d\n", year, month, day, hour, minute, second, ns)

year = 2021, month = 4, day = 18, hour = 17, minute = 26, second = 17, ns = 466388000

time.Parse

func time.Parse(layout, value string) (time.Time, error)

将字符串类型的日期时间转换为UTC标准的Time类型

timestr := "2021-01-04 12:00:00"

utctime, err := time.Parse("2006-01-02 15:04:05", timestr)

时间戳

Unix

• Unix时间又称为POSIX时间，是UNIX或类UNIX操作系统使用的时间表示方式。
• Unix时间表示从UTC的1970年1月1日0时0分0秒开始到现在的总秒数，不考虑闰秒。
• Unix时间表示从1970年1月1日 08:00:00GMT开始至今的总毫秒数或秒数，又称为UNIX时间戳（UNIX Timestamp）。

func (t Time) Unix() int64
func (t Time) UnixNano() int64

时间戳	单位	长度
t.Unix()	秒	10位
t.UnixNano()	纳秒	19位

s := t.Unix()
ns := t.UnixNano()
ms := t.UnixNano() / 1e6
fmt.Printf("timestamp = %d, unixnano = %d, ms = %d\n", s, ns, ms)

timestamp = 1618738171, unixnano = 1618738171513428200, ms = 1618738171513

19位纳秒转13位毫秒

ms := t.UnixNano() / 1e6
fmt.Println(ms) // 1618737494948

time.Unix

• time.Unix()函数可将时间戳转换为时间点对象

func time.Unix(sec int64, nsec int64) time.Time

格式化

Format

获取时间并格式化

func (t Time) Format(layout string) string

• 2006-01-02 15:04:05表示GoLang诞生时间，此处为固定写法。

例如：将时间点对象转换为指定格式的字符串

t := time.Now()
fmt.Println(t)//2021-04-18 17:53:23.8149167 +0800 CST m=+0.002995001

str := t.Format("2006-01-02 15:04:05")
fmt.Println(str)//2021-04-18 17:53:23

例如：将时间戳转换为指定格式的字符串

ts := time.Now().Unix()
fmt.Println(ts)//1618739719

str := time.Unix(ts,0).Format("2006-01-02 15:04:05")
fmt.Println(str)//2021-04-18 17:55:19

标准

UTC

• UTC（Coordinated Universal Time，协调世界时）是最主要的世界时间标准，它以原子时秒长为基础，在时刻上尽量接近于格林尼治标准时间（Greenwich Mean Time，GMT）。
• UTC是世界上调节时钟和时间的主要时间标准，它与0度经线的平太阳时相差不超过1秒，且不遵守夏令时。
• UTC是最接近格林威治标准时间（GMT）的替代时间系统之一，对于大多数用途来说，UTC时间被认为与GMT时间互换，但GMT时间已不再被科学界所确定。

func (t Time) UTC() Time 

例如：将GMT格林威治时间转换为UTC时间

t := time.Now()
fmt.Println(t)//2021-04-18 17:57:51.7228428 +0800 CST m=+0.002020201

utc := t.UTC()
fmt.Println(utc)//2021-04-18 09:57:51.7228428 +0000 UTC

时区

时间其实包括时间值和时区，没有时区信息的时间是不完整的。使用没有时区的非标准时间表示格式是有隐患的，由于解析时会根据使用场景的默认设置，如系统时区、数据库默认时区等，可能会引发事故。因此需确保服务器系统、数据库、应用程序时间统一的时区。

time.Location

func (t Time) Location() *Location

• Location函数返回时间点对象的地点和时区信息

例如：获取时间点对应的时区

t := time.Now()
loc := t.Location()
fmt.Println(loc)//Local

func time.LoadLocation

• LoadLocation用于获取给定名字创建的时区

func time.LoadLocation(name string) (*time.Location, error)

例如：获取服务器所在时区

loc,err := time.LoadLocation("Asia/Shanghai")
if err!=nil {
    println(err)
}
println(loc)//0xc0000c2000

是否能够拿到时区取决于机器本地的zoneinfo文件，time.LoadLocation()函数将会返回一个*time.Location指针对象。

计时器

time.Ticker

time.Ticker是一个周期触发定时的计时器，一旦被定义每隔一段时间会自动触发。

type Ticker struct {
    C <-chan Time // 周期性传递时间信息的通道
    r runtimeTimer
}

time.Ticker会按照一个指定的时间间隔重复的向通道C发送系统当前时间值，通道的接收者可以按固定的时间间隔从通道中读取事件。

//实现原理
go func(t *time.Ticker){
    for{
        select{
        case <-t.C:
            fmt.Printf("ticker: run\n")
        }
    }
}(ticker)

在goroutine周期性执行一些事务时非常有用，比如状态状态日志、输出、计算等。

例如：

ticker := time.NewTicker(time.Second * 3)
defer ticker.Stop()

fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
time.Sleep(time.Second * 4)

for{
    select{
    case <-ticker.C:
        fmt.Println(time.Now())
    }
}

time.NewTicker

NewTicker方法用于返回一个新的Ticker，Ticker中包含一个通道字段C会每隔时间段d就向该通道发送当前的时间。

func time.NewTicker(d time.Duration) *time.Ticker

• 时间间隔d的单位为纳秒(ns, int64)，在工厂函数time.NewTicker中以time.Duration类型的参数传入。
• *Ticker指向定时器的指针

例如：定时执行，循环执行不退出。

//创建计时器，每隔1秒后定时器会向channel发送一个事件，包含当前时间。
ticker := time.NewTicker(time.Second * 1)

i:=0
for{
    //执行若干次后退出
    if i>5 {
        break
    }
    i++

    fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
    //从打点器中获取通道
    <-ticker.C
}

//清理计时器
ticker.Stop()

例如：

//创建计时器，每隔1秒后定时器会向channel发送一个事件，包含当前时间。
ticker := time.NewTicker(time.Second * 1)

i:=0
for{
    //执行若干次后退出
    if i>5 {
        //清理计时器
        ticker.Stop()
        //跳出循环
        break
    }
    //从打点器中获取通道
    select{
    case <-ticker.C:
        i++
        fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
    }
}

例如：

ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for{
    select{
    case t := <-ticker.C:
        fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
    }
}

time.Tick

time.Tick()返回的是一个通道，每隔指定时间就会有数据从通道中出来。

 func Tick(d Duration) <-chan Time {
    if d <= 0 {
        return nil
    }
    return NewTicker(d).C
}

实现固定时间重复执行，即定期循环。

for{
    time.Sleep(time.Second * 2)
    fmt.Println(time.Now())
}

更优雅的方案

• range是可以不接收遍历的值的，若不接收则可简写。

for range time.Tick(time.Second * 2){
    fmt.Println(time.Now())
}

ticker.Stop

func (t *Ticker) Stop() {
    stopTimer(&t.r)
}

• ticker.Stop()方法会关闭一个Ticker，关闭后将不会再发送更多的tick信息。
• ticker.Stop()方法不会关闭通道t.C，只能避免从通道的读取不正确的成功。

ticker.Reset

func (t *Ticker) Reset(d Duration) {
    if t.r.f == nil {
        panic("time: Reset called on uninitialized Ticker")
    }
    modTimer(&t.r, when(d), int64(d), t.r.f, t.r.arg, t.r.seq)
}

时间段

time.Duration

• time.Duration是time包定义的一个类型，表示一段时间间隔。
• Duration类型表示两个时间点之间经过的时间段，以纳秒为单位，可表示的最长时间段大约290年。
• Duration时间段实际上是int64类型，单位纳秒。

实际编程中不会直接赋值时间段为一个数字，而是会采用time包提供的常量。

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

时间运算

Add

• 获取时间点增加时间段后的时间点

func (t Time) Add(d Duration) Time

例如：计算1天后的时间点

t1 := time.Now()
fmt.Println(t1)//2021-04-18 18:27:30.482194 +0800 CST m=+0.002020201

t2 := t1.Add(time.Hour * 24)
fmt.Println(t2)//2021-04-19 18:27:30.482194 +0800 CST m=+86400.002020201

例如：计算1天前的时间点

t2 := t1.Add(-time.Hour * 24)
fmt.Println(t2)//2021-04-17 18:30:48.1375322 +0800 CST m=-86399.998035299

Sub

• 计算两个事件之间的差值

func (t Time) Sub(u Time) Duration

例如：

t1 := time.Now()
fmt.Println(t1)//2021-04-18 18:27:30.482194 +0800 CST m=+0.002020201

t2 := t1.Add(time.Hour * 24)
fmt.Println(t2)//2021-04-17 18:30:48.1375322 +0800 CST m=-86399.998035299

d := t2.Sub(t1)
fmt.Println(d)//24h0m0s

时间比较

Equal

func (t Time) Equal(u Time) bool

• 判断两个时间点t和u是否相同，会考虑时区的影响。

例如：

t1 := time.Now()
fmt.Println(t1)//2021-04-18 18:27:30.482194 +0800 CST m=+0.002020201

t2 := t1.Add(time.Hour * 24)
fmt.Println(t2)//2021-04-17 18:30:48.1375322 +0800 CST m=-86399.998035299

flag := t2.Equal(t1)
fmt.Println(flag)//false

Before

func (t Time) Before(u Time) bool

• 判断时间点t是否在指定时间点u之前

After

func (t Time) After(u Time) bool

• 判断某时间点t是否在指定时间点u之后

---