Want to dive even deeper?

Take the course PHP Development with Laravel 4 by Stone River and become an expert!
PHP Development with Laravel 4
by Stone River

Check it out!
You're watching a preview of this video, click the button on the left to puchase the full version from Atomikos ExtremeTransactions Certification.

Modèles de concurrence en GO

La concurrence est un facteur clé pour le design de services sur le réseau à haute performance. Les primitives Go pour la concurrence, goroutines et channels (canaux), offrent un moyen pour l'exprimer d'une façon simple et efficace. Pendant cette session nous verrons comment des problèmes complexes peuvent être résolus gracieusement avec du code Go simple

Published on
  • 870
  • 0
  • 0
  • 1
  • 0
  • Modèles de concurrence en Go Francesc Campoy Flores Google Mountain View
  • La concurrence en Go Les gens étaient fascinés par les fonctionnalités de concurrence proposées par Go quand la première version a été annoncée. Questions: Pourquoi supporte-on la concurrence? Mais, c'est quoi la concurrence? D'où vient cette idée? À quoi ça sert? Comment l'utiliser?
  • Pourquoi? Regardez autour de vous. Qu'est-ce que vous y voyez? Est-ce que vous voyez un monde ou seulement une chose change à la fois? Ou est-ce que vous voyez un monde complexe avec beaucoup de pièces indépendantes en interaction? Le traitement de données de manière séquentielle ne modélise pas de manière satisfaisante le comportement de notre monde.
  • C'est quoi la concurrence? La concurrence est la composition de calculs à exécution indépendante. La concurrence est une façon de structurer un logiciel, en particulier c'est une façon d'écrire du code propre qui interagit correctement avec le monde réel. Ce n'est pas du parallélisme!
  • La concurrence n'est pas du parallélisme La concurrence n'est pas du parallélisme, même si elle le rend plus facile. Si on a seulement un processeur, le programme peut être concurrent mais il ne peut pas être parallèle. Un programme concurrent bien écrit peut être exécuté de façon efficace en parallèle sur un processeur multi-coeur. Cette qualité peut être d'une certaine importance ... Pour plus de différences, allez sur le lien en dessous. golang.org/s/concurrency-is-not-parallelism (http://golang.org/s/concurrency-is-not-parallelism)
  • Un modèle pour la construction du logiciel Facile à comprendre. Facile à utiliser. Facile pour raisonner. On n'a pas besoin d'être des experts! (Beaucoup plus agréable que de gérer les détails du parallélisme (threads, semaphores, locks, barrières, etc.))
  • Histoire Pour beaucoup, les fonctionnalités pour la concurrence en Go semblaient nouvelles. Mais elles viennent d'une longue histoire, datant du papier sur les CSP par Hoare en 1978, ou même du langage de commandes de Dijkstra en 1975. D'autres langages ont des fonctionnalités similaires: Occam (May, 1983) Erlang (Armstrong, 1986) Newsqueak (Pike, 1988) Concurrent ML (Reppy, 1993) Alef (Winterbottom, 1995) Limbo (Dorward, Pike, Winterbottom, 1996).
  • Distinction Go est le cadet dans la branche Newsqueak-Alef-Limbo, qui se caractérise par des canaux en tant que des éléments de première classe. Erlang ressemble plus aux CSP originaux, où on communique avec processus par nom plutôt que sur un channel. Les modèles sont équivalents mais expriment des choses différentes. Une analogie: écrire sur un fichier par nom (processus, Erlang) vs. écrire sur un file descriptor (channel, Go).
  • Exemples basiques
  • Une fonction ennuyeuse On a besoin d'un exemple qui montre des propriétés intéressantes des primitives pour la concurrence. Pour éviter des distractions, on crée une fonction ennuyeuse. fn enyu(s srn){ uc nuexmg tig fri: 0 ;i+{ o = ; + ftPitnmg i m.rnl(s, ) tm.le(ieScn) ieSeptm.eod } } Run
  • Un peu moins ennuyeux Rendons les périodes de temps entre messages imprévisibles (en dessous d'une seconde). fn enyu(s srn){ uc nuexmg tig fri: 0 ;i+{ o = ; + ftPitnmg i m.rnl(s, ) tm.le(ieDrto(adIt(e) *tm.ilscn) ieSeptm.uainrn.nn13) ieMlieod } } Run
  • Un peu moins ennuyeux Rendons les périodes de temps entre messages imprévisibles (en dessous d'une seconde). fn enyu(s srn){ uc nuexmg tig fri: 0 ;i+{ o = ; + ftPitnmg i m.rnl(s, ) tm.le(ieDrto(adIt(e) *tm.ilscn) ieSeptm.uainrn.nn13) ieMlieod } } Run
  • Exécutons! Une fonction ennuyeuse, tel un bon invité ennuyeux, ne finit jamais. fn mi( { uc an) enyu(enyu!) nuex"nuex" } fn enyu(s srn){ uc nuexmg tig fri: 0 ;i+{ o = ; + ftPitnmg i m.rnl(s, ) tm.le(ieDrto(adIt(e) *tm.ilscn) ieSeptm.uainrn.nn13) ieMlieod } } Run
  • On peut l'ignorer Le mot clé go exécute la fonction comme d'habitude, mais sans attendre le retour de l'appel. On crée une nouvelle goroutine. Cette fonctionnalité est similaire au &à la fin d'une commande shell. pcaemi akg an ipr ( mot "m" ft "ahrn" mt/ad "ie tm" ) fn mi( { uc an) g enyu(enyu!) o nuex"nuex" } Run
  • Ou on peut l'ignorer un peu moins Quand main finit, le programme finit aussi et cause la fin de la fonction ennuyeuse en même temps. On peut attendre un peu, et en même temps montrer que la fonction m i et an e n y u s'exécute en même temps. nuex fn mi( { uc an) g enyu(enyu!) o nuex"nuex" ftPitn"etéot.) m.rnl(J 'cue" tm.le( *tm.eod ieSep2 ieScn) ftPitn"uetenyu,j me vi!) m.rnl(T s nuex e 'n as" } Run
  • Goroutines C'est quoi une goroutine? C'est une fonction qui s'exécute indépendamment, crée par une instruction g . o Les goroutines ont leur propre pile (stack), qui grandit et rétrécit en fonction des besoins. Elles ne sont pas chères. On peut en avoir des milliers, même des centaines de milliers! Ce ne sont pas des threads. On peut avoir juste un thread pour des milliers de goroutines. Les goroutines sont multiplexées dynamiquement sur des threads de façon à les avoir toutes en exécution. Mais si tu penses aux goroutines en tant que des threads pas chers, t'es vraiment pas loin.
  • Communication On a un peu triché avec les exemples précédents: la fonction main ne pouvait pas voir l'output de l'autre goroutine. L'autre goroutine imprimait sur l'écran, et on faisait semblant d'avoir une conversation. Les vraies conversations ont besoin de communication.
  • Channels (canaux) Les channels en Go offrent une connexion entre deux goroutines, et leur permettent de communiquer. / Dcaaine iiilsto. / élrto t ntaiain vrcca it a hn n c=mk(hnit aeca n) / o / u c: mk(hnit = aeca n) / Eviduevlu sru canl / no 'n aer u n hne. c< 1 / Rcpinduevlu du canl / éeto 'n aer 'n hne. / L "lce mnr l drcind fu d dnés / a fèh" ote a ieto u lx e one. vle=<c au -
  • Utilisation des channels Un channel connecte les goroutine main et ennuyeux pour qu'elles communiquent. fn mi( { uc an) c: mk(hnsrn) = aeca tig g enyu(enyu!,c o nuex"nuex" ) fri: 0 i<5 i+{ o = ; ; + / Lepeso d rcpinetuevlu. / 'xrsin e éeto s n aer ftPit(T ds %\" <c m.rnf"u i: qn, -) } ftPitn"'senyu,j me vi!) m.rnl(Te nuex e 'n as" } Run fn enyu(s srn,cca srn){ uc nuexmg tig hn tig fri: 0 ;i+{ o = ; + / O pu evyrnipreqel epeso d bntp. / n et noe 'mot ule xrsin u o ye c< ftSrnf"s%" mg i - m.pit(% d, s, ) tm.le(ieDrto(adIt(e) *tm.ilscn) ieSeptm.uainrn.nn13) ieMlieod } }
  • Synchronisation Quand la fonction main exécute < celle attend qu'une valeur soit envoyée. -, D'une façon similaire, quand la fonction e n y u exécute c - a u , elle nuex <vle attend jusqu'à ce que quelqu'un soit prêt à récevoir la valeur de l'autre coté. Le récepteur et l'émetteur doivent être prêts à jouer leur part dans la communication. Autrement on attend jusqu'à ce qu'ils le soient. En conséquence, les channels communiquent et synchronisent.
  • Buffered channels (canaux à tampon mémoire) Note pour les experts: Les channels Go peuvent aussi être crées avec un tampon mémoire. Ceci enlève la synchronisation. Les buffered channels sont très similaires aux mailboxes d'Erlang. Les buffered channels peuvent être importants pour quelques problèmes mais le raisonnement est plus subtil. On n'aura pas besoin d'eux aujourd'hui.
  • L'approche Go "Don't communicate by sharing memory, share memory by communicating." "Ne communique pas en partageant de la mémoire, partage de la mémoire en communiquant."
  • Modèles
  • Générateur: une fonction qui retourne un channel Les channels sont des valeurs à part entière, tels que les strings ou les entiers. c: enyu(enyu!)/ Fnto qirtun u canl = nuex"nuex" / ocin u eore n hne. fri: 0 i<5 i+{ o = ; ; + ftPit(Yusy %\" <c m.rnf"o a: qn, -) } ftPitn"'senyu,j me vi!) m.rnl(Te nuex e 'n as" fn enyu(s srn)<ca srn {/ Rtun u canle lcuesue uc nuexmg tig -hn tig / eore n hne n etr el. c: mk(hnsrn) = aeca tig g fn( {/ O lnel gruiedpi l fnto. o uc) / n ac a ootn eus a ocin fri: 0 ;i+{ o = ; + c< ftSrnf"s%" mg i - m.pit(% d, s, ) tm.le(ieDrto(adIt(e) *tm.ilscn) ieSeptm.uainrn.nn13) ieMlieod } }) ( rtr c/ Rtun l canlàcliqiaaplél fnto. eun / eore e hne eu u pel a ocin } Run
  • Les channels en tant que point d'accès à un service Notre fonction ennuyeuse retourne un channel qui nous permet de communiquer avec l'ennuyeux service qu'elle offre. Nous pouvons avoir plus d'une instance du service. fn mi( { uc an) je: enyu(Je) o = nuex"o" an: enyu(An) n = nuex"n" fri: 0 i<5 i+{ o = ; ; + ftPitn<je m.rnl(-o) ftPitn<an m.rnl(-n) } ftPitn"osêe tu lsdu enyus j me vi!) m.rnl(Vu ts os e ex nuex, e 'n as" } Run
  • Multiplexage Ces programmes font que Joe et Ann comptent à tour de rôle. On peut utiliser un multiplexeur (fan-in) pour laisser parler le premier à être prêt. fn fnnipt,ipt <ca srn)<ca srn { uc aI(nu1 nu2 -hn tig -hn tig c: mk(hnsrn) = aeca tig g fn( {fr{c< <ipt }}) o uc) o - -nu1 ( g fn( {fr{c< <ipt }}) o uc) o - -nu2 ( rtr c eun } fn mi( { uc an) c: fnnenyu(Je) enyu(An) = aI(nuex"o", nuex"n") fri: 0 i<1;i+{ o = ; 0 + ftPitn<c m.rnl(-) } ftPitn"osêe tu lsdu enyus j me vi!) m.rnl(Vu ts os e ex nuex, e 'n as" } Run
  • Multiplexage (Fan-in)
  • Multiplexage Ces programmes font que Joe et Ann comptent à tour de rôle. On peut utiliser un multiplexeur (fan-in) pour laisser parler le premier à être prêt. fn fnnipt,ipt <ca srn)<ca srn { uc aI(nu1 nu2 -hn tig -hn tig c: mk(hnsrn) = aeca tig g fn( {fr{c< <ipt }}) o uc) o - -nu1 ( g fn( {fr{c< <ipt }}) o uc) o - -nu2 ( rtr c eun } fn mi( { uc an) c: fnnenyu(Je) enyu(An) = aI(nuex"o", nuex"n") fri: 0 i<1;i+{ o = ; 0 + ftPitn<c m.rnl(-) } ftPitn"osêe tu lsdu enyus j me vi!) m.rnl(Vu ts os e ex nuex, e 'n as" } Run
  • Réinstaurer l'ordre On peut envoyer un channel dans un channel, et faire que la goroutine attende son tour. On reçoit tous les messages, puis on permet aux goroutines d'envoyer des nouveaux par leur propre channel. D'abord on définit un type de message qui contient le channel pour la réponse. tp Msaesrc { ye esg tut sr srn t tig wi ca bo at hn ol }
  • Réinstaurer l'ordre Chaque émeteur doit attendre le permis de continuer. fri: 0 i<5 i+{ o = ; ; + mg : <c s1 = ftPitnmg.t) m.rnl(s1sr mg : <c s2 = ftPitnmg.t) m.rnl(s2sr mg.at< tu s1wi - re mg.at< tu s2wi - re } wiFrt: mk(hnbo)/ Praéprtu lsmsae. atoI = aeca ol / atg a os e esgs c< MsaeftSrnf"s %" mg i,wiFrt - esg{m.pit(%: d, s, ) atoI} tm.le(ieDrto(adIt(e) *tm.ilscn) ieSeptm.uainrn.nn23) ieMlieod <wiFrt -atoI Run
  • Select Une structure de contrôle uniquement pour la concurrence. La raison pour laquelle les channels et les goroutines font partie du langage.
  • Select L'instruction select offre une autre façon de gérer plusieurs channels. C'est comme un switch, mais chaque 'case' est une communication: - Tous les channels sont évalués. - Select bloque jusqu'à ce qu'une des opérations puisse être exécutée, puis il l'exécute. - Si plusieurs opérations sont prêtes, on en choisit une pseudo-aléatoirement. - Le cas default, si présent, est exécuté si aucune autre opération n'est prête. slc { eet cs v : <c: ae 1 = -1 ftPit(Rç % d c\" v) m.rnf"eu v e 1n, 1 cs v : <c: ae 2 = -2 ftPit(Rç % d c\" v) m.rnf"eu v e 2n, 1 cs c < 2: ae 3 - 3 ftPit(Evy % src\" 2) m.rnf"noé v u 3n, 3 dfut eal: ftPit(Pron netpê pu cmuiurn) m.rnf"esne 's rt or omnqe\" }
  • Encore le multiplexeur On peut réécrire notre fonction fanIn avec seulement une goroutine. Avant: fn fnnipt,ipt <ca srn)<ca srn { uc aI(nu1 nu2 -hn tig -hn tig c: mk(hnsrn) = aeca tig g fn( {fr{c< <ipt }}) o uc) o - -nu1 ( g fn( {fr{c< <ipt }}) o uc) o - -nu2 ( rtr c eun }
  • Fan-in avec select On peut réécrire notre fonction fanIn avec seulement une goroutine. Après: fn fnnipt,ipt <ca srn)<ca srn { uc aI(nu1 nu2 -hn tig -hn tig c: mk(hnsrn) = aeca tig g fn( { o uc) fr{ o slc { eet cs s: <ipt:c< s ae = -nu1 cs s: <ipt:c< s ae = -nu2 } } }) ( rtr c eun } Run
  • Timeout avec select La fonction t m . f e retourne un channel qui bloque pour une période de ieAtr durée donnée. Aprés cette durée, le channel reçoit le temps actuel, une seule fois. fn mi( { uc an) c: enyu(Je) = nuex"o" fr{ o slc { eet cs s: <c ae = -: ftPitns m.rnl() cs <tm.fe( *tm.eod: ae -ieAtr1 ieScn) ftPitn"ue to ln.) m.rnl(T s rp et" rtr eun } } } Run
  • Timeout pour la conversation entière avec select Crée le temporisateur une fois, en dehors de la boucle, pour faire timeout de la conversation entière. (On avait un timeout par message au paravant.) fn mi( { uc an) c: enyu(Je) = nuex"o" tmot: tm.fe( *tm.eod ieu = ieAtr5 ieScn) fr{ o slc { eet cs s: <c ae = -: ftPitns m.rnl() cs <tmot ae -ieu: ftPitn"upre to.) m.rnl(T als rp" rtr eun } } } Run
  • Timeout avec select La fonction t m . f e retourne un channel qui bloque pour une période de ieAtr durée donnée. Aprés cette durée, le channel reçoit le temps actuel, une seule fois. fn mi( { uc an) c: enyu(Je) = nuex"o" fr{ o slc { eet cs s: <c ae = -: ftPitns m.rnl() cs <tm.fe( *tm.eod: ae -ieAtr1 ieScn) ftPitn"ue to ln.) m.rnl(T s rp et" rtr eun } } } Run
  • Timeout pour la conversation entière avec select Crée le temporisateur une fois, en dehors de la boucle, pour faire timeout de la conversation entière. (On avait un timeout par message au paravant.) fn mi( { uc an) c: enyu(Je) = nuex"o" tmot: tm.fe( *tm.eod ieu = ieAtr5 ieScn) fr{ o slc { eet cs s: <c ae = -: ftPitns m.rnl() cs <tmot ae -ieu: ftPitn"upre to.) m.rnl(T als rp" rtr eun } } } Run
  • Le channel quit On peut retourner l'interaction et demander à Joe d'arrêter de parler quand on est fatigué de l'entendre. qi : mk(hnbo) ut = aeca ol c: enyu(Je,qi) = nuex"o" ut fri: rn.nn1) i> 0 i-{ o = adIt(0; = ; ftPitn<c m.rnl(-) } qi < tu ut - re slc { eet cs c< ftSrnf"s %" mg i: ae - m.pit(%: d, s, ) / o fi re / n at in cs <qi: ae -ut rtr eun } Run
  • Le channel quit On peut retourner l'interaction et demander à Joe d'arrêter de parler quand on est fatigué de l'entendre. qi : mk(hnbo) ut = aeca ol c: enyu(Je,qi) = nuex"o" ut fri: rn.nn1) i> 0 i-{ o = adIt(0; = ; ftPitn<c m.rnl(-) } qi < tu ut - re slc { eet cs c< ftSrnf"s %" mg i: ae - m.pit(%: d, s, ) / o fi re / n at in cs <qi: ae -ut rtr eun } Run
  • Réception par le channel quit Comment sait-on que Joe a fini? On peut attendre qu'il nous le dise: en utilisant quit une deuxième fois. qi : mk(hnsrn) ut = aeca tig c: enyu(Je,qi) = nuex"o" ut fri: rn.nn1) i> 0 i-{ o = adIt(0; = ; ftPitn<c m.rnl(-) } qi < "au! ut - Slt" ftPit(Jedt %\" <qi) m.rnf"o i: qn, -ut slc { eet cs c< ftSrnf"s %" mg i: ae - m.pit(%: d, s, ) / d ntig / o ohn cs <qi: ae -ut cenp) lau( qi < " pu! ut - À ls" rtr eun } Run
  • Le jeu du téléphone, avec des Gophers
  • Le jeu du téléphone, avec des Gophers fn flf,rgtca it { uc (et ih hn n) lf < 1+<rgt et -ih } fn mi( { uc an) cntn=100 os 000 lfms : mk(hnit etot = aeca n) rgt: lfms ih = etot lf : lfms et = etot fri: 0 i<n i+{ o = ; ; + rgt=mk(hnit ih aeca n) g flf,rgt o (et ih) lf =rgt et ih } g fn( ca it {c< 1}rgt o ucc hn n) (ih) ftPitn<lfms) m.rnl(-etot } Run
  • Un langage pour les systèmes logiciels Go a été crée pour écrire des systèmes logiciels. Voyons comment les fonctionnalités de concurrence nous aident.
  • Exemple: Google Search Q: Que fait Google? A: Pour une requête donnée, crée une page avec des résultats (et quelques annonces). Q: Comment on fait pour obtenir les résultats? A: On envoie la requête au moteurs Web, Image, YouTube, Maps, News, etc., puis on les mixe. Comment implémenter ça?
  • Google Search: Un faux framework On peut simuler les fonctions de recherche, comme on fait avec les conversations. vr( a Wb =fkSac(wb) e aeerh"e" Iae=fkSac(iae) mg aeerh"mg" Vdo=fkSac(vdo) ie aeerh"ie" ) tp Sac fn(ur srn)Rsl ye erh ucqey tig eut fn fkSac(idsrn)Sac { uc aeerhkn tig erh rtr fn(ur srn)Rsl { eun ucqey tig eut tm.le(ieDrto(adIt(0) *tm.ilscn) ieSeptm.uainrn.nn10) ieMlieod rtr Rsl(m.pit(Rsla % pu %\" kn,qey) eun eutftSrnf"éutt s or qn, id ur) } }
  • Google Search: Testons le framework fn mi( { uc an) rn.edtm.o(.nxao) adSe(ieNw)UiNn() sat: tm.o( tr = ieNw) rsls: Gol(gln" eut = oge"oag) easd: tm.ic(tr) lpe = ieSnesat ftPitnrsls m.rnl(eut) ftPitneasd m.rnl(lpe) } Run
  • Google Search 1.0 La fonction G o l reçoit une requête et retourne une slice de R s l s oge eut (qui sont des strings). G o l utilise les recherches W bI a eet V d oen série, en oge e, mg ie rajoutant les résultats à la slice r s l s eut. fn Gol(ur srn)(eut [Rsl){ uc ogeqey tig rsls ]eut rsls=apn(eut,Wbqey) eut pedrsls e(ur) rsls=apn(eut,Iaeqey) eut pedrsls mg(ur) rsls=apn(eut,Vdoqey) eut pedrsls ie(ur) rtr eun } Run
  • Google Search 2.0 Appelons W bI a eet V d oconcurremment, et attendons les résultats. e, mg ie Pas de verrous. Pas de moniteurs. Pas de callbacks. fn Gol(ur srn)(eut [Rsl){ uc ogeqey tig rsls ]eut c: mk(hnRsl) = aeca eut g fn( {c< Wbqey }) o uc) - e(ur) ( g fn( {c< Iaeqey }) o uc) - mg(ur) ( g fn( {c< Vdoqey }) o uc) - ie(ur) ( fri: 0 i<3 i+{ o = ; ; + rsl : <c eut = rsls=apn(eut,rsl) eut pedrsls eut } rtr eun } Run
  • Google Search 2.1 N'attendons pas les serveurs trop lents. Pas de verrous. Pas de moniteurs. Pas de callbacks. c: mk(hnRsl) = aeca eut g fn( {c< Wbqey }) o uc) - e(ur) ( g fn( {c< Iaeqey }) o uc) - mg(ur) ( g fn( {c< Vdoqey }) o uc) - ie(ur) ( tmot: tm.fe(0*tm.ilscn) ieu = ieAtr8 ieMlieod fri: 0 i<3 i+{ o = ; ; + slc { eet cs rsl : <c ae eut = -: rsls=apn(eut,rsl) eut pedrsls eut cs <tmot ae -ieu: ftPitn"ie ot) m.rnl(tmd u" rtr eun } } rtr eun Run
  • Comment éviter les timeouts Q: Comment éviter la perte de résultats par les serveurs lents? A: Repliquer les serveurs. Envoyer les requêtes à plusieurs instances, et utiliser seulement la première réponse. fn Frtqeysrn,rpia ..erh Rsl { uc is(ur tig elcs .Sac) eut c: mk(hnRsl) = aeca eut sacRpia: fn( it {c< rpia[]qey } erhelc = uci n) - elcsi(ur) fri: rnerpia { o = ag elcs g sacRpiai o erhelc() } rtr <c eun }
  • Utiliser la première réponse fn mi( { uc an) rn.edtm.o(.nxao) adSe(ieNw)UiNn() sat: tm.o( tr = ieNw) rsl : Frt"oag, eut = is(gln" fkSac(rpia1) aeerh"elc ", fkSac(rpia2) aeerh"elc ") easd: tm.ic(tr) lpe = ieSnesat ftPitnrsl) m.rnl(eut ftPitneasd m.rnl(lpe) } Run
  • Google Search 3.0 Réduction de la latence en utilisant des serveurs de recherche répliqués. c: mk(hnRsl) = aeca eut g fn( {c< Frtqey Wb,Wb)}) o uc) - is(ur, e1 e2 ( g fn( {c< Frtqey Iae,Iae)}) o uc) - is(ur, mg1 mg2 ( g fn( {c< Frtqey Vdo,Vdo)}) o uc) - is(ur, ie1 ie2 ( tmot: tm.fe(0*tm.ilscn) ieu = ieAtr8 ieMlieod fri: 0 i<3 i+{ o = ; ; + slc { eet cs rsl : <c ae eut = -: rsls=apn(eut,rsl) eut pedrsls eut cs <tmot ae -ieu: ftPitn"ie ot) m.rnl(tmd u" rtr eun } } rtr eun Run
  • Et tojours... Pas de verrous. Pas de moniteurs. Pas de callbacks.
  • Sommaire En juste quelques transformations simples on a utilisé les primitives de concurrence en Go pour convertir un système: lent séquentiel sensible aux erreurs en un système rapide concurrent répliqué robuste.
  • D'autres exemples Il y a beaucoup d'autres façons d'utiliser ces outils, beaucoup sont presentées ailleurs. Chatroulette: golang.org/s/chat-roulette (http://golang.org/s/chat-roulette) Load balancer: golang.org/s/load-balancer (http://golang.org/s/load-balancer) Crible des nombres premiers concurrente: golang.org/s/prime-sieve (http://golang.org/s/prime-sieve) Séries entières concurrente (par McIlroy): golang.org/s/power-series(http://golang.org/s/power-series)
  • Il faut pas trop en faire C'est amusant d'utiliser ces idées. Les goroutines et les channels c'est des grandes idées. Des bons outils pour la programmation. Mais ... parfois, tout ce dont on a besoin c'est un compteur de références. Go fournit "sync" et "sync/atomic" avec des mutex, sémaphores, etc. Il faut toujours choisir le bon outil pour chaque tâche.
  • Conclusions Les goroutines et les channels rendent facile à exprimer les opérations liées à plusieurs inputs plusieurs outputs timeouts erreurs Et ils sont amusants à utiliser!
  • Quelques liens Go Home Page: golang.org(http://golang.org) Go Tour (apprend Go depuis ton navigateur) tour.golang.org(http://tour.golang.org) Documentation de la standard library: golang.org/pkg(http://golang.org/pkg) Plein d'autres articles: golang.org/doc(http://golang.org/doc) Concurrency is not parallelism: golang.org/s/concurrency-is-not-parallelism (http://golang.org/s/concurrency-is-not-parallelism)
  • Thanks!
  • Thank you Francesc Campoy Flores Google Mountain View @campoy83 (http://twitter.com/campoy83) (mailto:campoy@google.com) (http://golang.org)

Comments

Be the first one to add a comment

Thumbnail for: Findings Revealed: 2015 State of the Software Supply Chain

Findings Revealed: 2015 State of the Software Supply Chain

WaiMan Yau

free
Thumbnail for: Web Application Security Reloaded for the HTML5 era

Web Application Security Reloaded for the HTML5 era

Carlo Bonamico

free
Thumbnail for: Gimme Caching - The Distributed JCache(JSR107) Way

Gimme Caching - The Distributed JCache(JSR107) Way

David Brimley

free
Thumbnail for: How to lower the power consumption of your app, without affecting performance

How to lower the power consumption of your app, without affecting performance

Rick Schwartz

free
Thumbnail for: Never mind the bollocks: here's the Linux containers

Never mind the bollocks: here's the Linux containers

Patrick Chanezon

free
Thumbnail for: NOW TV and Linear Streaming: The unpredictable scalability challenge

NOW TV and Linear Streaming: The unpredictable scalability challenge

Tom Maule

free
Thumbnail for: The end of server management : hosting has to become a commodity

The end of server management : hosting has to become a commodity

Quentin ADAM

free
Thumbnail for: The Future of Personal Robotics

The Future of Personal Robotics

Nicolas Rigaud

free
Thumbnail for: Performance Tuning, Top 10 Your Doing it Wrong!

Performance Tuning, Top 10 Your Doing it Wrong!

Kirk Pepperdine

free
Thumbnail for: Let’s Get to the Rapids: Java 8 Stream Perfomance

Let’s Get to the Rapids: Java 8 Stream Perfomance

Maurice Naftalin

free
Thumbnail for: Pushing The Limits With Java Enterprise Cloud Development

Pushing The Limits With Java Enterprise Cloud Development

Simon Ritter

free
Thumbnail for: JCP, Adopt-a-JSR & You

JCP, Adopt-a-JSR & You

Heather VanCura

free
Thumbnail for: 3 Keys to Rapid Deployment Success

3 Keys to Rapid Deployment Success

Sven Erik Knop

free
Thumbnail for: Bringing IBM Watson to the Cloud

Bringing IBM Watson to the Cloud

Dale Lane

free
Thumbnail for: The Smartwatch Revolution begins: Developing for Android Wear

The Smartwatch Revolution begins: Developing for Android Wear

Pratik Patel

free
Thumbnail for: The Google Cloud Plaform - Beyond simple use cases

The Google Cloud Plaform - Beyond simple use cases

David Gageot

free
Thumbnail for: The Cloud, an Arduino, an Application, Server, and me - Adventures In and Out of the Cloud

The Cloud, an Arduino, an Application, Server, and me - Adventures In and Out of the Cloud

Holly Cummins

free
Thumbnail for: TestOps - Chasing the White Whale

TestOps - Chasing the White Whale

Ioana Serban

free
Thumbnail for: Experimenting with ServiceWorker

Experimenting with ServiceWorker

Sandro Paganotti

free
Thumbnail for: Accessibility and how to get the most from your screenreader

Accessibility and how to get the most from your screenreader

Edd Sowden

free
Thumbnail for: What Were You Doing In 1995? A 20 Year Retrospective of Java

What Were You Doing In 1995? A 20 Year Retrospective of Java

Simon Ritter , Steve Elliott

free
Thumbnail for: SQL’s back: querying document databases the old fashioned way

SQL’s back: querying document databases the old fashioned way

Matthew Revell

free
Thumbnail for: Decoding the air around you with Java and $7 hardware

Decoding the air around you with Java and $7 hardware

Bert Jan Schrijver

free
Thumbnail for: "Catch me if you can" - Java on wearables

"Catch me if you can" - Java on wearables

Gerrit Grunwald

free
Thumbnail for: Miniboxing: Fast Generics for Primitive Types

Miniboxing: Fast Generics for Primitive Types

Vlad Ureche

free
Thumbnail for: goto java;

goto java;

Martin Skarsaune

free
Thumbnail for: Java 8 in Anger

Java 8 in Anger

Trisha Gee

free
Thumbnail for: Not my department?! How our privacy is broken and what you can do about it.

Not my department?! How our privacy is broken and what you can do about it.

Anna Biselli

free
Thumbnail for: The Hidden Gems of PDF

The Hidden Gems of PDF

Michaël Demey

free
Thumbnail for: Design Patterns in the 21st Century

Design Patterns in the 21st Century

Samir Talwar

free
Thumbnail for: Keynote: The Extraordinary Team of Developers

Keynote: The Extraordinary Team of Developers

Trisha Gee , Daniel Bryant

free
Thumbnail for: Java Generics: Past, Present and Future

Java Generics: Past, Present and Future

Richard Warburton , Raoul-Gabriel Urma

free
Thumbnail for: Building securely with agile

Building securely with agile

Michael Brunton-spall

free
Thumbnail for: STOP BREAKING MY STUFF

STOP BREAKING MY STUFF

Katharine Fitzpatrick

free
Thumbnail for: All Change! How the new economics of Cloud will make you think differently about Java

All Change! How the new economics of Cloud will make you think differently about Java

Steve Poole

free
Thumbnail for: Powering real-time web apps with Hazelcast

Powering real-time web apps with Hazelcast

Andrejs Jermakovics

free
Thumbnail for: What is your build telling you about your application structure?

What is your build telling you about your application structure?

Abraham Marin-Perez

free
Thumbnail for: Practical Challenges of moving from CI to CD using Maven

Practical Challenges of moving from CI to CD using Maven

Jatin Bhadra

free
Thumbnail for: Destination: Cloud. Deploying Applications To The Cloud With Docker

Destination: Cloud. Deploying Applications To The Cloud With Docker

Ryan Baxter

free
Thumbnail for: Finally, Security API JSR 375

Finally, Security API JSR 375

Alex Kosowski

free
Thumbnail for: Level up your Android Build

Level up your Android Build

Volker Leck

free
Thumbnail for: Practical Continuous Deployment

Practical Continuous Deployment

Steve Smith

free
Thumbnail for: The Seven Deadly Sins of Microservices

The Seven Deadly Sins of Microservices

Daniel Bryant

free
Thumbnail for: Making Events for Local Dev Communities

Making Events for Local Dev Communities

Celestino Bellone , Federico Yankelevich

free
Thumbnail for: Nuts and Bolts of WebSocket

Nuts and Bolts of WebSocket

Arun Gupta

free
Thumbnail for: Developing iOS applications with Java and Eclipse

Developing iOS applications with Java and Eclipse

Grant Ronald

free
Thumbnail for: Welcome Keynote

Welcome Keynote

Mark Hazell

free
Thumbnail for: Refactor your Java EE application using Microservices and Containers

Refactor your Java EE application using Microservices and Containers

Arun Gupta

free
Thumbnail for: Java EE 8, a snapshot overview

Java EE 8, a snapshot overview

David Delabassee

free
Thumbnail for: The Dark arts of building your own framework

The Dark arts of building your own framework

Andrey Glaschenko , Konstantin Krivopustov

free
Thumbnail for: Programming at any Scale

Programming at any Scale

Andrew Harmel-Law

free
Thumbnail for: Java is dead, long live Ceylon, Kotlin,…

Java is dead, long live Ceylon, Kotlin,…

Russel Winder

free
Thumbnail for: Android Testing: A New Hope

Android Testing: A New Hope

Zan Markan , Nicholas Jackson

free
Thumbnail for: Java EE changes design pattern implementation

Java EE changes design pattern implementation

Alex Theedom

free
Thumbnail for: Building Cloud Powered Android Apps with Azure

Building Cloud Powered Android Apps with Azure

Chris Risner

free
Thumbnail for: From 0 to 60 million users: Scaling for speed and high availability

From 0 to 60 million users: Scaling for speed and high availability

Aviran Mordo

free
Thumbnail for: HTTP/2 comes to Java. What Servlet 4.0 means to You

HTTP/2 comes to Java. What Servlet 4.0 means to You

David Delabassee

free
Thumbnail for: 50 minutes to develop a full Java EE application with Forge? Is that all?

50 minutes to develop a full Java EE application with Forge? Is that all?

Antonio Goncalves

free
Thumbnail for: How to Rock your Web Apps with Spring and Vaadin

How to Rock your Web Apps with Spring and Vaadin

Sami Ekblad

free
Thumbnail for: In-Memory Computing - Distributed Systems

In-Memory Computing - Distributed Systems

Christoph Engelbert

free
Thumbnail for: Comparing different concurrency models on the JVM

Comparing different concurrency models on the JVM

Mario Fusco

free
Thumbnail for: 5 reasons why developers should pay attention to robotics

5 reasons why developers should pay attention to robotics

Nicolas Rigaud

free
Thumbnail for: Ceylon from here to infinity: the big picture and what's coming

Ceylon from here to infinity: the big picture and what's coming

Stephane Epardaud

free
Thumbnail for: Is your profiler speaking the same language as you?

Is your profiler speaking the same language as you?

Simon Maple

free
Thumbnail for: Java 9: Make Way for Modules!

Java 9: Make Way for Modules!

Mark Reinhold

free
Thumbnail for: Akka Streams with Scala and Java

Akka Streams with Scala and Java

Jamie Allen

free
Thumbnail for: The 10 Golden Rules of Mobile UX

The 10 Golden Rules of Mobile UX

Emilia Ciardi

free
Thumbnail for: Ludicrously Fast Builds with Buck

Ludicrously Fast Builds with Buck

Simon Stewart

free
Thumbnail for: Making Enterprise Java Architecture Sustainable

Making Enterprise Java Architecture Sustainable

Markus Eisele

free
Thumbnail for: Combining R with Java for Data Analysis

Combining R with Java for Data Analysis

Ryan Cuprak , Elsa Cuprak

free
Thumbnail for: Diversity Rules!

Diversity Rules!

Amali de Alwis

free
Thumbnail for: Flyway - Database Migration made easy

Flyway - Database Migration made easy

Axel Fontaine

free
Thumbnail for: Microservices Made Easy with Spring Cloud and Netflix OSS

Microservices Made Easy with Spring Cloud and Netflix OSS

David Syer

free
Thumbnail for: CDI 2.0: what is in the work?

CDI 2.0: what is in the work?

Antoine Sabot-Durand , José Paumard

free
Thumbnail for: WildFly 9

WildFly 9

Kabir Khan

free
Thumbnail for: Functional patterns for scala beginners

Functional patterns for scala beginners

Clément Delafargue

free
Thumbnail for: Devoxx4Kids

Devoxx4Kids

Dan Hardiker

free
Thumbnail for: Let’s Get to the Rapids: Java 8 Stream Perfomance

Let’s Get to the Rapids: Java 8 Stream Perfomance

Maurice Naftalin

free
Thumbnail for: Level Up your Dev Skills with Static Analysis

Level Up your Dev Skills with Static Analysis

David Lindsay

free
Thumbnail for: From Requirements to Deployment: Implementing a Microservice in Java using BDD and TDD

From Requirements to Deployment: Implementing a Microservice in Java using BDD and TDD

John Ferguson Smart

free
Thumbnail for: Predicting the Future with Machine Learning

Predicting the Future with Machine Learning

Amy Nicholson

free
Thumbnail for: Software Architecture as Code

Software Architecture as Code

Simon Brown

free
Thumbnail for: Top 10 Real-life WebSocket Use Cases and Experiences

Top 10 Real-life WebSocket Use Cases and Experiences

Richard Cullen

free
Thumbnail for: The First IoT JSR: Units of Measurement

The First IoT JSR: Units of Measurement

Leonardo Lima , Chris Senior

free
Thumbnail for: One Framework, No Dependencies: Using Frameworks to Avoid Common Pitfalls of App Development

One Framework, No Dependencies: Using Frameworks to Avoid Common Pitfalls of App Development

Lee Boonstra

free
Thumbnail for: Building the UKs biggest IoT network

Building the UKs biggest IoT network

Romanas Sonkinas

free
Thumbnail for: Never Mind the Devoxx

Never Mind the Devoxx

David Blevins

free
Thumbnail for: Five Ways to Not Suck at Being a Java Freelancer

Five Ways to Not Suck at Being a Java Freelancer

Roberto Cortez

free
Thumbnail for: Java EE Game Changers

Java EE Game Changers

David Blevins

free
Thumbnail for: Express yourself with Java 8

Express yourself with Java 8

Benjamin Weber

free