« Programmation en Go/Goroutines » : différence entre les versions

Un livre de Wikilivres.
Contenu supprimé Contenu ajouté
Ligne 70 : Ligne 70 :
Le choix entre les différentes alternatives est basé sur un processus pseudo-aléatoire.
Le choix entre les différentes alternatives est basé sur un processus pseudo-aléatoire.


=== Définir le nombre de processeurs ===
== Définir le nombre de processeurs ==


En définissant la variable d'environnement GOMAXPROCS comme étant égale au moins au nombre de processeurs, ou en appelant runtime.GOMAXPROCS() avec ce nombre, on peut répartir les gorutines sur les différents coeurs ou processeurs sur un ordinateur particulier.
En définissant la variable d'environnement GOMAXPROCS comme étant égale au moins au nombre de processeurs, ou en appelant runtime.GOMAXPROCS() avec ce nombre, on peut répartir les gorutines sur les différents coeurs ou processeurs sur un ordinateur particulier.

Version du 18 novembre 2010 à 17:25

Définition

Une goroutine est un fil d'éxécution tournant en parallèle avec d'autres goroutines à l'intérieur du même espace d'adressage (le processus).

Les goroutines permettent de paralléliser des tâches en les répartissant sur plusieurs coeurs ou processeurs. Le mot clé go permet de lancer un appel de fonction en une goroutine, et de ne pas attendre le résultat:

go list.Sort() // trie une liste en parallèle

Il est courant d'utiliser une fonction littérale pour appeler une goroutine.

Les canaux (de communication)

Un canal est un type de base de Go, et se déclare en plaçant chan avant le type de ses éléments. On peut créer un canal avec make:

c := make(chan int)

Ensuite on peut comme avec une file FIFO, enfiler ou dépiler un élément avec l'opérateur <-. Dans cet exemple, on lance une goroutine et on attend sa fin en recevant le signal qu'elle va envoyer:

go func() {
   list.Sort()
   c <- 1  // Envoie un signal, la valeur importe peu
}()
blahBlahPendantUnMoment()
<-c   // Attend la fin du tri de la liste à la réception du signal

Canaux avec tampon

On peut créer un canal avec un tampon en fournissant la taille du tampon en argument de make().

Lorsque le canal n'a pas de tampon, la goroutine qui enfile une valeur doit attendre qu'une autre goroutine dépile cette valeur. En revanche, avec un tampon, la goroutine qui enfile une donnée attend seulement que le tampon dispose d'une case vide pour y mettre la donnée.

Dans l'exemple suivant, MaxTaches tâches peuvent se dérouler en parallèle:

var sem = make(chan int, MaxTaches)
func handle(r *Requete) {
   sem <- 1    // attend que sem soit disponible
   process(r)  // cela peut prendre un certain temps.
   <-sem       // cela permet à la prochaine tâche de démarrer
}

func Serve(file chan *Requete) {
   for {
       requete := <-file
       go handle(requete)  // lance la goroutine
   }
}

La syntaxe suivante permet de savoir si une case est disponible dans le canal:

v,ok = <- canal

Select

Select est une structure de contrôle similaire à switch. Elle permet de gérer une multitude d'envois et de réceptions à travers des canaux différents. Voici sa syntaxe:

select {
case canal <- var: commandes...
case var = <-canal: ...
case var := <-canal: ...
default: ...
}

Les différentes alternatives sont évaluées dans l'ordre de leur écriture, la première réception ou émission dans un canal déclenche l'exécution des commandes correspondant à l'alternative. Si aucune de ces opérations ne réussit, le cas par défaut est exécuté, sinon l'opération bloque jusqu'à la réception ou l'envoi d'une donnée.

Le choix entre les différentes alternatives est basé sur un processus pseudo-aléatoire.

Définir le nombre de processeurs

En définissant la variable d'environnement GOMAXPROCS comme étant égale au moins au nombre de processeurs, ou en appelant runtime.GOMAXPROCS() avec ce nombre, on peut répartir les gorutines sur les différents coeurs ou processeurs sur un ordinateur particulier.