Le langage Go 3ème partie

1. Le langage Go 3ème partie Rob Pike r@google.com Traduction en français, adaptation xavier.mehaut @gmail.com (Version de Juin 2011)

2. Sommaire de la journée Exercices des questions? Concurrence et communication goroutines channels problématiques de la concurrence

3. Exercice Des questions? Pour un serveur HTTP trivial avec de multiples générateurs, voir http://golang.org/src/pkg/http/triv.go

4. Concurrence et communication :Les goroutines

5. Les goroutines Terminologie: Il existeplusierustermes pour “des choses qui fonctionnent de manièreconcurrente” – processus, tâche, coroutine, thread POSIX, thread NPTL, processusléger, … - maisleur signification à toutes estlégèrementdifférente. Aucune ne correspond exactement à comment Go traite la concurrence. Ainsinousalorsintroduire un nouveau terme : les goroutines

6. définition Unegoroutineestunefonctionouuneméthode Go s’exécutant de manièreconcurrentedans le mêmeespace d’adressageque les autresgoroutines. Un programme qui tourneconsistedonc en uneouplusieursgoroutines. Cen’est pas identique à un thread, coroutine, processus, …. C’estunegoroutine. NB : la concurrence te le parallélisme sont deux concepts différents.

7. Démarrer une goroutine Invoke a function or method and say go: funcIsReady(what string, minutes int64) { time.Sleep(minutes * 60*1e9) // Unités en nanosecs. fmt.Println(what, "est prêt") } go IsReady("thé", 6) go IsReady("café", 2) fmt.Println("J’attends...") afiche à l’écran: J’attends... (right away) Les café est prêt (2 minutes plus tard) Le théest prêt tea (6 minutes plus tard)

8. Quelques faits simples Goroutines ne coûtent pas grand chose. Goroutines exit by returning from their top-level function, or just falling off the end.. Goroutines ne peuvents’exécuter de manière concurrentequesur un seulprocesseur en partageant la mémoire. Vousn’avez pas à vousoccuper de la taille de la pile!

9. Les piles (stacks) En gccgo, au moinsjusqu’àprésent, les goroutinessont des pthreads. En 6g, cesont des threads multiplexés, qui sont ainsibien plus légers. Dans les deuxmondes, les piles sontpeites (quelqueskO) et croissentselon le besoin. Ainsi les goroutinesutilisentpeu de mémoire, vouspouvez en avoir de nombreuses, et elles peuventavoirdynamiquement des piles énormes en taille. Le programmeur ne devrait pas se préoccuper de la taille de la pile, c’est Go qui le fait à sa place.

10. L’ordonnancement des tâches (scheduling) Les Goroutinessontmultiplexées. Quandunegoroutineéxécute un appelsystèmebloquant, les autresgoroutines ne sont pas bloquées. Il y a des plans de faire de même pour les goroutinesliées au CPU à un certain degré, mais pour l’instant, sivousvoulez du parallélismeniveau utilisateur en 6g*, vousdevzinitialiser la variable shell GOMAXPROCSou appeler runtime.GOMAXPROCS(n). GOMAXPROCSindique au scheduler d’exécutioncombien de goroutiness’exécutantdansl’espaceutilisateur (userspace) peuvent tourner à la fois, idéallementsurdifférentscoeurs. *gccgoutilisetoujours un thread par goroutine.

11. Concurrence et communication:les canaux (channels)

12. Les channels en Go A moinsque two goroutines ne communiquent, elles ne peuvent se coordonner. Go possède un type spcifiqueappelé channel (canal) qui fournit des mécanismes de communication et de synchronisation. Il existeégalement des structures de contrôlespéciales qui sontbasées sur les channels pour rendre la programmationconcurrente plus simple. NB: J’aidonnéune conf en 2006 surcesujetmais en un autrelangage http://www.youtube.com/watch?v=HmxnCEa8Ctw

13. Le type channel Danssa plus simple forme, le type ressemble à ceci : chan elementType Avec unevaleur de ce type, vouspouvezenvoyer et recevoir des items de elementType. Les channels sont des types de référence, ce qui signifiequesivous affectezune variable chan à uneautre variable, les deux variables accèdent au même canal de communication. Cecisignifiequevous utilisez un makepour en allouer un. var c = make(chan int)

14. L’operateur de communication : <- La flèchepointedans la direction du flow de données. En tantqu’opérateurbinaire, <-envoie la valeurvers la droite du canal sur la gauche : c := make(chan int) c <- 1 // envoie 1 sur c Commeopérateurunaire , <-reçoit des données d’un canal (channel) : v = <-c // reçoitunevaleur de c, l’ affecte <-c // reçoitunevaleur, sans la stocker i := <-c // rçoitunevaleur, initialisei

15. Sémantique Par défaut, la communication estsynchrone (nous reparlerons des communications asynchrones plus tard) Ceci signifie donc: • Uneopération envoi sur un channel bloquel’exécutionjusqu’au moment où le récepteurest de nouveau disponiblesurce channel • Uneopération de réceptionestbloquéejusqu’au moment oùl’envoyeyrestdisponiblesurcemême channel La communication est par conséquentuneforme de synchronization : deuxgoroutineséchangent des données à travers un canal et synchronise de facto les deuxtâches au moment de la communication.

16. Injectons des données funcpump(ch chan int) { for i := 0; ; i++ { ch <- i } } ch1 := make(chan int) go pump(ch1) fmt.Println(<-ch1) // affiche 0 Maintenant nous démarronsune boucle de réception funcsuck(ch chan int) { for { fmt.Println(<-ch) } } go suck(ch1) // des tonnes de chiffresapparaissent

17. Fonctions retournant un channel Dansl’exempleprécédent, pump étaitcomme un génerateur de valeurs.Packageons la dansunefonctionretrournant un channel de valeurs . funcpump() chan int { ch:= make(chan int) go func() { for i := 0; ; i++ { ch <- i } }() return ch } stream := pump() fmt.Println(<-stream) // prints0 “unefonctionretournant un channel" est un idiome important.

18. Des fonctions channel partout J’évite de répéter des exemplesillustresquevouspouveztrouver partout. Ici un ensemble de liens intéressants : • Les nombres premiers; dans la spécification du langage et égalementdanscetutoriel • Un papier de Doug McIlroy: http://plan9.bell-labs.com/who/rsc/thread/squint.pdf Une version Go de ceprogrammefameuxestdisponible dans les suites de tests : http://golang.org/test/chan/powser1.go

19. Range et channels La clause rangedes boucles foracceptent les channels commeopérandes, dansquelcas le for boucle surtoutes la valeurs recues du channel. Nous pouvons réécrirel’exempleainsi: funcsuck(ch chan int) { go func() { for v := range ch { fmt.Println(v) } }() } suck(pump()) // ne bloque plus maintenant

20. Fermer un channel Comment est-ceque le rangesaitquand le channel arrêted’envoyer des données? L’émetteur envoie la commande native close: close(ch) Le récepteurtestesil’émetteur a fermé le canal en utilisant le "comma ok": val, ok := <-ch Le résultatest(value, true) tantqu’ilya des valeursdisponibles ; Unefoisque le canal estfermé et vidé, le résultatest(zero, false).

21. Range sur un channel à la main Un for range sur un channel telque : for value := range <-ch { use(value) } est équivalent à : for { value, ok := <-ch if !ok { break } use(value) }

22. Close Les point clefs: • Seulementl’émetteurdoitappeler close. • Seulement le récepteurpeut demander si un channel a étéfermé • Peutseulement demander tantqu’ilest en réception de valeurs (évite les courses). Appeler close seulementquandc’estnécessaire pour signaler au récepteurqu’aucuneautrevaleurn’arrivera . La plupart du temps, close n’est pas nécessaire ; cen’est pas analogue à la fermeture d’un fichier. Channelssont récupérés par le ramasse-miette quoiqu’il en soit.

23. Bidirectionnalité des channels Danssa plus simples expression, un channel est non bufferisé (synchronous) et peutêtreutilisé pour émettreourecevoirunedonnée. Un type channel peutêtreannoté pour spécifié qui’ilest en lecture ou en écritureseule : var recvOnly <-chan int var sendOnly chan<- int

24. Bidirectionnalité des channels (2) Tous les channels sontcréésbidirectionnels, mais nous pouvons les affecter à des variables unidirectionnelles. Utile par exempledans les fonctions pour la sûreté de fonctionnement: funcsink(ch <-chan int) { for { <-ch } } func source(ch chan<- int) { for { ch <- 1 } } c := make(chan int) // bidirectionnel go source(c) go sink(c)

25. Channels synchrones Les channels synchronessont non bufferisés. L’envoi ne s’effectue pas tant quer le récepteurn’a pas accepté la valeurémise. c := make(chan int) go func() { time.Sleep(60*1e9) x := <-c fmt.Println("reçu", x) }() fmt.Println("en train d’émettre", 10) c <- 10 fmt.Println("envoyé", 10) sortie: en train d’émettre 10 (arrive immédiatement) envoyé 10 (60s plus tard, cesdeuxlignesapparaissent) reçu 10

26. Channels asynchrones Un channel bufferisé et asynchroneestcréé en indiquant à make le nombre d’élémentsdans le buffer (tampon . c := make(chan int, 50) go func() { time.Sleep(60*1e9) x := <-c fmt.Println("reçu", x) }() fmt.Println("en train d’émettre", 10) c <- 10 fmt.Println("envoyé", 10) Output: en train d’émettre 10 (arrive immédiatement) envoyé 10 (maintenant) reçu 10 (60s plus tard)

27. Le buffer ne fait pas partie du type Notezque la taille du buffer, oumêm son existence, ne fait pas partie du type du channel, seulement de la valeur concrète. Ce code est par conséquentlégal, quoiquedangereux : buf = make(chan int, 1) unbuf = make(chan int) buf = unbuf unbuf = buf Mettre en tampon estunepropriété de la valeur, pas du type de la valeur.

28. Select Selectestune structure de contrôle en Go analogue à l’instruction switch . Chaquecasdoit former une communication, soitrecevoir, soitémettreunedonnée. ci, cs := make(chanint), make(chan string) select { case v := <-ci: fmt.Printf("received %d from ci\n", v) case v := <-cs: fmt.Printf("received %s from cs\n", v) } Selectexécute un des branchements au hasard. Si aucuncasn’est exécutable, ilbloquel’exécutionjusqu’àcequ’uncasvalablesoitdéclenché. Une clause defaultesttoujours executable .

29. Sémantique du Select Rapide résumé: • Chaquecasdoitreprésenterune communication • Tous les branchements du select sontexécutés • Toutes les expressions à envoyersontévaluées • Si une communication peutêtreentreprise, ellel’est; sinonelleestignorée • Si de multiples cas son possibles, uneestsélectionnée au hasard. Les autre ne s’exécutent pas. • Autrement: • S’ilexisteune clause default, elles’exécute • S’iln’y a pas de default, le select bloquejusqu’àcequ’une communication soitdémarrée. Il n’y a pas réévaluation des channels ou des valeurs.

30. Un générateur de bits aléatoire Idiot mais illustratif : c := make(chan int) go func() { for { fmt.Println(<-c) } }() for { select { case c <- 0: //pas d’instruction, pas d’échappement case c <- 1: } } affiche 0 1 1 0 0 1 1 1 0 1 ...

31. Tester la communication Est-cequ’une communication peuts’effectuer sans blocage? Selectavec un defaultpeut nous le dire: select { case v := <-ch: fmt.Println("reçu", v) default: fmt.Println("chn’est pas prêt à recevoir") } La clause par défauts’executesiaucunautrecas ne convient, ainsic’est l’idiomepouuneréception non bloquante ; un envoi non bloquantest unevarianteévidente;

32. Timeout Est-cequ’une communication peutêtre un succès après un interval de temps donné? Le package time contient la fonctionAfter pour cela: func After(ns int64) <-chanint64 Il rencoieunevaleur (le temps courant) sur le channel retourné après un temps spécifié.. L’utiliserdansselect pour implémenter le timeout: select { case v := <-ch: fmt.Println("reçu", v) case <-time.After(30*1e9): fmt.Println("timed out après 30 secondes") }

33. Multiplexing Les channels sont des valeurs de première classe, ce qui signifiequ’elles peuventelles-mêmeêtreenvoyéessur des channels commetouteautrevaleur. Cettepropriété rend très simple l’écriture d’un multiplexeurpuisque le client peutfournir, à côté de sarequête, le channel surlequelrépondre. chanOfChans:= make(chan chanint) Ou plus typiquement type Replystruct { ... } type Requeststruct { arg1, arg2 someType replycchan *Reply }

34. Serveur de multiplexage type requeststruct { a, b int replycchan int } Type binOpfunc(a, b int) int funcrun(op binOp, req *request) { req.replyc<- op(req.a, req.b) } func server(op binOp, service <-chan *request) { for { req:= <-service // les requêtesarriventici go run(op, req) // n’attend pas op } }

35. Démarrer le serveur Utiliserune “fonctionretrournant un channel” pour créer un channel vers un nouveau serveur. funcstartServer(op binOp) chan<- *request { service := make(chan *request) go server(op, req) return service } adderChan := startServer( func(a, b int) int { return a + b } )

36. Le client Un exemplesimilaireestexpliqué plus en détaildans le tutoriel, maisil y a unevariante : func (r *request) String() string { return fmt.Sprintf("%d+%d=%d", r.a, r.b, <-r.replyc) } req1 := &request{7, 8, make(chanint)} req2 := &request{17, 18, make(chanint)} Les requêtessontprêtes ; on les envoie adderChan <- req1 adderChan <- req2 On peutrécupérer les résultatsdansn’importequelordre ; r.replycdemuxes: fmt.Println(req2, req1)

37. Démontage Dansl’exemplemultiplexé, le serveurtourne à jamais. Pour l’éteindreproprement, ilfautnotifier le channel. Ceserveurpossède la mêmefonctionnalitémais avec un channel. func server(op binOp, service <-chan *request, quit<-chan bool) { for { select { case req := <-service: go run(op, req) // don't wait for it case <-quit: return } } }

38. Démarrer le serveur Le reste du code estquasiment le même, avec un channel supplémentaire: funcstartServer(op binOp) (service chan<- *request, quitchan<- bool) { service = make(chan *request) quit= make(chan bool) go server(op, service, quit) return service, quit } adderChan, quitChan := startServer( func(a, b int) int { return a + b } )

39. Arrêter le client Le client n’est pas affectéjusqu’àcequ’ilsoità arrêter le serveur: req1 := &request{7, 8, make(chanint)} req2 := &request{17, 18, make(chanint)} adderChan <- req1 adderChan <- req2 fmt.Println(req2, req1) Tout est accompli, on signale au serveur de sortir : quitChan<- true

40. Chaînage package main import ("flag"; "fmt") varnGoroutine = flag.Int("n", 100000, “combien") func f(left, right chanint) { left <- 1 + <-right } func main() { flag.Parse() leftmost:= make(chan int) varleft, right chanint = nil, leftmost for i := 0; i < *nGoroutine; i++ { left, right = right, make(chanint) go f(left, right) } right <- 0 // bang! x := <-leftmost // attend la terminaison fmt.Println(x) // 100000 }

41. Exemple : channel comme cache de buffer varfreeList = make(chan *Buffer, 100) var serverChan = make(chan *Buffer) func server() { for { b := <-serverChan // attend qque chose à faire process(b) // Met la requêtedans le buffer select { case freeList <- b: // reutilise le buffer si place default: // autrement ne fait rien. } } } func client() { for { var b *Buffer select { case b = <-freeList: // en prend un sidisponible default: b = new(Buffer) // allouesi pas } load(b) // lit la prochainerequêtedans b serverChan<- b // envoieunerequêtevers le serveur } }

42. Concurrence

43. Problématiques de la concurrence Beaucoup biensûr, mais Go essaye de prendre soind’elles. Les opérationsd’envoi et de réception sont en Go atomiques. L’instruction Select est définie de manièretrèsprécise et bin emplémentée, … Mais les goroutiness’exécutentdans un espacepartagé, le réseau de communication peuttrèsbienêtredans un état d’étreinte fatale, les débuggers multi-threadés ne sont pas encore au point, etc… Que faire alors?

44. Go vous donne des primitives Ne programmez pas de la mêmefaçonque vous programmeriez en c, C++ et même java. Les channels vous offre et la synchronisation et la communication, et cela rend la programmation très puissante et rigoureuse si vous savez bien les utiliser. La règle est la suivante: • Ne communiquez pas par mémoirepartagée • A la place, partagez la mémoire en communiquant! L’acte de communiquergarantit la synchronization!

45. Le modèle Par exemple, utiliser un channel pour envoyer des données à unegoroutineserveurdédiée. Si seulementunegoroutine à la foispossède un pointeurvers les données, iln’y a pas de problématiques de concurrence. C’est le modèle que nous prônons pour programmer des serveurs, au moins. C’est la bonne vieille approche « une tâche thread par client » , généralisée – et en utilisation depuis les années 80. Et ca marche très bien. Ma conf précédente (mentionnée auparavant)décline cette idée plus en profondeur.

46. Le modèle mémoire Les détails qui tuent au sujet de la synchronisation et de la mémoirepartagée sontdécritsici : http://golang.org/doc/go_mem.html Maisvousaurezrarementbesoin de les comprendresivoussuiveznotreapproche.