In the output of the code above, the m= value — which represents the monotonic clock — is shown only on the first line; it won't be present for the other values.

When the monotonic clock reading isn't present in a given value, Go falls back to the wall clock to calculate the time difference. In that case, if the operating system's clock changes, that change will affect the calculated value.

For example, if we move the operating system's clock two hours forward or back, the calculated time difference will be two hours more or less.

Comparing Times

There are two ways to compare times for equality in Go:

• Using ==, if the monotonic clock matters
• Using Equal, if only the wall clock matters.

In Go, two times (time.Time) are equal to each other if the following conditions hold:

• Both have the same time zone.
• Both represent the same time.

• If at least one of them has a monotonic clock reading, their monotonic clock readings must also be equal. (If neither has a monotonic clock reading, the monotonic clock comparison is skipped.)

In Go, for comparing whether a time is greater or less than another — similar to the equality comparison (==) — you can use one of the following approaches:

• If you want the monotonic clock to also be taken into account, we use >= and <=.
• If we want only the wall clock to be taken into account, we can use the Before and After methods.

Time Durations

In Go, the time.Duration type is used to represent time spans, and the result of calculating the difference between two times will be a time.Duration.

To calculate the time difference between two time.Time variables, you can use the Sub method:

If we want to calculate the time elapsed between now and a time in the past, we can use the Since method as follows:

Scheduled Execution of Commands

The time package has several different ways to do scheduled execution. Each one is designed for a specific scenario.

Delaying Code Execution with time.Sleep

The simplest way to delay code execution is to use time.Sleep.

Sending a Signal on a Channel After a Set Time with time.After

One way to send a scheduled signal on channels is to use the time.After function. This function returns a channel onto which a value is written once the specified duration (time.Duration) has elapsed.

Controlled Signal Delivery Using a Timer

A timer can be used for controlled signal delivery. A timer lets us change how much time has passed or remains before the signal is sent, or even prevent the signal from being sent at all. You can create a timer using the time.NewTimer function.

You can stop a timer using the Stop method, and reset its value using the Reset method. In the example above, we first set the timer to 1 second, and then, after 200 milliseconds, reset it to 2 seconds.

Running a Function After a Set Time with time.AfterFunc

You can use time.AfterFunc to run a function after a specified duration.

Sending a Recurring Signal with time.Tick

Using time.Tick, we can periodically send a value on a channel at a fixed interval.

Note: Tick cannot be stopped, and it's suited to cases where you need to do something repeatedly for the entire lifetime of the program.

In the example above, we used break to exit the loop, but the Ticker held in the tick variable will keep putting values on its internal channel and won't stop!

Using time.NewTicker to Create a Controllable Recurring Schedule

You can create a controllable Ticker using the time.NewTicker function. A Ticker is simply a struct with a C field of channel type, plus Stop and Reset methods.

The Stop method stops the Ticker, and the Reset method can be used to change the Ticker's schedule.

Previous part: Unit Testing | Golang basics

Next part: The sync Standard Package | Golang basics