Why does Go‘s time.Now().UnixNano() return a smaller result?

I use time.Now().UnixNano() to calculate the time of rpc, but I find that the second call to time.Now().UnixNano() returns a smaller timestamp than the first call.
This code belongs to the rpc client. I execute it concurrently tens of thousands of times and it sometimes comes up once.

start := time.Now().UnixNano()
v := ck.Get(key)
end := time.Now().UnixNano()
if start > end {
   fmt.Printf("TimeReverseErr found: callTime %v > returnTime %v\n", start, end)
}

Here are outputs:

... found: callTime 1667161706348148000 > returnTime 1667161706304057000
... found: callTime 1667161706365079000 > returnTime 1667161706319597000

OS: macOS Monterey 12.6<br>
Go: go1.18 darwin/amd64

The complete code:

// in RPC Client
func Get(cfg *config, ck *Clerk, key string, log *OpLog, cli int) string {
   start := time.Now().UnixNano()
   v := ck.Get(key)
   end := time.Now().UnixNano()
   if start > end {
      fmt.Printf("TimeReverseErr found: callTime %v > returnTime %v", start, end)
   }
   cfg.op()
   if log != nil {
      log.Append(porcupine.Operation{
         Input:    models.KvInput{Op: 0, Key: key},
         Output:   models.KvOutput{Value: v},
         Call:     start,
         Return:   end,
         ClientId: cli,
      })
   }

   return v
}

I have tried many times and this problem persists.

time.Now().UnixNano() is a wall clock reading, it is not a monotonic clock reading.

> time: Monotonic Clocks
>
> Operating systems provide both a “wall clock,” which is subject to changes for clock synchronization, and a “monotonic clock,” which is not. The general rule is that the wall clock is for telling time and the monotonic clock is for measuring time. Rather than split the API, in this package the Time returned by time.Now contains both a wall clock reading and a monotonic clock reading; later time-telling operations use the wall clock reading, but later time-measuring operations, specifically comparisons and subtractions, use the monotonic clock reading.
>
> For example, this code always computes a positive elapsed time of approximately 20 milliseconds, even if the wall clock is changed during the operation being timed:
>
> start := time.Now()
> ... operation that takes 20 milliseconds ...
> t := time.Now()
> elapsed := t.Sub(start)

Rephrase your code to use time.Now() as a monotonic clock. For example,

package main

import (
	"fmt"
	"time"
)

func Get(key string) string { return "value" }

func main() {
	key := "key"

	start := time.Now()
	v := Get(key)
	end := time.Now()
	since := end.Sub(start)

	fmt.Println(start)
	fmt.Println(end)
	fmt.Println(since)
	if since < 0 {
		fmt.Println("start > end")
	}

	_ = v
}

m=+0.000018015 is a monotonic clock value.

2022-10-31 00:38:30.415473095 -0400 EDT m=+0.000018015
2022-10-31 00:38:30.415473159 -0400 EDT m=+0.000018073
58ns