Wall Clock与Monotonic Clock（以Go time为例）

package main

import (
 "fmt"
 "time"
)

func main() {

 start := time.Now()

 fmt.Println("当前墙上时间为：", start.String())

}

package main

import (
 "fmt"
 "time"
)

func main() {

 start := time.Now()

 fmt.Println("start：", start.Unix())
 fmt.Println("当前墙上时间为：", start.String())

 time.Sleep(10e9)

 fmt.Println("在此期间修改系统时间")

 end := time.Now()

 fmt.Println("end：", end.Unix())
 fmt.Println("修改系统时间后的墙上时间为：", end.String())

 elapsed := end.Sub(start)

 fmt.Println(elapsed)

}

type Time struct {
 // wall and ext encode the wall time seconds, wall time nanoseconds,
 // and optional monotonic clock reading in nanoseconds.
 //
 // From high to low bit position, wall encodes a 1-bit flag (hasMonotonic),
 // a 33-bit seconds field, and a 30-bit wall time nanoseconds field.
 // The nanoseconds field is in the range [0, 999999999].
 // If the hasMonotonic bit is 0, then the 33-bit field must be zero
 // and the full signed 64-bit wall seconds since Jan 1 year 1 is stored in ext.
 // If the hasMonotonic bit is 1, then the 33-bit field holds a 33-bit
 // unsigned wall seconds since Jan 1 year 1885, and ext holds a
 // signed 64-bit monotonic clock reading, nanoseconds since process start.

    //  wall 和 ext 对 wall time seconds、wall time nanoseconds 和可选的以 nanoseconds 为单位的单调时钟读数进行编码。 从高位到低位位置，wall 编码一个 1 位标志（hasMonotonic）、一个 33 位秒字段和一个 30 位壁时间纳秒字段。纳秒字段在 [0, 999999999] 范围内。
    // 如果 hasMonotonic 位为 0，则 33 位字段必须为零，并且自第 1 年 1 月 1 日以来的完整有符号 64 位墙秒存储在 ext。 如果 hasMonotonic 位为 1，则 33 位字段保存自 1885 年 1 月 1 日以来的 33 位无符号壁秒，而 ext 保存自进程开始以来的有符号 64 位单调时钟读数，纳秒。

 wall uint64
 ext  int64

 // loc specifies the Location that should be used to
 // determine the minute, hour, month, day, and year
 // that correspond to this Time.
 // The nil location means UTC.
 // All UTC times are represented with loc==nil, never loc==&utcLoc.
 loc *Location // 时区,在此先不讨论
}

// Monotonic times are reported as offsets from startNano.
// We initialize startNano to runtimeNano() - 1 so that on systems where
// monotonic time resolution is fairly low (e.g. Windows 2008
// which appears to have a default resolution of 15ms),
// we avoid ever reporting a monotonic time of 0.
// (Callers may want to use 0 as "time not set".)

// 单调时间报告为与 startNano 的偏移量。我们将 startNano 初始化为 runtimeNano() - 1，以便在单调时间分辨率相当低的系统上（例如，Windows 2008 的默认分辨率似乎为 15 毫秒），我们避免报告单调时间 时间为 0。（调用者可能希望使用 0 作为“未设置时间”。）
var startNano int64 = runtimeNano() - 1

// Now returns the current local time.
func Now() Time {
 sec, nsec, mono := now()
 mono -= startNano
 sec += unixToInternal - minWall
 if uint64(sec)>>33 != 0 {
  return Time{uint64(nsec), sec + minWall, Local}
 }
 return Time{hasMonotonic | uint64(sec)<<nsecShift | uint64(nsec), mono, Local}
}

// Provided by package runtime.
func now() (sec int64, nsec int32, mono int64)

package runtime

import _ "unsafe" // for go:linkname

//go:linkname time_now time.now
func time_now() (sec int64, nsec int32, mono int64) {
 sec, nsec = walltime()
 return sec, nsec, nanotime()
}

//go:nosplit
func nanotime() int64 {
 return nanotime1()
}

func walltime() (sec int64, nsec int32) {
 return walltime1()
}

//go:nosplit
//go:cgo_unsafe_args
func nanotime1() int64 {
 var r struct {
  t            int64  // raw timer
  numer, denom uint32 // conversion factors. nanoseconds = t * numer / denom.
 }
 libcCall(unsafe.Pointer(funcPC(nanotime_trampoline)), unsafe.Pointer(&r))
 // Note: Apple seems unconcerned about overflow here. See
 // https://developer.apple.com/library/content/qa/qa1398/_index.html
 // Note also, numer == denom == 1 is common.
 t := r.t
 if r.numer != 1 {
  t *= int64(r.numer)
 }
 if r.denom != 1 {
  t /= int64(r.denom)
 }
 return t
}
func nanotime_trampoline()

//go:nosplit
//go:cgo_unsafe_args
func walltime1() (int64, int32) {
 var t timespec
 libcCall(unsafe.Pointer(funcPC(walltime_trampoline)), unsafe.Pointer(&t))
 return t.tv_sec, int32(t.tv_nsec)
}
func walltime_trampoline()

// func walltime1() (sec int64, nsec int32)
// non-zero frame-size means bp is saved and restored
TEXT runtime·walltime1(SB),NOSPLIT,$16-12
 // We don't know how much stack space the VDSO code will need,
 // so switch to g0.
 // In particular, a kernel configured with CONFIG_OPTIMIZE_INLINING=n
 // and hardening can use a full page of stack space in gettime_sym
 // due to stack probes inserted to avoid stack/heap collisions.
 // See issue #20427.

 MOVQ SP, R12 // Save old SP; R12 unchanged by C code.

 get_tls(CX)
 MOVQ g(CX), AX
 MOVQ g_m(AX), BX // BX unchanged by C code.

 // Set vdsoPC and vdsoSP for SIGPROF traceback.
 // Save the old values on stack and restore them on exit,
 // so this function is reentrant.
 MOVQ m_vdsoPC(BX), CX
 MOVQ m_vdsoSP(BX), DX
 MOVQ CX, 0(SP)
 MOVQ DX, 8(SP)

 LEAQ sec+0(FP), DX
 MOVQ -8(DX), CX
 MOVQ CX, m_vdsoPC(BX)
 MOVQ DX, m_vdsoSP(BX)

 CMPQ AX, m_curg(BX) // Only switch if on curg.
 JNE noswitch

 MOVQ m_g0(BX), DX
 MOVQ (g_sched+gobuf_sp)(DX), SP // Set SP to g0 stack

noswitch:
 SUBQ $16, SP  // Space for results
 ANDQ $~15, SP // Align for C code

 MOVL $0, DI // CLOCK_REALTIME
 LEAQ 0(SP), SI
 MOVQ runtime·vdsoClockgettimeSym(SB), AX
 CMPQ AX, $0
 JEQ fallback
 CALL AX
ret:
 MOVQ 0(SP), AX // sec
 MOVQ 8(SP), DX // nsec
 MOVQ R12, SP  // Restore real SP
 // Restore vdsoPC, vdsoSP
 // We don't worry about being signaled between the two stores.
 // If we are not in a signal handler, we'll restore vdsoSP to 0,
 // and no one will care about vdsoPC. If we are in a signal handler,
 // we cannot receive another signal.
 MOVQ 8(SP), CX
 MOVQ CX, m_vdsoSP(BX)
 MOVQ 0(SP), CX
 MOVQ CX, m_vdsoPC(BX)
 MOVQ AX, sec+0(FP)
 MOVL DX, nsec+8(FP)
 RET
fallback:
 MOVQ $SYS_clock_gettime, AX
 SYSCALL
 JMP ret

// func nanotime1() int64
TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 // Switch to g0 stack. See comment above in runtime·walltime.

 MOVQ SP, R12 // Save old SP; R12 unchanged by C code.

 get_tls(CX)
 MOVQ g(CX), AX
 MOVQ g_m(AX), BX // BX unchanged by C code.

 // Set vdsoPC and vdsoSP for SIGPROF traceback.
 // Save the old values on stack and restore them on exit,
 // so this function is reentrant.
 MOVQ m_vdsoPC(BX), CX
 MOVQ m_vdsoSP(BX), DX
 MOVQ CX, 0(SP)
 MOVQ DX, 8(SP)

 LEAQ ret+0(FP), DX
 MOVQ -8(DX), CX
 MOVQ CX, m_vdsoPC(BX)
 MOVQ DX, m_vdsoSP(BX)

 CMPQ AX, m_curg(BX) // Only switch if on curg.
 JNE noswitch

 MOVQ m_g0(BX), DX
 MOVQ (g_sched+gobuf_sp)(DX), SP // Set SP to g0 stack

noswitch:
 SUBQ $16, SP  // Space for results
 ANDQ $~15, SP // Align for C code

 MOVL $1, DI // CLOCK_MONOTONIC
 LEAQ 0(SP), SI
 MOVQ runtime·vdsoClockgettimeSym(SB), AX
 CMPQ AX, $0
 JEQ fallback
 CALL AX
ret:
 MOVQ 0(SP), AX // sec
 MOVQ 8(SP), DX // nsec
 MOVQ R12, SP  // Restore real SP
 // Restore vdsoPC, vdsoSP
 // We don't worry about being signaled between the two stores.
 // If we are not in a signal handler, we'll restore vdsoSP to 0,
 // and no one will care about vdsoPC. If we are in a signal handler,
 // we cannot receive another signal.
 MOVQ 8(SP), CX
 MOVQ CX, m_vdsoSP(BX)
 MOVQ 0(SP), CX
 MOVQ CX, m_vdsoPC(BX)
 // sec is in AX, nsec in DX
 // return nsec in AX
 IMULQ $1000000000, AX
 ADDQ DX, AX
 MOVQ AX, ret+0(FP)
 RET
fallback:
 MOVQ $SYS_clock_gettime, AX
 SYSCALL
 JMP ret

var vdsoLinuxVersion = vdsoVersionKey{"LINUX_2.6", 0x3ae75f6}

var vdsoSymbolKeys = []vdsoSymbolKey{
 {"__vdso_gettimeofday", 0x315ca59, 0xb01bca00, &vdsoGettimeofdaySym},
 {"__vdso_clock_gettime", 0xd35ec75, 0x6e43a318, &vdsoClockgettimeSym},
}

var (
 vdsoGettimeofdaySym uintptr
 vdsoClockgettimeSym uintptr
)

package main

import (
 "fmt"
 "time"
)

func main() {

 t0 := time.Unix(0, 0)

 fmt.Println(t0)

 t1 := time.Date(2022, 07, 17, 19, 11, 23, 45, time.Local)
 fmt.Println(t1)

 st, err := time.Parse("2006-01-02 15:04:05", "2008-08-08 20:08:00")
 if err != nil {
  panic(err)
 }
 fmt.Println(st)
}

1970-01-01 08:00:00 +0800 CST
2022-07-17 19:11:23.000000045 +0800 CST
2008-08-08 20:08:00 +0000 UTC

// Unix returns the local Time corresponding to the given Unix time,
// sec seconds and nsec nanoseconds since January 1, 1970 UTC.
// It is valid to pass nsec outside the range [0, 999999999].
// Not all sec values have a corresponding time value. One such
// value is 1<<63-1 (the largest int64 value).

//  Unix 返回与给定 Unix 时间相对应的本地时间，自 1970 年 1 月 1 日 UTC 以来的秒秒和纳秒纳秒。
//  在 [0, 999999999] 范围之外传递 nsec 是有效的。
//  并非所有秒值都有对应的时间值。 一个这样的值是 1<<63-1（最大的 int64 值）。
func Unix(sec int64, nsec int64) Time {
 if nsec < 0 || nsec >= 1e9 {
  n := nsec / 1e9
  sec += n
  nsec -= n * 1e9
  if nsec < 0 {
   nsec += 1e9
   sec--
  }
 }
 return unixTime(sec, int32(nsec))
}


func unixTime(sec int64, nsec int32) Time {
 return Time{uint64(nsec), sec + unixToInternal, Local}
}


var unixToInternal int64 = (1969*365 + 1969/4 - 1969/100 + 1969/400) * secondsPerDay 

// 即公元1年1月1日的秒数；可参考https://www.zhihu.com/question/320347209； 
// 关于计算两个日期之间的天数，可参考如何计算两个日期之间的天数: https://dashen.tech/2022/03/17/%E5%A6%82%E4%BD%95%E8%AE%A1%E7%AE%97%E4%B8%A4%E4%B8%AA%E6%97%A5%E6%9C%9F%E4%B9%8B%E9%97%B4%E7%9A%84%E5%A4%A9%E6%95%B0/

package main

import (
 "fmt"
 "time"
)

func main() {

 start := time.Unix(time.Now().Unix(), 0)

 fmt.Println("start：", start.Unix())
 fmt.Println("当前墙上时间为：", start.String())

 time.Sleep(10e9)

 fmt.Println("在此期间修改系统时间")

 end := time.Unix(time.Now().Unix(), 0)

 fmt.Println("end：", end.Unix())
 fmt.Println("修改系统时间后的墙上时间为：", end.String())

 elapsed := end.Sub(start)

 fmt.Println(elapsed)

}

const hasMonotonic = 1 << 63

const (
 minDuration Duration = -1 << 63
 maxDuration Duration = 1<<63 - 1
)


// Sub returns the duration t-u. If the result exceeds the maximum (or minimum)
// value that can be stored in a Duration, the maximum (or minimum) duration
// will be returned.
// To compute t-d for a duration d, use t.Add(-d).
func (t Time) Sub(u Time) Duration {
 if t.wall&u.wall&hasMonotonic != 0 {
  te := t.ext
  ue := u.ext
  d := Duration(te - ue)
  if d < 0 && te > ue {
   return maxDuration // t - u is positive out of range
  }
  if d > 0 && te < ue {
   return minDuration // t - u is negative out of range
  }
  return d
 }
 d := Duration(t.sec()-u.sec())*Second + Duration(t.nsec()-u.nsec())
 // Check for overflow or underflow.
 switch {
 case u.Add(d).Equal(t):
  return d // d is correct
 case t.Before(u):
  return minDuration // t - u is negative out of range
 default:
  return maxDuration // t - u is positive out of range
 }
}

package main

import (
 "fmt"
 "time"
)

func main() {

 t1 := time.Now()
 t2 := time.Now()
 a := t1 == t2
 fmt.Println(a)

}

use std::time::{Duration, Instant};
use std::thread::sleep;

fn main() {
   let now = Instant::now();
   sleep(Duration::new(2, 0));
   println!("{}", now.elapsed().as_secs());
}