The best way to detect race conditions in Go is to use the built-in race detector with the -race flag. 1. Run go run -race main.go or go test -race ./... to enable the race detector, which identifies concurrent read-write access to shared variables and provides detailed reports including goroutine traces and access types. 2. Write tests that actively exercise concurrency by using multiple goroutines, loops, and sync.WaitGroup to coordinate execution and increase the likelihood of exposing races. 3. Avoid common race-prone patterns such as unsynchronized access to global variables, improper closure use in loops, and unprotected shared structs by using sync.Mutex, channels, or sync/atomic for safe concurrency. 4. Complement dynamic detection with static analysis using go vet ./... to catch basic issues, though it cannot detect most races. The race detector is essential during development and testing, especially in CI pipelines, and should be used routinely because race conditions often manifest silently without crashes, meaning untested concurrent code likely contains undetected races.

Race conditions in Go can be tricky to spot because they don’t always cause crashes or obvious bugs—they might just lead to inconsistent or incorrect behavior under load. Fortunately, Go provides a built-in tool to help detect them: the race detector.

Use the Go Race Detector

The most effective way to check for race conditions is to enable Go’s built-in race detector by adding the -race flag when running your program:

go run -race main.go

Or when testing:

go test -race ./...

This flag instruments your code to detect concurrent access to shared variables where one access is a write. When a race is detected, the tool prints a detailed report showing:

• Which goroutines accessed the variable
• The stack traces for each access
• Whether the access was a read or write

For example, if two goroutines read and write the same variable without synchronization:

var counter int

func main() {
    go func() {
        counter  
    }()
    go func() {
        counter  
    }()
    time.Sleep(time.Second)
}

Running go run -race will likely report a data race on counter.

Write Tests That Exercise Concurrency

The race detector only catches races that actually occur during execution. So you need to create test scenarios that stress concurrent execution.

Tips:

• Run tests with multiple goroutines accessing shared state.
• Use loops to increase the chance of overlapping execution.
• Add time.Sleep calls sparingly (only for demonstration—avoid in real tests).
• Prefer using sync.WaitGroup to coordinate goroutines in tests.

Example test:

func TestCounter(t *testing.T) {
    var counter int
    var wg sync.WaitGroup

    for i := 0; i < 10; i   {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter   // Race!
        }()
    }
    wg.Wait()
}

Run with go test -race to catch the race.

Avoid Common Patterns That Cause Races

Even with the race detector, it helps to recognize unsafe patterns:

• Unsynchronized access to global variables
• Closures capturing loop variables (though Go 1.22 improved this)
• Shared structs without mutex protection

Instead:

• Use sync.Mutex or sync.RWMutex to protect shared data.
• Use channels to pass ownership instead of sharing memory.
• Consider sync/atomic for simple atomic operations (e.g., atomic.AddInt64).

Use Static Analysis Tools (Limited Help)

While the race detector is dynamic (needs execution), tools like go vet can catch some suspicious constructs, though they won’t find most races. Still, always run:

go vet ./...

It may catch obvious mistakes, like locking the wrong mutex or copying locked structs.

Bottom line: The -race flag is your best friend. Use it regularly during testing, especially in CI pipelines. It has performance and memory overhead, so leave it off in production—but never skip it during development and testing.

Basically, if you're writing concurrent Go code and aren't using -race, you're probably shipping races.

The above is the detailed content of How can you check for race conditions in your Go code?. For more information, please follow other related articles on the PHP Chinese website!