Kanalbezogene Erklärungen in Go-Sprache

Das CSP-Modell wird in der Go-Sprache für die Thread-Kommunikation verwendet. Genauer gesagt handelt es sich um die Kommunikation zwischen leichtgewichtigen Thread-Goroutinen. Das CSP-Modell ähnelt dem Actor-Modell. Es besteht ebenfalls aus unabhängigen Einheiten, die gleichzeitig ausführen. Die Einheiten kommunizieren auch durch das Senden von Nachrichten.

1. Der Unterschied zwischen Akteurmodell und CSP-Modell:

Aktoren kommunizieren direkt, während CSP über den Kopplungsgrad kommuniziert sind gleich. Es gibt einen Unterschied, letzteres ist lockerer gekoppelt.
Der Hauptunterschied besteht darin, dass im CSP-Modell der Absender und der Empfänger der Nachricht lose über den Kanal gekoppelt sind. Der Absender weiß nicht, welcher Empfänger die Nachricht konsumiert hat, und der Empfänger weiß nicht, welcher Absender die Nachricht gesendet hat. . Da der Akteur im Akteurmodell anhand seines eigenen Zustands auswählen kann, welche eingehende Nachricht er verarbeiten möchte, sind Autonomie und Kontrollierbarkeit besser.
Um den Prozess in der Go-Sprache nicht zu blockieren, müssen Programmierer verschiedene eingehende Nachrichten überprüfen, um die richtige Reihenfolge vorherzusehen und sicherzustellen. Der Vorteil von CSP besteht darin, dass Channel keine Nachrichten puffern muss, während Actor theoretisch ein Postfach unbegrenzter Größe als Nachrichtenpuffer benötigt.
Der Nachrichtensender des CSP-Modells kann nur dann eine Nachricht senden, wenn der Empfänger zum Empfang der Nachricht bereit ist. Im Gegensatz dazu ist die Nachrichtenübermittlung im Actor-Modell asynchron, d. h. das Senden und Empfangen von Nachrichten muss nicht gleichzeitig erfolgen und der Sender kann die Nachricht senden, bevor der Empfänger zum Empfang der Nachricht bereit ist.

2. Detaillierte Erläuterung des Go-Kanals
Das Definitionsformat des Kanaltyps ist wie folgt:

ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .

Es enthält die Definition von drei Typen. Das optionale <- gibt die Richtung des Kanals an. Wenn keine Richtung angegeben ist, ist der Kanal bidirektional und kann sowohl Daten empfangen als auch Daten senden.

chan T          // 可以接收和发送类型为 T 的数据
chan<- float64  // 只可以用来发送 float64 类型的数据
<-chan int      // 只可以用来接收 int 类型的数据

< - Immer zuerst mit dem Typ ganz links kombinieren. (Der <--Operator ordnet sich dem am weitesten links stehenden Kanal zu)

c := make(chan bool) //创建一个无缓冲的bool型Channel
c <- x        //向一个Channel发送一个值
<- c          //从一个Channel中接收一个值
x = <- c      //从Channel c接收一个值并将其存储到x中
x, ok = <- c  //从Channel接收一个值，如果channel关闭了或没有数据，那么ok将被置为false

Standardmäßig blockieren Sender und Empfänger des Kanals, bis die andere Partei zum Senden oder Empfangen bereit ist, wodurch die Go-Sprache ohne Sperren oder Sonstiges funktioniert Bedingungen unterstützen natürlich die Parallelität.
Verwenden Sie make, um den Kanal zu initialisieren, und Sie können die Kapazität festlegen:

make(chan int, 100) #//创建一个有缓冲的int型Channel

Kapazität (Kapazität) stellt die maximale Anzahl von Elementen dar, die der Kanal aufnehmen kann, und stellt die Größe des Caches des Kanals dar.
Wenn die Kapazität nicht festgelegt ist oder die Kapazität auf 0 eingestellt ist, bedeutet dies, dass der Kanal keinen Cache hat.
Sie können in mehreren Goroutinen Daten von/an einen Kanal empfangen/senden, ohne zusätzliche Synchronisierungsmaßnahmen in Betracht ziehen zu müssen.
Der Kanal kann als First-In-First-Out-Warteschlange (FIFO) verwendet werden und die Reihenfolge der empfangenen und gesendeten Daten ist konsistent.
Ein Kanal ohne Pufferung verfügt sowohl über Kommunikations- als auch über Synchronisationseigenschaften und ist in der gleichzeitigen Entwicklung sehr beliebt.

// _Channels_ are the pipes that connect concurrent
// goroutines. You can send values into channels from one
// goroutine and receive those values into another
// goroutine.

package main

import "fmt"

func main() {

    // Create a new channel with `make(chan val-type)`.
    // Channels are typed by the values they convey.
    messages := make(chan string)

    // _Send_ a value into a channel using the `channel <-`
    // syntax. Here we send `"ping"`  to the `messages`
    // channel we made above, from a new goroutine.
    go func() { messages <- "ping" }()

    // The `<-channel` syntax _receives_ a value from the
    // channel. Here we&#39;ll receive the `"ping"` message
    // we sent above and print it out.
    msg := <-messages
    fmt.Println(msg)
}

Hier erstellen wir einen ungepufferten String-Typ-Channel und übergeben dann „ping“ mit „channel<-“ in einer Goroutine an diesen Channel. <-Der Kanal empfängt diesen Wert und gibt ihn in der Hauptfunktion aus. Tatsächlich verwenden wir hier Channel, um die „Ping“-Nachricht stillschweigend von einer Goroutine an die Haupt-Goroutine zu übertragen und so die Kommunikation zwischen Threads (genauer gesagt zwischen Goroutinen) zu realisieren.
Da der Kanalsender und -empfänger blockiert, bis die andere Partei zum Senden oder Empfangen bereit ist, können wir auf die „Ping“-Nachricht am Ende des Programms warten, ohne dass weitere Synchronisierungsvorgänge erforderlich sind.
Sehen wir uns ein anderes Beispiel an: Nachdem die benutzerdefinierte Goroutine einen Vorgang abgeschlossen hat, erinnert sie die Haupt-Goroutine daran:

// We can use channels to synchronize execution// across goroutines. Here's an example of using a// blocking receive to wait for a goroutine to finish.package mainimport "fmt"import "time"// This is the function we'll run in a goroutine. The// `done` channel will be used to notify another// goroutine that this function's work is done.func worker(done chan bool) {
    fmt.Print("working...")
    time.Sleep(time.Second)
    fmt.Println("done")    // Send a value to notify that we're done.
    done <- true}func main() {    // Start a worker goroutine, giving it the channel to
    // notify on.
    done := make(chan bool, 1)    go worker(done)    // Block until we receive a notification from the
    // worker on the channel.
    <-done
}

                                      

Das CSP-Modell wird in der Go-Sprache für die Thread-Kommunikation verwendet Genau genommen handelt es sich um die Kommunikation zwischen leichtgewichtigen Thread-Goroutinen. Das CSP-Modell ähnelt dem Actor-Modell. Es besteht ebenfalls aus unabhängigen Einheiten, die gleichzeitig ausgeführt werden. Die Einheiten kommunizieren auch durch das Senden von Nachrichten. [Empfohlener Kurs:

Das obige ist der detaillierte Inhalt vonKanalbezogene Erklärungen in Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!