Golang Channel'lar: Buffer'lı, Buffer'sız, Close ve Range

Göndermek ve almak

Channel, goroutine'ler arasında tipli bir borudur. ch <- v gönderir, <-ch alır. make ile bir tane oluşturun:

package main

import "fmt"

func main() {
	messages := make(chan string)

	go func() {
		messages <- "ping" // blocks until main receives
	}()

	msg := <-messages // blocks until the goroutine sends
	fmt.Println(msg)
}

Bir channel tipinin sıfır değeri nil'dir, bu yüzden make olmadan var ch chan string size sonsuza kadar bloklanan bir channel verir. Channel'ları her zaman make ile oluşturun.

Buffer'sız channel'lar senkronize eder

make(chan T) buffer'sız bir channel oluşturur. Bir gönderim, bir alıcı değeri alana kadar; bir alım da bir gönderici bir değer sağlayana kadar bloklanır. İki goroutine o noktada buluşur; bu da buffer'sız bir channel'ı bir veri borusu olduğu kadar bir senkronizasyon aracı yapar. Aşağıda <-done döndüğünde worker'ın gönderiminden önceki her şeyi bitirdiğini bilirsiniz:

package main

import "fmt"

func main() {
	done := make(chan struct{})
	result := 0

	go func() {
		for i := 1; i <= 100; i++ {
			result += i
		}
		done <- struct{}{} // signal: finished
	}()

	<-done
	fmt.Println("sum:", result)
}

main içinde result'ı okumak burada bir mutex olmadan güvenlidir. Go'nun bellek modeli, worker'ın gönderimden önce yaptığı her şeyin eşleşen alımdan sonra main'e görünür olduğunu garanti eder. struct{} hiç bellek kaplamadığı için saf bir sinyal için deyimsel tip chan struct{}'dir.

Buffer'lı channel'lar

make(chan T, n) channel'a n değerlik yer verir. Gönderimler buffer dolana kadar bir alıcı olmadan başarılı olur; alımlar buffer boşalana kadar başarılı olur. Değerler girdikleri sırayla çıkar.

package main

import "fmt"

func main() {
	ch := make(chan int, 3)

	ch <- 10
	ch <- 20
	fmt.Println("len:", len(ch), "cap:", cap(ch))

	ch <- 30 // buffer now full; a fourth send here would block forever

	fmt.Println(<-ch, <-ch, <-ch)
	fmt.Println("len:", len(ch))
}

Bir buffer göndericiyi ve alıcıyı birbirinden ayırır, böylece kısa patlamalar göndericiyi durdurmaz. Tüketicisinden kalıcı olarak daha hızlı olan bir üreticiyi düzeltmez; yalnızca göndericinin bloklandığı anı geciktirir. Bir buffer boyutunu bir deadlock'u yok etmek için değil, bir nedenle (gönderici sayısı, bilinen bir parti boyutu) seçin.

len(ch) bir anlık görüntüdür. Ona göre davrandığınızda başka bir goroutine onu değiştirmiş olabilir, bu yüzden bir gönderimin bloklanıp bloklanmayacağına karar vermek için onu kullanmayın. Bunun için default case'li bir select kullanın.

Close ve range

close(ch) alıcılara başka değer gönderilmeyeceğini söyler. Bir close'tan sonra:

• buffer'da zaten olan değerler yine teslim edilir,
• sonra her alım hemen sıfır değeri döndürür,
• v, ok := <-ch, ok == false bildirir,
• for v := range ch biter.

package main

import "fmt"

func produce(n int) <-chan int {
	ch := make(chan int)
	go func() {
		defer close(ch) // the sender closes, when it is done
		for i := range n {
			ch <- i * i
		}
	}()
	return ch
}

func main() {
	for v := range produce(5) {
		fmt.Println(v)
	}

	ch := make(chan string, 1)
	ch <- "last"
	close(ch)
	v, ok := <-ch
	fmt.Printf("%q %v\n", v, ok)
	v, ok = <-ch
	fmt.Printf("%q %v\n", v, ok)
}

close'tan sonraki ilk alım yine ok == true ile "last"'ı alır. İkincisi sıfır değer ""'yi ve false'u alır.

Panic'e yol açan kurallar:

• kapatılmış bir channel'a göndermek send on closed channel ile panic olur,
• zaten kapatılmış bir channel'ı kapatmak panic olur,
• bir nil channel'ı kapatmak panic olur.

Bu yüzden yalnızca gönderen taraf kapatır, ve yalnızca bir kez. Birden fazla göndericiyle hiçbir gönderici diğerlerinin ne zaman bittiğini bilmez; tüm göndericileri (bir sync.WaitGroup ile) bekleyen ayrı bir goroutine'iniz olsun ve channel'ı Wait döndükten sonra kapatsın. Kapatmak yalnızca bir alıcı sonu beklediğinde gereklidir. Kimsenin başvurmadığı kapatılmamış bir channel diğer değerler gibi çöp toplayıcı tarafından toplanır.

Yön tipleri

Bir fonksiyon bir channel'a yalnızca gönderdiğini ya da yalnızca ondan aldığını bildirebilir. Derleyici o zaman diğer işlemi reddeder.

Bir chan T, bir fonksiyona aktardığınızda kısıtlı tiplerden herhangi birine örtük olarak dönüşür. Yukarıdaki produce'un bir <-chan int döndürebilmesinin nedeni budur: çağıranlar onun üzerinde range yapabilir ama ona gönderemez ya da onu kapatamaz. Uygun olan her fonksiyon parametresinde yön tiplerini kullanın. Sahipliği belgelerler ve yanlış kullanımı bir derleme hatasına dönüştürürler.

Deadlock

Her goroutine bloklanmışsa ve hiçbir şey hiçbirini uyandıramıyorsa, çalışma zamanı programı durdurur:

package main

import "fmt"

func main() {
	ch := make(chan int)
	ch <- 1 // no other goroutine exists to receive
	fmt.Println(<-ch)
}

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
	/tmp/main.go:7 +0x38
exit status 2

Goroutine dökümü hangi işlemin takıldığını söyler (burada chan send, ya da chan receive, sync.WaitGroup.Wait, select). Olağan nedenler:

• hiçbir alıcı çalışmıyorken buffer'sız bir channel'a gönderim,
• hiç kapatılmayan bir channel üzerinde range,
• hiç sıfıra ulaşmayan bir WaitGroup sayacı,
• birbirini bekleyen iki goroutine.

Çalışma zamanı yalnızca tüm goroutine'lerin takıldığı durumu tespit eder. Başka goroutine'lerin yaşadığı bir sunucuda (bir HTTP dinleyicisi, bir ticker) aynı hata hiçbir şeyi çökertmez; bloklanan goroutine yalnızca sızar.

Nil channel'lar

Bir nil channel'a gönderimler ve ondan alımlar sonsuza kadar bloklanır. Bu işe yaramaz gibi görünür ama select içinde standart bir hiledir: bir channel değişkenini nil yapmak onun case'ini devre dışı bırakır. Bu, iki channel'ı birleştirir ve her biri kapandığında onu dinlemeyi bırakır:

package main

import "fmt"

func main() {
	a := make(chan int)
	b := make(chan int)
	go func() { defer close(a); a <- 1; a <- 2 }()
	go func() { defer close(b); b <- 10 }()

	sum := 0
	for a != nil || b != nil {
		select {
		case v, ok := <-a:
			if !ok {
				a = nil // a is finished: never select it again
				continue
			}
			sum += v
		case v, ok := <-b:
			if !ok {
				b = nil
				continue
			}
			sum += v
		}
	}
	fmt.Println("sum:", sum)
}

nil atamaları olmadan kapatılmış bir channel her zaman hazırdır ve döngü sıfır değerler üzerinde boşa dönerdi.

Bir pipeline

Channel'lar pipeline'lara dönüşür: her aşama bir channel'dan alıp bir sonrakine gönderen ve girdisi bittiğinde çıktısını kapatan bir goroutine'dir.

package main

import "fmt"

func generate(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, n := range nums {
			out <- n
		}
	}()
	return out
}

func square(in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for n := range in {
			out <- n * n
		}
	}()
	return out
}

func main() {
	total := 0
	for v := range square(square(generate(1, 2, 3))) {
		fmt.Println(v)
		total += v
	}
	fmt.Println("total:", total)
}

Her aşama eşzamanlı çalışır ve çıktı sırası deterministiktir (1, 16, 81), çünkü her aşama sırayı koruyan tek bir goroutine'dir. Kapatmalar zincirleme ilerler: generate kapatır, bu square'in range'ini bitirir, o da çıktısını kapatır ve bu main'e kadar böyle gider.

Bu pipeline'ın zayıf noktası: main okumayı erken bıraksaydı aşamalar gönderimlerinde sonsuza kadar bloklanırdı. Gerçek pipeline'lar bir context.Context ya da bir done channel'ı alır ve her gönderimin yanında onun üzerinde select yapar.

Channel mı, mutex mi

Channel'lar verinin sahipliğini aktarmak ve olayları bildirmek içindir. Bir sync.Mutex, bir önbellek ya da bir sayaç gibi birçok goroutine'in yerinde okuyup güncellediği paylaşılan durumu korumak için daha basittir. İçinde mutex olan bir struct, durumun sahibi olup channel'lar üzerinden istekleri karşılayan bir goroutine'den çoğu zaman daha anlaşılırdır. Hangisi kodu kısaltıyor ve sahipliği belirgin yapıyorsa onu kullanın.

Hızlı başvuru