Mekanisme penyekatan Saluran Buffered Go

Dalam bahasa Go, terdapat jenis saluran khas yang dipanggil Saluran Penampan, yang menyimpan sejumlah elemen tertentu dalam saluran. Apabila bilangan elemen dalam saluran mencapai had atas yang ditetapkan, operasi tulis akan disekat sehingga coroutine lain membaca elemen daripada saluran. Sebaliknya, apabila bilangan elemen dalam saluran adalah sifar, operasi baca juga akan disekat sehingga coroutine lain menulis elemen ke saluran. Mekanisme penyekatan ini boleh mengawal penyegerakan dan komunikasi antara coroutine dengan berkesan. Dalam artikel ini, kami akan memperkenalkan mekanisme penyekatan Saluran Buffer dalam bahasa Go secara terperinci.

Kandungan soalan

Dalam "Tour of Go", kod sampel diberikan seperti ini:

package main

import "fmt"

func main() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

Ia dilaksanakan dengan baik dan mencetak

1
2

Tingkah laku ini berbeza daripada penerangan latihan ini, yang menyatakan:

<code>
Sends to a buffered channel block only when the buffer is full. Receives block when the buffer is empty
</code>

dalam ch <- 2 行之后，ch is 已满，并且由于我们只运行 1 个单独的 Goroutine，即主 Goroutine，因此该 Goroutine 应该被阻塞，直到 ch is 被接收者消耗，因此代码不应该到达fmt.Println(<-ch) OK, tetapi harus sebut seperti

<code>
fatal error: all goroutines are asleep - deadlock!
</code>

Namun, memandangkan ini tidak berlaku, saya keliru dan mencari panduan.

Ini adalah satu lagi kod yang saya tulis

chh := make(chan int, 2)

go func() {
    chh <- 1
    fmt.Printf("chh after 1: %v, %v\n", cap(chh), len(chh))
    chh <- 2
    fmt.Printf("chh after 2: %v, %v\n", cap(chh), len(chh))
    chh <- 3
    fmt.Printf("chh after 3: %v, %v\n", cap(chh), len(chh))
}()

fmt.Println(<-chh)
fmt.Println(<-chh)
fmt.Println(<-chh)

Hasil pelaksanaan ialah

1
chh after 1: 2, 0
chh after 2: 2, 0
chh after 3: 2, 1
2
3

Ini lebih mengelirukan. Kali ini ada lagi goroutine yang melakukan penghantaran. Jangkaan saya ialah ia akan disekat serta-merta selepas yang pertama fmt.Println(<-chh) 期间，主 goroutine 应该被阻塞。调度程序将选择运行匿名函数的 goroutine，并且它应该执行到 chh <- 2，然后它会阻塞自身，调度程序再次恢复到主 goroutine。然而，如结果所示，第二个 goroutine 在 chh <- 1. Mengapa ini berlaku?

Edit: Saya masih tidak faham mengapa cetakan tempatan saya 1 pada mulanya. Apabila saya cuba menggunakan go Playground pada pelayan jauh, ia menunjukkan tingkah laku yang berbeza, kini konsisten dengan jangkaan saya.

Adalah diketahui bahawa saluran itu terdiri daripada 3 barisan (menerima goroutine, menghantar goroutine dan penimbal nilai Apabila fungsi tanpa nama berjalan, saluran chh的状态为(sending:empty,valuebuffer:empty,receiving:[main] )).

Anak yang sedang berjalan Goroutine hanya menolak nilai terus ke dalam Goroutine utama tanpa benar-benar menghantarnya ke penimbal nilai. Sebab tu chh推送后1的长度是0.

Penyelesaian

Saluran ini boleh memuatkan dua orang. Dua hantaran boleh berjaya tanpa menyekat. Yang ketigatak boleh. Hantaran hanya akan disekat jika saluran penuh sebelum dihantar.

Atas ialah kandungan terperinci Mekanisme penyekatan Saluran Buffered Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!