Горутины и каналы

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

Как select выбирает ветвь, когда одновременно готовы несколько операций?

Представьте, что буферизованный канал закрыли после отправки нескольких значений: что увидит получатель после исчерпания буфера?

Что происходит с ветвью select, если её канал имеет значение nil?

Объясните, почему положительный Add у WaitGroup выполняют до запуска горутины при параллельном вызове Wait?

Разберите ошибку в коде: какой участник должен закрывать канал, чтобы несколько отправителей не завершили его преждевременно?

package main

import (
	"fmt"
	"sync"
)

func main() {
	ch := make(chan int)
	var wg sync.WaitGroup
	for i := 0; i < 2; i++ {
		wg.Add(1)
		go func(v int) {
			defer wg.Done()
			ch <- v
			close(ch)
		}(i)
	}
	go func() { wg.Wait(); close(ch) }()
	for v := range ch { fmt.Println(v) }
}

Как успешная передача значения через канал влияет на видимость изменений памяти между горутинами?

В каких случаях выполняется ветка default в select без блокировки?

Практическая ситуация: сервис запускает много независимых задач, но одновременно разрешено выполнять только две; как применить буферизованный канал для ограничения числа активных горутин?

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

Для чего функциям передают канал с ограниченным направлением?

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

При параллельном запуске нескольких горутин инициализация должна выполниться ровно один раз: какой примитив Go выбрать и почему?

Разберите последствия: программа запускает горутину перед возвратом из main; гарантировано ли, что горутина успеет завершить работу?

Допустимо ли копировать sync.Mutex после его первого использования?

Когда для ожидания изменения общего состояния в Go уместнее sync.Cond, чем канал?

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

Когда замена sync.Mutex на sync.RWMutex может ухудшить производительность?

Две горутины должны обменяться значениями через два небуферизованных канала, но каждая сначала выполняет отправку. Какой результат следует ожидать и почему?

Можно ли после успешной отправки в буферизованный канал считать, что получатель уже обработал значение?