Перейти к параллелизму: каналы против мутекс

Параллелизм - это Jewel's Go Crown - Goroutines и каналы делают одновременное программирование чувствовать себя почти волшебным. Но не каждая проблема принадлежит каналу. Многие разработчики попадают в ловушку чрезмерного использования каналов или злоупотребления мутекс, что приводит к медленному, глюковому или незамевному коду. В этой статье мы демистифицируемКогда использовать каналы и когда использовать мутекси почему слепо следование «моделями параллелистики» может иметь неприятные последствия.

Заблуждение

Философия Go «Не общайтесь, делясь памятью; делиться памятью путем общения» часто принимается буквально. Некоторые суслики пытаются заменить каждый мутекс каналом, мышления каналы - это «путь», чтобы синхронизировать все.

Но вот сложная правда:каналы не являются бесплатной заменой для мутексПолем Они отлично подходят для координации goroutines, трубопроводов и событий, но не всегда правильный инструмент для защиты общего состояния.

На первый взгляд, Goroutines выглядят более элегантными, уверенными, и они находятся в правильном контексте. Но попытка направить весь доступ к штатам через каналы, даже для простого счетчика или карты, часто приводит к:

• Ненужная сложность: Простой приращение счетчика может стать десятками строк кода канала шаблона.
• Штрафы на производительность: Каналы включают планирование, распределение и копирование, поэтому вы платите дополнительные накладные расходы, где будет достаточно мутекс.
• Тонкие ошибки: Неправильно управляемые каналы могут отлаживать тупик или утечка, иногда так, чтобы отлаживать гораздо сложнее, чем простой мутекс.

Пример: рассмотрим простой счетчик, который увеличивает множественные goroutines. Использование канала для этого может привести к сложному и подверженному ошибкам кода, в то время как мутекс будет простым и эффективным:

// Using channels to protect a counter
counter := 0
ch := make(chan int)

go func() {
    for val := range ch {
        counter += val
    }
}()

ch <- 1
ch <- 1
close(ch)

Фу. Это работает, но это излишнее. Мутекс делает то же самое с меньшим кодом и меньшими затратами:

// Using a mutex to protect a counter
var mu sync.Mutex
counter := 0

mu.Lock()
counter++
mu.Unlock()

Каналы: для общения, а не только безопасности

Каналы сияют, когда Goroutines необходимо общаться или сигнализировать события. Они могут быть использованы для реализации шаблонов вентиляторов/вентиляторов, рабочих бассейнов или трубопроводов:

package main

import (
	"fmt"
)

func main() {
	jobs := make(chan int, 5)
	results := make(chan int, 5)

	// Start 3 workers
	for w := 0; w < 3; w++ {
		go func(id int) {
			for j := range jobs {
				results <- j * 2
			}
		}(w)
	}

	// Send jobs
	for i := 1; i <= 5; i++ {
		jobs <- i
	}
	close(jobs)

	// Collect results
	for i := 0; i < 5; i++ {
		fmt.Println(<-results)
	}
}

Плюсы:

• Отлично подходит для оркестрации goroutines.
• Может упростить сложные модели координации.

Минусы:

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

Mutexes: правильный инструмент для общего состояния

Прежде всего, что такое мутекс? Мутекс (короткий для взаимного исключения) - это примитив синхронизации, который обеспечивает одну только один goroutine (или поток), который может получить доступ к кусочке общих данных. Он действует как блокировка вокруг критических разделов, предотвращая условия гонки, когда множественные goroutines пытаются прочитать или написать одно и то же состояние одновременно.

Аsync.Mutexпредназначен для защиты доступа к общему ресурсу. Если вам просто нужен безопасный доступ к карте, счетчику или структуре, мутекс часто проще и быстрее.

Представьте, что вы поддерживаете кэш, который необходимо читать и обновить множественные goroutines. Аsync.Mutexэто самый простой и эффективный способ охранять эту общую карту:

var (
    mu    sync.Mutex
    cache = make(map[string]string)
)

func set(key, value string) {
	mu.Lock()
	defer mu.Unlock()
	cache[key] = value
}

func get(key string) (string, bool) {
	mu.Lock()
	defer mu.Unlock()
	v, ok := cache[key]
	return v, ok
}

Плюсы:

• Чрезвычайно низкие накладные расходы.
• Явная блокировка делает рассуждения о общем состоянии простым.
• Предсказуемая производительность.

Минусы:

• Тупики, если он используется неправильно.
• Может быть менее элегантным в сложных трубопроводах или вентиляционных паттернах.

Когда использовать что

Эмпирическое правило:Используйте мутекс для общего состояния, каналы для общенияПолем

Производительность реальности

Цитрицы часто удивляют, Go Devs. Простые мутации состояния, защищенные мутексами

• Мутекс очень легкие. Они реализованы во время выполнения GO с использованием эффективных атомных операций. Замок и разблокировка часто стоит лишь несколько наносекунд.
• Каналы, с другой стороны, включают в себя больше движущихся частей. Отправка или получение на канале может запустить:
  • Распределение памяти для буферированной/бессмысленной очереди.
  • Планирование ожидания goroutines.
  • Потенциальное переключение контекста, если приемник не готов.

Эта дополнительная бухгалтерская работа делает каналы медленнее, когда все, что вам нужно, это охранять общую переменную.

Контрол: Mutex vs канал счетчик

Давайте рассмотрим это на тест с помощью концентрации Go:

package main

import (
	"sync"
	"testing"
)

func BenchmarkMutexCounter(b *testing.B) {
	var mu sync.Mutex
	counter := 0

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			mu.Lock()
			counter++
			mu.Unlock()
		}
	})
}

func BenchmarkChannelCounter(b *testing.B) {
	counter := 0
	ch := make(chan int, 1000)

	// Goroutine that serializes all increments
	go func() {
		for v := range ch {
			counter += v
		}
	}()

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			ch <- 1
		}
	})

	close(ch)
}

И вот пример того, как могут выглядеть результаты на типичном ноутбуке (GO 1.23, 8-ядерный процессор):

BenchmarkMutexCounter-8      1000000000   0.8 ns/op
BenchmarkChannelCounter-8     20000000    60 ns/op

Теперь, очевидно, реальные рабочие нагрузки могут немного отличаться от синтетических контрольных показателей (например, переключатели контекста, планирование ОС и т. Д.), Но это~ 75 × разница в производительности в пользу Mutex!

Так почему огромный разрыв? Путь Mutex - это просто атомная операция для приобретения/освобождения блокировки. Путь канала включает в себя синхронизацию между двумя goroutines, управление очередью и, возможно, пробуждение сна.

Это демонстрирует, почему мутекс - это правильный инструмент для защиты простого общего состояния.

Реальные примеры

1. Подсчет запросов веб -сервера

Представьте, что вы запускаете HTTP -сервер и хотите подсчитать запросы:

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

В производстве это разница между комфортной обработкой 100K запросов/сек и отставкой в 10 тыс. Запросов/сек.

2. Общий кеш

Если несколько goroutines считывают и напишите кэш (например, пользователь Map [String]), Mutex идеально подходит. Читает и записывает, что происходит с минимальными затратами.

Благодаря каналу "Cache Manager Goroutine" каждый отдельный чтение/запись становится запросом-ответ обратно. Вместо O (1) поиска карты у вас теперь есть O (1) + канал отправки/приема + планирование. Это вводит задержку и делает ваш кэш медленнее, чем просто нанести удар по базе данных в некоторых случаях.

3. Рабочие пул для обработки задач

С мутексом у вас может быть кусок задач, защитить его с помощью син.mutex и попросить из него несколько ружений. Каждый goroutine блокирует, вызывает задачу, разблокирует, процессы и повторения.

Но с помощью каналов вы можете просто выдвинуть задачи в канал работы, развернуться и работников и позволить им одновременно употреблять:

jobs := make(chan string, 100)
results := make(chan string, 100)

for w := 0; w < 5; w++ {
    go func(id int) {
        for job := range jobs {
            results <- process(job)
        }
    }(w)
}

for _, j := range []string{"a", "b", "c"} {
    jobs <- j
}
close(jobs)

Здесь каналы являются естественным соответствием, потому что проблема - это распределение работы, а не только общая безопасность памяти.

Использование Mutex потребует написания собственной координационной логики, которая является более подверженной ошибкам и менее читаемой.

4. Уведомления о событиях / паб-саб

С помощью мутекса вы можете поддерживать кусок подписчиков, охраняемых мутекс. Каждый раз, когда происходит событие, вы блокируете, зацикливаются на подписчиках и вызываете их функции обработчика. Это работает, но это смешивает синхронизацию, итерацию и бизнес -логику.

Почему Goroutines + каналы лучше: каналы позволяют вам отделить производство событий от потребления. Каждый подписчик может слушать на своем собственном канале и обрабатывать события в своем собственном темпе:

subscribers := []chan string{}

func subscribe() chan string {
    ch := make(chan string, 10)
    subscribers = append(subscribers, ch)
    return ch
}

func publish(event string) {
    for _, ch := range subscribers {
        ch <- event
    }
}

Теперь вы можете развернуть независимые goroutines для каждого подписчика:

sub := subscribe()
go func() {
    for msg := range sub {
        fmt.Println("Received:", msg)
    }
}()

publish("user_signed_in")
publish("user_signed_out")

С Goroutines + каналами события асинхронно текут, подписчики не блокируют друг друга, а обратное давление (буферированные/незвученные каналы) легко моделировать.

Делать то же самое с списком подписчиков на основе Mutex быстро становится грязным, особенно если один абонент является медленным или блоками.

Другие примитивы параллелизма в Go

В то время как мутекс и каналы являются наиболее распространенными инструментами, стандартная библиотека GO включает в себя несколько других примитивов, которые стоит знать:

• sync.RWMutex: Вариацияsync.MutexЭто позволяет нескольким читателям удерживать блокировку одновременно, но только один писатель за раз. Полезно для рабочих нагрузок, таких как кэши.
• sync.Cond: Переменная условия, которая позволяет goroutines ждать, пока не будет выполнено определенное условие. Более продвинутые, чем каналы, но иногда полезные для реализации пользовательских моделей координации.
• sync.Once: Обеспечивает, что кусок кода работает только один раз, даже если вы называете из нескольких goroutines. Обычно используется для ленивой инициализации.
• sync.WaitGroup: Ждет коллекции Goroutines, чтобы закончить. Идеально подходит для нерестовых работников и ожидания их завершения, прежде чем двигаться дальше.
• sync/atomic: Предоставляет низкоуровневые атомные операции (например, Atomic.Addint64) для предоставления без блокировки к основным типам. Часто самое быстрое решение для счетчиков и флагов.

Эти инструменты дополняют мутекс и каналы. Например, вы можете использоватьsync.WaitGroupЧтобы подождать партию Goroutines, чтобы закончить обработку перед отправкой конечного результата на канале.

Или счетчик сsync/atomicДля увеличения без блокировки:

package main

import (
	"fmt"
	"sync/atomic"
)

func main() {
	var counter int64

	// Increment atomically
	atomic.AddInt64(&counter, 1)

	// Read atomically
	value := atomic.LoadInt64(&counter)

	fmt.Println("Counter:", value)
}

Это часто является самым быстрым вариантом для простых счетчиков и флагов, потому что он вообще избегает спора о замке.

Если мы продлим наш эталон сверху:

func BenchmarkAtomicCounter(b *testing.B) {
	var counter int64

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			atomic.AddInt64(&counter, 1)
		}
	})
}

Результаты будут что -то вроде этого:

BenchmarkAtomicCounter-8    1000000000   0.3 ns/op
BenchmarkMutexCounter-8     1000000000   0.8 ns/op
BenchmarkChannelCounter-8     20000000   60 ns/op

Обратите внимание, как атомные операции на ~ 2–3 × быстрее, чем мутекс, в то время как каналы распоряжаются медленнее для этого варианта использования. Обидно, что атомные операции чрезвычайно ограничены: они работают только над отдельными переменными и основными типами.

Заключение

Мутекс идеально подходит для защиты состояния. Каналы сияют, когда вам нужно координировать или распространять работу/события.

Но многие разработчики стараются заставить каналы в каждую проблему параллелизма, потому что они чувствуют себя более «идиоматическими». На самом деле каналы по своей природе не лучше, чем мутекс. Это инструменты для общения, а не серебряная пуля. Также важно отметить, чтоканалы и мутекс не являются взаимоисключающими- Иногда вы объедините их (например, рабочие пул с каналом + общей статистикой, защищенной Mutex). Думайте о каналах как о «коммуникационных автомагистралях» и мутексесах как о «светофоре» для общей памяти - у каждого есть свое место.

Чрезмерные каналы-это обычная ловушка для начинающих и приводит к коду, который труднее читать, медленнее, чтобы запустить и более склонную к ошибкам-полная противоположность философии простоты Го. Только не задумывайтесь над этим:мутекс для состояния, каналы для общенияПолем