Какие существуют способы синхронизации данных в Go?

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

Основные механизмы:

• Каналы (Channels): Типизированный канал связи, через который можно отправлять и принимать значения. Могут быть буферизованными и небуферизованными. Использование каналов считается идиоматичным в Go для синхронизации доступа к данным и координации горутин.

  // Небуферизованный канал
  ch := make(chan int)
  
  // Буферизованный канал
  bufferedCh := make(chan string, 10)
  
  // Отправка в канал
  go func() {
      ch <- 1
  }()
  
  // Прием из канала
  val := <-ch
  

• Пакет sync: Предоставляет примитивы синхронизации для более классических сценариев совместного использования памяти.

  • Mutex: Взаимная исключающая блокировка. Может быть только один владелец в любой момент времени.

    import "sync"
    
    var mu sync.Mutex
    var balance int
    
    func deposit(amount int) {
        mu.Lock()
        balance += amount
        mu.Unlock()
    }
    

  • RWMutex: Mutex для чтения/записи. Позволяет множественным горутинам читать одновременно, но только одной горутине писать.

    import "sync"
    
    var rwmu sync.RWMutex
    var data map[string]string
    
    func readData(key string) string {
        rwmu.RLock() // Блокировка для чтения
        defer rwmu.RUnlock()
        return data[key]
    }
    
    func writeData(key, value string) {
        rwmu.Lock() // Блокировка для записи
        defer rwmu.Unlock()
        data[key] = value
    }
    

  • WaitGroup: Ожидание завершения группы горутин.

    import "sync"
    
    var wg sync.WaitGroup
    
    func worker() {
        defer wg.Done() // Уменьшение счетчика по завершении
        // Работа горутины
    }
    
    func main() {
        wg.Add(5) // Увеличение счетчика
        for i := 0; i < 5; i++ {
            go worker()
        }
        wg.Wait() // Ожидание, пока счетчик не станет 0
    }
    

  • Once: Гарантирует выполнение определенного действия только один раз.

    import "sync"
    import "fmt"
    
    var once sync.Once
    
    func setup() {
        fmt.Println("Выполняется только один раз")
    }
    
    func main() {
        go func() {
            once.Do(setup)
        }()
        go func() {
            once.Do(setup)
        }()
         // Обе горутины вызовут once.Do(setup), но setup выполнится лишь один раз
    }
    

В итоге, при выборе подхода предпочтение отдается каналам, так как они способствуют более безопасным и понятным моделям конкуренции. Однако, для определенных сценариев, например, для защиты общих структур данных, примитивы из пакета sync являются подходящим решением.