Кратко — причина дедлока $илипаники$ в таких примерах обычно в неверной координации отправителей/приёмников и в попытках закрыть канал в неподходящее время. Разберём ваш пример и варианты исправления.

Исходный код $воднустрокудлянаглядности$:
ch := make$chanint$ go func{ ch <- 1 } <-ch
close$ch$

Почему тут проблем нет в простом случае

Если единственный отправитель выполняет ch <- 1 и затем завершает goroutine, а главный поток делает <-ch и только потом close$ch$, то всё работает: отправка синхронизируется с приёмом, после приёма можно безопасно закрыть канал $отправительужезавершился$.Но в реальном коде легко допустить гонку: если close$ch$ вызывается до того, как последний отправитель выполнил ch <- ..., то отправка в закрытый канал вызовет panic. Если же все горутины окажутся заблокированы $всетолькождутоперацийнаканалахиниоднанеготовавыполнитьsend/receive$, runtime обнаружит «all goroutines are asleep – deadlock!» и завершит программу.

Гарантии, которые даёт runtime

Нештатный канал $make(chanT)$ — это unbuffered: send блокируется до тех пор, пока кто‑то не выполнит receive; receive блокируется до тех пор, пока кто‑то не выполнит send.Буферизированный канал $make(chanT,N)$ — send блокируется только когда буфер заполнен; receive блокируется когда буфер пуст.Отправка и приём через канал обеспечивает happens‑before семантику: всё, что было сделано до send в отправителе, будет видимо приёму после receive.Закрытие канала: после close$ch$ приём (<-ch) возвращает нулевое значение и ok==false; попытка отправить в закрытый канал вызывает panic.Runtime может обнаружить дедлок и завершить программу, если нет runnable‑горутин $всегорутинызаблокированы$.

Как правильно структурировать обмен, чтобы избежать блокировок и утечек горутин
1) Закрывает только отправитель

Правило: тот, кто посылает все значения и знает, что отправок больше не будет, должен закрывать канал.
Пример:
ch := make$chanint$ go func {
ch <- 1
close$ch$ } v, ok := <-ch
// ok==true для полученного значения; если range, то он корректно остановится после close.

2) Используйте buffered канал, если хотите ненадёжную ненадёжную ненадёжность $тоестьпозволитьотправителюнеждать$:
ch := make$chanint,1$ go func{ ch <- 1 } v := <-ch
// send не блокирует, пока в буфере есть место

Но учтите: буфер лишь временно снимает синхронизацию, он не решает проблемы с закрытием или координацией нескольких отправителей.

3) Используйте sync.WaitGroup / явную синхронизацию

Если нужно дождаться, что горутина завершилась, используйте WaitGroup вместо попытки угадать порядок close/receive:
var wg sync.WaitGroup
wg.Add$1$ ch := make$chanint$ go func {
defer wg.Done ch <- 1
} v := <-ch
wg.Wait // теперь можно закрывать канал, если нужно

4) Используйте отдельный канал done / context для отмены и завершения

Чтобы не «утекали» горутины, давайте им сигнал остановки $doneканалилиcontext.Context$ и в горутине слушайте select{ case ...; case <-done: return }.

5) Не закрывайте канал, если есть несколько отправителей

Если несколько горутин могут посылать в канал, кто‑то один не может безопасно закрыть его, потому что другие могут попытаться послать позже — это приведёт к панике. В таких случаях используйте синхронизацию $WaitGroup$ или делегируйте закрытие единственной координатор‑горутины.

6) Обрабатывать закрытие при чтении
v, ok := <-ch
if !ok {
// канал закрыт
}

Резюме с рекомендуемым шаблоном

Если у вас один отправитель: пусть он сам делает close$ch$ после всех отправок.
ch := make$chanint$ go func {
defer close$ch$ ch <- 1
} for v := range ch {
fmt.Println$v$ }

Если несколько отправителей: не закрывайте канал из приёмника; используйте WaitGroup или отдельный координатор, который закроет канал только когда все отправители завершились.

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