1. PROGRESS
1
Faisons travailler
des gophers ensemble

2. PROGRESS
2
Présentation

3. PROGRESS
3
Bruno Michel
✰ Directeur Technique d' af83
✰ Développeur de LinuxFr.org
✰ Ancien président de Ruby France
✰ github.com/nono
✰ twitter.com/brmichel

4. PROGRESS
4
Gophers
« Gaufre (ou gauphre) est un nom vernaculaire ambigu en français, pouvant désigner
des rongeurs […] »
— Wikipédia

5. PROGRESS
5
Go
✰ Langage Open Source, géré par la communauté
✰ Une version stable, Go 1
✰ Langage moderne et agréable à utiliser
✰ Pour faire des logiciels simples, performants et fiables

6. PROGRESS
6
Concurrence et parallélisme

7. PROGRESS
7
Concurrence
« Programming as the composition of independently executing
processes. »
— Ro b P i k e

8. PROGRESS
8
Parallélisme
« Programming as the simultaneous execution of (possibly related) computations. »
— Ro b Pik e

9. PROGRESS
9
Concurrence vs. parallélisme
Concurrence : une question de structure de données
Parallélisme : à propos de l'exécution

10. PROGRESS
10
Les primitives de Go

11. PROGRESS
11
Goroutine
func computation(n int) {
time.Sleep(n * time.Milliseconds)
fmt.Printf("%s seconds elapsedn", n)
}
go computation(3)
go computation(1)
go computation(5)
computation(7)

12. PROGRESS
12
Channels
func pingpong(ch chan int) {
n := <-ch
fmt.Printf("Received %dn", n)
ch <- n
}
func main() {
ch := make(chan int)
go pingpong(ch)
ch <- 42
<-ch
}

13. PROGRESS
13
Buffered Channels
func pingpong(ch chan int) {
n := <-ch
fmt.Printf("Received %dn", n)
ch <- n
}
func main() {
ch := make(chan int, 5)
go pingpong(ch)
ch <- 42
<-ch
}

14. PROGRESS
14
Select
select {
case chan1 <- nb:
fmt.Printf("c1")
case str := <-chan2:
fmt.Printf("c2")
case str := <-chan3:
fmt.Printf("c3")
}

15. PROGRESS
15
Quelques patterns

16. PROGRESS
16
Génerateur
func idGenerator() chan int {
ids := make(chan int)
go func() {
id := 0
for {
ch <- id
id++
}
}
return ids
}
ids := idGenerator()
id1 := <-ids
id2 := <-ids

17. PROGRESS
17
Timeout
select {
case n := <-ch:
fmt.Printf("Received %d", n)
case <-time.After(2 * time.Seconds)
fmr.Printf("Too late")
}

18. PROGRESS
18
Tickers
ticker := time.NewTicker(50 * time.Millisecond)
go func() {
for t := range ticker.C {
fmt.Println("Tick at", t)
}
}()
time.Sleep(150 * time.Millisecond)
ticker.Stop()

19. PROGRESS
19
Worker
func worker(in <-chan *Work,
out chan<- *Work) {
for w := range in {
w.z = w.x * w.y
Sleep(w.z)
out <- w
}
}

20. PROGRESS
20
Load balancer
func Run() {
in := make(chan *Work)
out := make(chan *Work)
for i := 0; i < NumWorkers; i++ {
go worker(in, out)
}
go sendLotsOfWork(in)
receiveLotsOfResults(out)
}

21. PROGRESS
21
Conclusion

22. PROGRESS
22
Goroutines + Channels = <3
✰ Ni mutex
✰ Ni semaphore
✰ Mais c'est très puissant

23. PROGRESS
23
Mise en application
External images for LinuxFr.org
https://github.com/nono /img-LinuxFr.org

24. PROGRESS
24
Pour aller plus loin
Concurrency is not Parallelism (it's better) — Rob Pike
http://waza.heroku.com/