Начинаем день с 9-ой главы книги "Golang для профи" от Михалиса Цукалоса. Глава - весьма лёгкая, поэтому я записал либо общие термины, которые важно помнить, либо моменты, которые мне показались интересными.
Конкурентность и параллелизм - разные вещи. Параллелизм - возможность выполнить несколько задач параллельно, в один момент времени. Конкурентность - способ организации, при котором задачи выполняются тогда, когда это возможно. В случае go - когда одна задача уходит на ожидание, другая начинает выполнение. Если первая выходит из ожидания, пока вторая всё ещё выполняется - первая может продолжить выполняться в другом потоке.
Очень часто разработчики используют waitgroup для ожидания выполнения пачки горутин. Перед запуском горутины счетчик инкрементируется посредством waitgroup.Add(1), внутри горутины происходит декремент, посредством waitgroup.Done(), в основном потоке мы ждём завершения выполнения группы горутин с помощью waitgroup.Wait(). Если количество Add будет больше, чем Done - получим deadlock, если меньше - фатальное завершение, так что этот момент важно контролировать.
Канал - это механизм коммуникации, позволяющий обмениваться данными между горутинами. Канал создаётся с помощью
make(chan type, bufferSize), где type - тип данных, проходящих через канал, а bufferSize - количество данных, которые канал сможет принять до блокировки. Канал можно закрыть с помощью метода close().
Если мы попытаемся считать данные из закрытого канала - мы получим нулевое значение соответствующего типа, а не ошибку. Это важный момент, часто являющийся поводом для ошибок, и который нужно обрабатывать.
Конвейер - паттерн, представляющий собой виртуальный метод, соединяющий горутины и каналы таким образом, что выходные данные одной горутины становятся входными данными для другой горутины.
Например:
var CLOSEA = false
var DATA = make(map[int]bool)
func random(min, max int) int {
return rand.Intn(max - min) + min
}
func first(min, max int, out chan <- int) {
for {
if CLOSEA {
close(out)
return
}
out <- random(min, max)
}
}
func second(out chan<- int, in <-chan int) {
for x := range in {
_, ok := DATA[x]
if ok {
CLOSEA = true
} else {
DATA[x] = true
out <- x
}
}
close(out)
}
func third(in <- chan int) {
var sum int
sum = 0
for x2 := range in {
sum = sum + x2
}
fmt.Println(sum)
}
func main() {
rand.Seed(time.Now().UnixNano())
A := make(chan int)
B := make(chan int)
go first()
go second()
third()
}
Похожим образом работает конвейер в unix: в консоли мы можем передать вывод одной программы на вход другой через вертикальный слеш:
cat .env | grep psqlДалее автор приводит интересное сравнение моделей конкурентности в go и Rust:
* потоки Rust - это потоки UNIX, соответственно - они гораздо более тяжелые, чем горутины
* Rust поддерживает конкурентность на основе обмена сообщениями и на основе совместного использования состояний - то же самое, что в Go реализовано с помощью каналов, мьютексов и общих переменных
* строгая типизация и система владения позволяет Rust обеспечивать безопасное изменяемое состояние потока
* Rust позволяет, с помощью специальных структур, совместно использовать состояния потока
Резюмируя, у Rust есть гибкая модель конкурентности, ещё более гибкая, чем у go. Но, чтобы её использовать, приходится мириться с Rust :)
Далее - ещё одно сравнение, между Go и Erlang:
* в Erlang используется только асинхронная коммуникация
* в Erlang реализована система обработки ошибок, позволяющая создавать надёжные конкурентные системы
* сбои процессов во время конкурентной работы можно ловить и обрабатывать
* как и горутины, процессы в Erlang являются изолированными, у них нет общих состояний. Единственный способ взаимодействия между процессами - передача сообщений
* Потоки Erlang такие же лёгкие, как и горутины.
Система конкурентности в Erlang, в общих чертах, больше похожа на систему конкурентности в Go, так что если тебе нравится Erlang - можно смело его юзать :)
