Parlons de la façon d'utiliser les chaînes en langage Go

Le canal en langage Go est un type de données spécial qui peut être utilisé pour transférer des données entre différents processus Go. Il est similaire à un canal qui permet à différentes goroutines d'échanger des informations à travers lui. Dans cet article, nous présenterons l'utilisation des chaînes en langage Go.

Créer une chaîne

En langage Go, vous pouvez utiliser la fonction make pour créer une chaîne. La syntaxe de la fonction make est la suivante :

make(chan data_type, buffer_size)

Parmi eux, data_type est le type de données à transmettre dans le canal, et buffer_size indique la taille du tampon du canal. Si la taille du tampon n'est pas spécifiée, cela signifie que le. le canal n’est pas tamponné.

Par exemple, dans le code suivant, un canal sans tampon est créé :

ch := make(chan int)

Ici, un canal est créé pour passer un type entier. Les canaux sans tampon peuvent être utilisés pour des opérations synchrones, telles que le blocage et l'attente entre deux goroutines.

Ce qui suit est un exemple de création d'un canal tamponné :

ch := make(chan string, 10)

Ici, un canal est créé pour transmettre un type de chaîne et la taille du tampon est définie sur 10. Les canaux tampons peuvent être utilisés pour les opérations asynchrones, ce qui signifie que les opérations d'envoi et de réception ne bloquent pas l'exécution du programme.

Envoi et réception de données

En langage Go, vous pouvez utiliser l'opérateur flèche (<-) du canal pour envoyer et recevoir des données. Les flèches pointant dans la direction du canal indiquent la direction du flux de données.

Par exemple, le code suivant envoie un entier à un canal :

ch := make(chan int)
ch <- 123

Ici, l'entier 123 est envoyé au canal ch à l'aide de l'opérateur flèche (<-).

Le code suivant reçoit un entier d'un canal :

ch := make(chan int)
x := <- ch

Ici, un entier est reçu du canal ch en utilisant l'opérateur flèche (<-). Ici, x est une variable entière utilisée pour stocker la valeur reçue du canal.

Blocage et attente

Dans un canal sans tampon, les opérations d'envoi et de réception provoqueront un blocage. Par exemple, si une goroutine envoie des données à un canal sans tampon, mais qu'aucune autre goroutine n'attend de recevoir des données, l'opération d'envoi sera bloquée jusqu'à ce qu'une autre goroutine commence à attendre de recevoir des données.

De même, si une goroutine reçoit des données d'un canal sans tampon, mais qu'aucune autre goroutine n'attend d'envoyer des données, l'opération de réception sera bloquée jusqu'à ce que d'autres goroutines commencent à envoyer des données.

Lorsque le tampon est de taille limitée, l'opération d'envoi peut également se bloquer. Si le tampon est plein, l'opération d'envoi attendra que d'autres Goroutines lisent les données du canal.

Par exemple, le code suivant montre comment créer un canal sans tampon et laisser deux processus Gor échanger des données via le canal :

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

  go func() {
    x := 1 + 1
    ch <- x
  }()

  y := <-ch

  fmt.Println(y)
}

Ici, un canal sans tampon ch est créé, puis un nouveau processus Go est démarré Processus, utilisé pour envoyer la valeur 2 au canal ch. À ce moment, l'opération de réception se bloquera jusqu'à ce que le nouveau processus Gor envoie la valeur 2, et imprimera enfin la valeur reçue sur la console.

Fermer la chaîne

En langage Go, vous pouvez utiliser la fonction intégrée de fermeture pour fermer une chaîne. Après la fermeture du canal, toutes les données non lues peuvent être supprimées, tandis que les données lues sont toujours accessibles.

La fermeture du canal permet au récepteur de savoir qu'aucune donnée ne sera envoyée, ce qui permet au récepteur de sortir de la boucle normalement et de terminer le programme.

Par exemple, l'exemple de code suivant montre comment terminer le programme en fermant le canal :

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

  go func() {
    for i := 0; i < 5; i++ {
      ch <- i
    }
    close(ch)
  }()

  for v := range ch {
    fmt.Println(v)
  }
}

Ici, un canal ch sans tampon est créé et une nouvelle goroutine est démarrée pour envoyer des valeurs entières au canal ch. Une fois que toutes les valeurs entières ont été envoyées, le canal ch est fermé. Ensuite, utilisez une boucle for pour parcourir toutes les valeurs du canal ch et imprimer sur la console.

Résumé

Dans le langage Go, le canal est un outil puissant qui peut être utilisé pour mettre en œuvre la communication de données entre différents processus Go. Vous pouvez utiliser des canaux pour envoyer et recevoir des données, et utiliser l'opérateur fléché (<-) pour identifier le flux de données. Vous pouvez créer des canaux sans tampon ou avec tampon et échanger des données entre goroutines. En fermant le canal, le récepteur sait qu'aucune donnée n'est plus envoyée et arrête l'exécution du programme.

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!