Какие типы каналов существуют в Go и для чего они используются?

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

Смотри, каналы — это как трубы, по которым твои горутины друг с другом болтают. Но трубы-то, сука, бывают разные. Вот смотри, какие распиздяйства тут возможны.

1. Каналы-засранцы (небуферизированные)

Создаёшь так: make(chan T). Вообще без буфера, наголо.

• Как работает: Представь, ты стоишь с передачкой в руке, а твой кореш — в другом конце комнаты. Ты кричишь: «На, лови!» — и замираешь, блядь, с вытянутой рукой, пока он не подбежит и не возьмёт. Ты — отправитель, он — получатель. Пока он не взял, ты нихуя не делаешь. И наоборот, если он стоит и ждёт, а ты ещё не кинул — он тоже тормозит. Это и есть рандеву, ёпта. Полная синхронизация, один в один.
• Зачем: Когда тебе надо быть на 146% уверенным, что твоё сообщение не потерялось в эфире, а прилетело прямо в руки.

ch := make(chan string) // Вот он, голый канал
go func() {
    fmt.Println("Горутина готова отправить данные")
    ch <- "ping" // И вот она встала, как вкопанная, с этим "ping" в руке
}()

message := <-ch // А main-горутина тут как тут, забирает
fmt.Println("Main получил:", message) // И только теперь обе поехали дальше

2. Каналы с заначкой (буферизированные)

Тут уже посложнее: make(chan T, size). Ты говоришь: «Окей, сделай мне ящик на N сообщений».

• Как работает: Ты кидаешь передачку в ящик. Пока ящик не полный — тебе похуй, кидай дальше, не блокируешься. Твой кореш подходит и забирает из ящика, когда захочет. Блокировка наступает только в двух ебейших случаях: 1) Ты пытаешься кинуть в уже забитый под завязку ящик. 2) Кореш пытается достать из пустого ящика. Всё, больше никакой синхронной мороки.
• Зачем: Ну, для производительности, ёбана! Чтоб быстрая горутина не ждала ленивую. Или для организации очереди задач — классика.

ch := make(chan int, 2) // Ящик на две передачки

ch <- 1 // Кинул в ящик. Свободно.
ch <- 2 // Кинул вторую. Всё ещё норм.
// ch <- 3 // А вот тут, сука, облом. Ящик полон. Ты встанешь и будешь ждать, пока кто-то не заберёт хотя бы одну.

fmt.Println(<-ch) // Забрали первую (1). Ура, в ящике снова есть место!
fmt.Println(<-ch) // Забрали вторую (2).

3. Каналы с односторонним движением (направленные)

Это вообще, блядь, верх паранойи и безопасности. Не новый тип, а так, ограничение в объявлении.

• Только для записи: chan<- T — сюда можно только пихать.

• Только для чтения: <-chan T — отсюда можно только таскать.

• Зачем, спрашивается? А чтобы, сука, не выстрелить себе в ногу! Чисто архитектурная хуйня. Есть у тебя функция-поставщик. Так вот, дай ей канал chan<- T, и она физически не сможет оттуда прочитать какую-то левую хуйню по ошибке. И наоборот, функция-потребитель с каналом <-chan T не сможет туда нахерачить мусора. Компилятор не даст, ёпта! Красота.

// Эта функция — поставщик. Ей дали трубу, в которую можно только срать.
func producer(out chan<- int) {
    out <- 100 // Запихнула — молодец.
    // <-out // АХТУНГ! Компилятор орёт: "Ты куда, блядь, лезешь? Тебе сюда нельзя!"
    close(out) // И трубу закрыла, аккуратная девочка.
}

// А эта — потребитель. Ей дали трубу, из которой можно только сосать.
func consumer(in <-chan int) {
    fmt.Println("Получено:", <-in) // Пососала — хорошо.
    // in <- 200 // НИ-ХУ-Я! Компилятор: "А ну положи на место, пизда!"
}

Вот и вся магия, блядь. Главное — не путать, где синхронная морока, а где можно по-бырому в буфер швырять. И с направленными каналами не ебаться, они тебя от глупых косяков спасут. В рот меня чих-пых, иди работай!