Как сделать потокобезопасный инкремент количества вызовов внутри структуры в Go?

Потокобезопасный инкремент в Go

В Go существует несколько подходов для обеспечения потокобезопасности при инкременте счетчика вызовов внутри структуры. Вот основные методы, от простых к сложным.

1. Использование sync.Mutex

Наиболее базовый подход — использование мьютекса для защиты доступа к общему ресурсу.

package main

import (
    "fmt"
    "sync"
)

type CallCounter struct {
    mu    sync.Mutex
    count int
}

func (c *CallCounter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

func (c *CallCounter) GetCount() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    counter := &CallCounter{}
    var wg sync.WaitGroup
    
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }
    
    wg.Wait()
    fmt.Println("Total calls:", counter.GetCount()) // 1000
}

2. Использование sync.RWMutex

Если операций чтения значительно больше, чем записей, эффективнее использовать RWMutex.

type CallCounter struct {
    mu    sync.RWMutex
    count int
}

func (c *CallCounter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

func (c *CallCounter) GetCount() int {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.count
}

3. Использование atomic операций

Для простых операций инкремента оптимальны атомарные операции из пакета sync/atomic.

import "sync/atomic"

type CallCounter struct {
    count int64
}

func (c *CallCounter) Increment() {
    atomic.AddInt64(&c.count, 1)
}

func (c *CallCounter) GetCount() int64 {
    return atomic.LoadInt64(&c.count)
}

Преимущества atomic:

• Высокая производительность для простых операций
• Нет блокировок, только атомарные инструкции процессора
• Меньше накладных расходов

4. Использование каналов (Go-идиоматичный подход)

В Go популярен принцип "Do not communicate by sharing memory; instead, share memory by communicating".

type CallCounter struct {
    count   int
    command chan func()
}

func NewCallCounter() *CallCounter {
    c := &CallCounter{
        command: make(chan func()),
    }
    go c.run()
    return c
}

func (c *CallCounter) run() {
    for cmd := range c.command {
        cmd()
    }
}

func (c *CallCounter) Increment() {
    c.command <- func() {
        c.count++
    }
}

func (c *CallCounter) GetCount() int {
    result := make(chan int)
    c.command <- func() {
        result <- c.count
    }
    return <-result
}

func (c *CallCounter) Close() {
    close(c.command)
}

5. Использование sync/atomic с CAS (Compare-And-Swap)

Для более сложных сценариев, где нужны не только инкременты:

type CallCounter struct {
    count int64
}

func (c *CallCounter) IncrementWithCAS() {
    for {
        current := atomic.LoadInt64(&c.count)
        if atomic.CompareAndSwapInt64(&c.count, current, current+1) {
            return
        }
    }
}

Сравнение подходов

Критерии выбора:

1. Производительность: atomic > sync.Mutex > каналы
2. Простота: sync.Mutex > atomic > каналы
3. Гибкость: каналы > sync.Mutex > atomic
4. Идиоматичность: каналы > sync.Mutex > atomic

Рекомендации для разных сценариев

• Высоконагруженные счетчики: sync/atomic
• Общие структуры данных: sync.Mutex или sync.RWMutex
• Сложная бизнес-логика: каналы или sync.Mutex
• Чтение >> записи: sync.RWMutex
• Минимальные накладные расходы: sync/atomic

Пример комплексного решения

type CallCounter struct {
    mu      sync.RWMutex
    counters map[string]int64
}

func (c *CallCounter) Increment(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.counters[key]++
}

func (c *CallCounter) GetCount(key string) int64 {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.counters[key]
}

Важные замечания:

1. Всегда проверяйте, что защищаемый ресурс действительно нуждается в потокобезопасности
2. Профилируйте код перед оптимизацией
3. Документируйте потокобезопасность методов в комментариях
4. Для map всегда требуется синхронизация при конкурентном доступе

Выбор конкретного подхода зависит от контекста: требований к производительности, сложности операций и стиля кода в проекте.