原子計數器以身作則

原子計數器用於在多個goroutine中安全地增減或讀取值以避免競爭條件，Go中的sync/atomic包提供底層原子操作，推薦使用atomic.Int64（Go 1.19 ）或atomic.AddInt64/LoadInt64等函數實現；1. 使用atomic.Int64可安全實現並發自增，如10個goroutine各增100次最終結果為1000；2. 在舊版Go中可通過atomic.AddInt64(&counter, 1)和atomic.LoadInt64(&counter)操作int64類型變量實現等效功能，需確保使用int64而非int以保證原子性；3. 可結合Load和Add在監控場景中安全讀寫計數器，如後台定期打印訪問量同時主線程增加計數；若未使用原子操作而直接對普通int變量進行並發遞增，則會觸發競態條件，導致結果不准確並被-go run -race檢測出問題；應使用原子計數器的場景包括：僅執行簡單增減查存操作、追求高性能且無需複雜共享狀態；反之當需更新多個關聯變量或執行複合邏輯時應改用sync.Mutex；總結：原子計數器是並發安全、高效無鎖且易於使用的工具，只要確保類型為int64、避免混合非原子操作並利用-race標誌檢測問題，即可正確高效地處理跨goroutine計數需求。

Atomic counters are used when you need to safely increment, decrement, or read a value from multiple goroutines without causing race conditions. In Go, the sync/atomic package provides low-level atomic operations, and atomic.Int64 (available since Go 1.19) or atomic.Value with int64 via atomic.AddInt64 , atomic.LoadInt64 , etc., are common ways to implement atomic counters.

Let's walk through a few practical examples that show how atomic counters work and when to use them.

✅ Example 1: Simple Atomic Counter with atomic.Int64

Since Go 1.19, atomic.Int64 provides a clean, type-safe way to manage atomic counters.

 package main

import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

func main() {
    var counter atomic.Int64
    var wg sync.WaitGroup

    // Launch 10 goroutines that each increment the counter 100 times
    for i := 0; i < 10; i {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := 0; j < 100; j {
                counter.Add(1)
                time.Sleep(time.Microsecond) // Simulate small work
            }
        }()
    }

    wg.Wait()
    fmt.Println("Final counter value:", counter.Load())
}

Output:

 Final counter value: 1000

✅ This is safe and race-free. No mutex needed.

✅ Example 2: Using atomic.AddInt64 and atomic.LoadInt64 (Pre-Go 1.19 style)

If you're on an older Go version or prefer explicit functions:

 package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

func main() {
    var counter int64 // Must be int64 for atomic operations
    var wg sync.WaitGroup

    for i := 0; i < 5; i {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := 0; j < 200; j {
                atomic.AddInt64(&counter, 1)
            }
        }()
    }

    wg.Wait()
    fmt.Println("Counter:", atomic.LoadInt64(&counter))
}

? Note: You must use int64 (not int ) because the atomic package operates on specific sizes, and int may be 32-bit on some systems.

✅ Example 3: Atomic Counter with Read (Load) and Write (Store)

You can also safely read and write values atomically:

 package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

func main() {
    var visits atomic.Int64

    // Simulate a background monitor
    go func() {
        for {
            time.Sleep(500 * time.Millisecond)
            fmt.Println("Visits so far:", visits.Load())
        }
    }()

    // Simulate incoming requests
    for i := 0; i < 10; i {
        visits.Add(1)
        time.Sleep(100 * time.Millisecond)
    }

    time.Sleep(time.Second) // Let monitor print a few times
}

This shows how you can safely read a counter from one goroutine while writing from others.

❌ What Happens Without Atomic?

If you use a regular int and increment across goroutines:

 var counter int
for i := 0; i < 10; i {
    go func() {
        for j := 0; j < 100; j {
            counter // ? Not atomic! Race condition!
        }
    }()
}

Run this with -race :

 go run -race main.go

You'll see race condition warnings , and the final value may be less than expected.

When to Use Atomic Counters

Use atomic counters when:

• You're doing simple operations: increment, decrement, add, load, store.
• Performance matters — atomics are faster than mutexes.
• You don't need complex shared state (eg, updating multiple fields together).

Avoid atomics when:

• You're updating multiple related variables — use sync.Mutex instead.
• You need complex logic or consistency across values.

Summary

Atomic counters in Go are:

• Safe for concurrent access
• Efficient (no locks)
• Easy to use with atomic.Int64 or atomic.AddInt64 / LoadInt64

Just remember:

• Use int64 (not int )
• Don't mix atomic and non-atomic access
• Use -race flag to detect issues

Basically, if you're counting things across goroutines, reach for atomic.Int64 . It's simple, fast, and correct.

以上是原子計數器以身作則的詳細內容。更多資訊請關注PHP中文網其他相關文章！