Explications relatives aux chaînes en langage Go

Le modèle CSP est utilisé dans le langage Go pour la communication des threads. Pour être précis, il s'agit d'une communication entre des goroutines de threads légers. Le modèle CSP est similaire au modèle Actor. Il est également composé d'entités indépendantes qui s'exécutent simultanément. Les entités communiquent également en envoyant des messages.

1. La différence entre le modèle d'acteur et le modèle CSP :

Les acteurs communiquent directement, tandis que CSP communique via Channel. sont les mêmes. Il y a une différence, ces derniers sont plus faiblement couplés.
La principale différence est que dans le modèle CSP, l'expéditeur et le destinataire du message sont faiblement couplés via Channel. L'expéditeur ne sait pas quel destinataire a consommé le message, et le destinataire ne sait pas quel expéditeur a envoyé le message. . Dans le modèle Acteur, puisque l'Acteur peut choisir quel message entrant traiter en fonction de son propre état, l'autonomie et la contrôlabilité sont meilleures.
Afin de ne pas bloquer le processus en langage Go, les programmeurs doivent vérifier les différents messages entrants afin de prévoir et s'assurer du bon ordre. L'avantage de CSP est que Channel n'a pas besoin de mettre les messages en mémoire tampon, tandis qu'Actor a théoriquement besoin d'une boîte aux lettres de taille illimitée comme tampon de messages.
L'expéditeur du message du modèle CSP ne peut envoyer un message que lorsque le destinataire est prêt à recevoir le message. En revanche, la transmission des messages dans le modèle Actor est asynchrone, c'est-à-dire que l'envoi et la réception des messages n'ont pas besoin de se produire en même temps, et l'expéditeur peut envoyer le message avant que le destinataire ne soit prêt à le recevoir.

2. Explication détaillée de Go Channel
Le format de définition du type de chaîne est le suivant :

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

Il comprend trois types de définitions. Le <- facultatif représente la direction du canal. Si aucune direction n'est spécifiée, le canal est bidirectionnel et peut à la fois recevoir et envoyer des données.

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

< - Combinez toujours avec le type le plus à gauche en premier. (L'opérateur <- s'associe au canal le plus à gauche possible)

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

Par défaut, l'émetteur et le récepteur du canal se bloqueront jusqu'à ce que l'autre partie soit prête à envoyer ou à recevoir, ce qui rend le langage Go inutile. Verrous ou d'autres conditions soutiennent naturellement la concurrence.
Utilisez make pour initialiser le canal, et vous pouvez définir la capacité :

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

Capacité (capacité) représente le nombre maximum d'éléments que le canal peut accueillir et représente la taille du cache du canal .
Si la capacité n'est pas définie, ou si la capacité est définie sur 0, cela signifie que le canal n'a pas de cache.
Vous pouvez recevoir/envoyer des données depuis/vers un canal dans plusieurs goroutines sans avoir à envisager des mesures de synchronisation supplémentaires.
Le canal peut être utilisé comme une file d'attente premier entré, premier sorti (FIFO), et l'ordre des données reçues et des données envoyées est cohérent.
Le canal sans mise en mémoire tampon possède à la fois des caractéristiques de communication et de synchronisation et est très populaire dans le développement simultané.

// _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)
}

Ici, nous créons un canal de type chaîne sans tampon, puis transmettons "ping" à ce canal en utilisant canal<- dans une goroutine. <-Le canal reçoit cette valeur et l'imprime dans la fonction principale. En fait, nous utilisons ici Channel pour transférer tranquillement le message "ping" d'une goroutine vers la goroutine principale, réalisant ainsi la communication entre les threads (pour être précis, entre les goroutines).
Étant donné que l'émetteur et le récepteur du canal se bloqueront jusqu'à ce que l'autre partie soit prête à envoyer ou à recevoir, cela nous permet d'attendre le message "ping" à la fin du programme sans avoir besoin d'autres opérations de synchronisation.
Regardons un autre exemple : une fois que la goroutine définie par l'utilisateur a terminé une opération, elle rappelle la goroutine principale :

// 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
}

                                                                                              🎜>

Le modèle CSP est utilisé dans le langage Go pour la communication par fil de discussion. . Pour être précis, il s'agit d'une communication entre des goroutines de threads légers. Le modèle CSP est similaire au modèle Actor. Il est également composé d'entités indépendantes qui s'exécutent simultanément. Les entités communiquent également en envoyant des messages. [Cours recommandé :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!