How to Multiply time.Duration by an Integer in Go

By the end of this page, you will understand what time.Duration is in Go, why it cannot be multiplied directly by values of a different numeric type, and how to convert integers safely so they work with functions like time.Sleep. You will also see practical examples using random delays, learn common mistakes, and understand how this pattern appears in real Go code.

time.Duration in Go is a named type that represents a length of time as a number of nanoseconds.

For example:

var d time.Duration = time.Second

Even though time.Duration is based on an integer type internally, Go treats it as its own type. Go is strict about type safety, so values of different types usually cannot be mixed in arithmetic unless you convert them explicitly.

That is why this fails:

rand.Int31n(1000) * time.Millisecond

• rand.Int31n(1000) returns an int32
• time.Millisecond is a time.Duration
• Go does not automatically convert int32 to time.Duration

The fix is to convert the random number to time.Duration first:

time.Sleep(time.Duration(rand.Int31n(1000)) * time.Millisecond)

Now both sides of the multiplication are compatible:

• time.Duration(rand.Int31n(1000)) is a

Think of time.Duration as a measuring unit like centimeters.

If someone gives you the number 5, that is just a plain number. But if you want to say 5 centimeters, you must attach the unit.

In Go:

• rand.Int31n(1000) is just a number of type int32
• time.Millisecond is a time unit

Go does not guess that your plain number should become a duration. You must say it explicitly:

time.Duration(rand.Int31n(1000))

Now Go understands: “This number represents a duration count,” so multiplying by time.Millisecond makes sense.

So the mental model is:

• plain integers are just counts
• time.Duration is a count with time meaning
• convert the count before combining it with time units

The basic pattern is:

time.Duration(number) * time.Unit

Correct syntax

time.Sleep(time.Duration(rand.Int31n(1000)) * time.Millisecond)

This means:

• generate a random number from 0 to 999
• convert it to time.Duration
• multiply it by time.Millisecond
• sleep for that amount of time

Example: fixed duration multiplication

package main

import (
	"fmt"
	"time"
)

func main() {
	wait := time.Duration(3) * time.Second
	fmt.Println(wait)
}

Output:

3s

Example: random delay

package main

import (
	"math/rand"
	
)

 {
	rand.Seed(time.Now().UnixNano())

	delay := time.Duration(rand.Int31n()) * time.Millisecond
	time.Sleep(delay)
}

Consider this code:

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	rand.Seed(time.Now().UnixNano())

	n := rand.Int31n(5)
	delay := time.Duration(n) * time.Millisecond

	fmt.Println("random number:", n)
	fmt.Println("delay:", delay)

	time.Sleep(delay)
	fmt.Println("done")
}

Step by step:

1. rand.Seed(time.Now().UnixNano())

   • Initializes the random generator with a changing seed.
   • Without this, the program may produce the same sequence each run.

2. n := rand.Int31n(5)

   • Picks a random int32 from 0 to 4.
   • Example value: 3

3. delay := time.Duration(n) * time.Millisecond

   • Converts 3 from to

Working with multiplied durations is common in Go applications.

Random delays for testing

You used this pattern for goroutine testing. That is a valid use case when you want to simulate:

• network latency
• slow database queries
• non-deterministic task completion

Example:

time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)

Retry with backoff

Programs often wait longer after each failed attempt:

wait := time.Duration(attempt) * time.Second

Polling loops

An app may check a resource every few seconds:

interval := time.Duration(10) * time.Second

Rate limiting

A worker may pause between operations:

time.Sleep(200 * time.Millisecond)

Timeout configuration

Sometimes you compute durations from numeric config values:

secondsFromConfig := 15
%timeout := time.Duration(secondsFromConfig) * time.Second

This pattern is especially useful when values come from:

In real Go codebases, developers usually compute durations in a small, readable variable first instead of putting everything directly inside time.Sleep.

Common pattern: assign first, use later

delay := time.Duration(rand.Intn(1000)) * time.Millisecond
time.Sleep(delay)

This is easier to debug and log.

Validation pattern

When durations come from config, developers often validate them:

seconds := 5
if seconds < 0 {
	seconds = 0
}
timeout := time.Duration(seconds) * time.Second

Backoff and retry logic

for attempt := 1; attempt <= 3; attempt++ {
	err := tryRequest()
	if err == nil {
		return
	}

	wait := time.Duration(attempt) * time.Second
	time.Sleep(wait)
}

Jitter to avoid synchronized retries

In distributed systems, developers add randomness so many processes do not retry at exactly the same moment:

base := 2 * time.Second
jitter := time.Duration(rand.Intn(500)) * time.Millisecond
time.Sleep(base + jitter)

Guarding against bad units

1. Mixing numeric types without conversion

Broken code:

time.Sleep(rand.Int31n(1000) * time.Millisecond)

Why it fails:

• rand.Int31n(1000) is int32
• time.Millisecond is time.Duration

Fix:

time.Sleep(time.Duration(rand.Int31n(1000)) * time.Millisecond)

2. Forgetting the time unit

Broken code:

time.Sleep(time.Duration(1000))

This sleeps for 1000 nanoseconds, not 1000 milliseconds.

Fix:

time.Sleep(time.Duration(1000) * time.Millisecond)

3. Assuming Go does automatic conversion

Broken idea:

var n int = 5
var d time.Duration = n * time.Second

time.Duration vs plain integers

Core rule

When combining numbers with time.Duration, convert the number first.

time.Duration(n) * time.Millisecond

Common examples

wait := time.Duration(5) * time.Second
sleep := time.Duration(rand.Intn(1000)) * time.Millisecond
timeout := time.Duration(configSeconds) * time.Second

Why your original code failed

rand.Int31n(1000) * time.Millisecond

• left side: int32
• right side: time.Duration
• Go does not mix them automatically

Correct version

time.Sleep(time.Duration(rand.Int31n(1000)) * time.Millisecond)

Remember the unit

time.Duration(1000)              // 1000 nanoseconds
time.Duration(1000) * time.Millisecond // 1000 milliseconds

Useful units

Why do I need to convert to time.Duration in Go?

Because Go does not automatically mix different numeric types in arithmetic. time.Duration is a distinct type.

What type is time.Millisecond?

It is a constant of type time.Duration.

Does rand.Intn() also need conversion?

Yes. Even though it returns int, you still need time.Duration(rand.Intn(...)) before multiplying by a duration unit.

What happens if I write time.Duration(1000)?

That means 1000 nanoseconds, because time.Duration stores nanoseconds unless you multiply by a unit like time.Millisecond.

Is 500 * time.Millisecond valid without conversion?

Yes. Untyped numeric constants like 500 can work directly with time.Duration constants.

Should I use rand.Int31n or rand.Intn?

• time.Duration — The core Go type for representing time intervals.
• time.Sleep — A common function that accepts a duration.
• Type conversion in Go — Needed because Go does not do many implicit conversions.
• Numeric types in Go — Helps explain differences between int, int32, and named types.
• Constants in Go — Useful for understanding why 500 * time.Millisecond works.
• Random numbers in Go — Relevant when creating random delays with rand.Intn or rand.Int31n.
• Goroutines — The original use case involves testing concurrent behavior.
• Timeouts and backoff — Common real applications of multiplied durations.