Communication de canal en Golang avec des travailleurs

Introduction

En Golang, la fermeture d'un canal peut être utilisée pour communiquer la fin à des récepteurs de canal. Dans ce laboratoire, nous allons démontrer comment utiliser un canal pour communiquer des travaux à effectuer du goroutine main() à une goroutine de travail, et comment fermer le canal lorsqu'il n'y a plus de tâches pour le travailleur.

Skills Graph

Fermeture des canaux

Dans ce laboratoire, vous devez modifier le code fourni pour fermer le canal jobs lorsqu'il n'y a plus de tâches pour le travailleur. Vous devez également utiliser le canal done pour être informé lorsque toutes les tâches ont été terminées.

• Utilisez un canal tamponné jobs pour communiquer les travaux à effectuer du goroutine main() à une goroutine de travail.
• Utilisez un canal done pour être informé lorsque toutes les tâches ont été terminées.
• Utilisez une goroutine de travail pour recevoir répétitivement de jobs avec j, more := <-jobs.
• Utilisez la forme à 2 valeurs spéciale de la réception pour être informé sur done lorsque toutes les tâches ont été terminées.
• Envoyez 3 tâches au travailleur via le canal jobs, puis fermez-le.
• Utilisez l'approche de synchronisation pour attendre le travailleur.

$ go run closing-channels.go
sent job 1
received job 1
sent job 2
received job 2
sent job 3
received job 3
sent all jobs
received all jobs

## L'idée des canaux fermés conduit naturellement à notre prochain
## exemple : `range` sur des canaux.

Voici le code complet ci-dessous :

// _Fermer_ un canal indique qu'aucune valeur supplémentaire
// ne sera envoyée dessus. Cela peut être utile pour communiquer
// la fin aux récepteurs du canal.

package main

import "fmt"

// Dans cet exemple, nous utiliserons un canal `jobs` pour
// communiquer les travaux à effectuer du goroutine `main()`
// à une goroutine de travail. Lorsque nous n'avons plus de tâches
// pour le travailleur, nous allons `fermer` le canal `jobs`.
func main() {
	jobs := make(chan int, 5)
	done := make(chan bool)

	// Voici la goroutine de travail. Elle reçoit répétitivement
	// de `jobs` avec `j, more := <-jobs`. Dans cette
	// forme spéciale à 2 valeurs de la réception, la valeur
	// `more` sera `false` si `jobs` a été `fermé` et toutes
	// les valeurs du canal ont déjà été reçues.
	// Nous utilisons cela pour être informé sur `done` lorsque
	// nous avons terminé toutes nos tâches.
	go func() {
		for {
			j, more := <-jobs
			if more {
				fmt.Println("received job", j)
			} else {
				fmt.Println("received all jobs")
				done <- true
				return
			}
		}
	}()

	// Cela envoie 3 tâches au travailleur via le canal `jobs`,
	// puis le ferme.
	for j := 1; j <= 3; j++ {
		jobs <- j
		fmt.Println("sent job", j)
	}
	close(jobs)
	fmt.Println("sent all jobs")

	// Nous attendons le travailleur en utilisant l'approche
	// de [synchronisation](channel-synchronization) que nous
	// avons vue précédemment.
	<-done
}

Résumé

Dans ce laboratoire, vous avez appris à utiliser un canal pour communiquer les travaux à effectuer du goroutine main() à une goroutine de travail, et à fermer le canal lorsqu'il n'y a plus de tâches pour le travailleur. Vous avez également appris à utiliser le canal done pour être informé lorsque toutes les tâches ont été terminées.