Die Parallelität von Go ohne es ist wie ein iPhone ohne Netzwerk

channel 的设计是基于 CSP 模型的。CSP 是 Communicating Sequential Process 的简称，中文可以叫做通信顺序进程，是一种并发编程模型，由 Tony Hoare 于 1977 年提出。简单来说，CSP 模型由并发执行的实体（线程或者进程）所组成，实体之间通过发送消息进行通信，这里发送消息时使用的就是通道，或者叫 channel。CSP 模型的关键是关注 channel，而不关注发送消息的实体。Go 语言实现了 CSP 部分理论，goroutine 对应 CSP 中并发执行的实体，channel 也就对应着 CSP 中的 channel。

创建Channel

• Go中的Channel使用chan

zu erwähnen es als Pipes, über die die gleichzeitige Kerneinheit Daten zur Kommunikation senden oder empfangen kann. Werfen wir in diesem Artikel einen genaueren Blick auf

• channel

• .

channel basiert auf dem CSP-Modell. CSP ist die Abkürzung für „Communicating Sequential Process“. Auf Chinesisch kann es „Communicating Sequential Process“ genannt werden. Es handelt sich um ein Modell der gleichzeitigen Programmierung, das 1977 von Tony Hoare vorgeschlagen wurde. Vereinfacht ausgedrückt besteht das CSP-Modell aus der gleichzeitigen Ausführung von Entitäten (Threads oder Prozessen), die durch das Senden von Nachrichten kommunizieren. Der beim Senden von Nachrichten verwendete Kanal ist ein Kanal. Der Schlüssel zum CSP-Modell besteht darin, sich auf den Kanal zu konzentrieren, nicht auf die Entität, die die Nachricht sendet. Die Go-Sprache implementiert einen Teil der CSP-Theorie. Goroutine entspricht der gleichzeitig ausgeführten Entität in CSP, und Kanal entspricht dem Kanal in CSP.

Kanal erstellen

Kanalverwendung in Gochan als Schlüsselwort.

Ohne Pufferung des Kanals werden Senden und Empfangen blockiert, bis die andere Partei bereit ist. Diese Methode kann zur Synchronisierung in Gororutines verwendet werden – ohne Verwendung von Sperren oder Bedingungsvariablen.
Es gibt einen Pufferkanal, der Blockierungen so weit wie möglich vermeiden und die Leistung der Anwendung verbessern kann, indem normalerweise Zeit gegen Speicherplatz ausgetauscht wird. 🎜🎜🎜

aChan := make(chan int)  // 创建无缓冲chan
bChan := make(chan int, N) // 创建缓冲为N的chan

Nach dem Login kopieren
🎜Zuweisung und Werterfassung🎜🎜 Das liegt daran, dass die beiden Anweisungen normalerweise nicht zusammenpassen: 🎜Coroutine A sendet Daten und Coroutine B empfängt Daten 🎜. 🎜

mchan <- value  // 发送值v到Channel ch中
value := <-mchan // 从Channel ch中接收数据，并将数据赋值给v

Nach dem Login kopieren
🎜Select🎜🎜🎜 Selsect🎜 ist die gebräuchlichste Methode, um Daten im Kanal abzurufen. 🎜

select 一定程度上可以类比于 linux 中的 IO 多路复用中的 select。后者相当于提供了对多个 IO 事件的统一管理，而 Golang 中的 select 相当于提供了对多个 channel 的统一管理。当然这只是 select 在 channel 上的一种使用方法。

func main(){
    ch1 := make(chan int, 1)
    ch2 := make(chan int, 1)

    select {
        case e1 := <-ch1:
        //如果ch1通道成功读取数据，则执行该case处理语句
            fmt.Printf("1th case is selected. e1=%v",e1)
        case e2 := <-ch2:
        //如果ch2通道成功读取数据，则执行该case处理语句
            fmt.Printf("2th case is selected. e2=%v",e2)
        default:
        //如果上面case都没有成功，则进入default处理流程
            fmt.Println("default!.")
    }
}

Nach dem Login kopieren

for…range

for …… range语句可以处理Channel。

    go func() {
        time.Sleep(1 * time.Hour)
    }()
    c := make(chan int)
    go func() {
        for i := 0; i < 10; i = i + 1 {
            c <- i
        }
        close(c)
    }()
    for i := range c {
        fmt.Println(i)
    }
    fmt.Println("Finished")

Nach dem Login kopieren

timeout

Select很重要的一个应用就是超时处理。因为上面提供的demo，select语句就会一直阻塞着。这时候我们可能就需要一个超时操作，用来处理超时的情况。下面这个例子我们会在2秒后往channel c1中发送一个数据，但是Select设置为1秒超时,因此我们会打印出timeout 1,而不是result 1。

    c1 := make(chan string, 1)
    go func() {
        time.Sleep(time.Second * 2)
        c1 <- "result 1"
    }()
    select {
    case res := <-c1:
        fmt.Println(res)
    case <-time.After(time.Second * 1):
        fmt.Println("timeout 1")
    }

Nach dem Login kopieren

close

    Go内建的close方法就可以用来关闭channel。但如果channel 已经被关闭,继续往它发送数据会导致panic: send on closed channel:

 close(mChan)