go doSomeThing()

Transcript

1. go doSomething() author := "Jérémy Courtial"
2. // Pragmatic & productive // language for efficient // softwares type GoLang struct {
 …
 }
3. go.creationYear = "2007" go.authors = []Author{ "Robert Griesemer", "Rob Pike", "Ken Thompson"}
4. go.users = []Company{ "Google", "Docker" "SoundCloud", "Dropbox", "Facebook", "CoreOS", "Cloudflare", … }
5. go := Language{ 
 memManagement: gc, packaging: fatBinary, crossPlatform: true …
6. …
 paradigm: imperative, typeSystem: static-inferred, licence: openSource }
7. import "fmt"
8. import "fmt" func main() { }
9. import "fmt" func main() { msg := "Hello, World" }
10. import "fmt" func main() { msg := "Hello, World" fmt.Println(msg) }
11. // Go has interface type Human interface {
 SayHello()
 }
12. // Struct is a class equiv. type HomoSapiens struct {
 Name string Age int
 }
13. func (hs HomoSapiens) SayHello {
 }
14. func (hs HomoSapiens) SayHello {
 fmt.Println("Hi, i'm", hs.Name) }
15. // Now HomoSapiens implements Human func (hs HomoSapiens) SayHello {
 fmt.Println("Hi, i'm", hs.Name) }
16. /* "Favor 'object composition' over 'class inheritance'." Design Patterns, GoF, 1995 */
17. type Robot interface {
 DestroyHumanity()
 }
18. type Cyborg struct {
 Human Robot gadgets []Gadget
 }
19. t800 := Cyborg { }
20. t800 := Cyborg { human: HumanImpl{}, }
21. t800 := Cyborg { human: HumanImpl{}, robot: RobotImpl{}, }
22. t800 := Cyborg { human: HumanImpl{}, robot: RobotImpl{}, gadgets: lethalGadgets, }
23. t800.SayHello() t800.DestroyHumanity()
24. // golang.org/doc/effective_go.html
25. go.missings = []Feature{ }
26. go.missings = []Feature{ "Generics", }
27. go.missings = []Feature{ "Generics", "Pointer Arithmetic", }
28. go.missings = []Feature{ "Generics", "Pointer Arithmetic", "try/catch", }
29. go.missings = []Feature{ "Generics", "Pointer Arithmetic", "try/catch", "Implicit Conversions"}
30. go.tools = []Tool{ "go build", "go fmt", "go get", "go vet", … }
31. go.stdLib = []Package{ "net/http", "crypto/aes", "encoding/json", "sort", "bytes", "compress/gzip", "image/png", "net/html", … }
32. func NewCipher(key []byte) (cipher.Block, error) type Block interface {
 
 BlockSize() int
 
 Encrypt(dst, src []byte)
 
 Decrypt(dst, src []byte)
 }
33. func main() { http.HandleFunc("/hi", func(w http.ResponseWriter, r *http.Request ) {
 msg := map[string]string {"msg": "Hello, World!"}
 j, _ := json.Marshal(msg)
 w.Write(j)
 })
 
 http.ListenAndServe(":8080", nil) }
34. go.concurrency = LigthAndFastImpl{}
35. go doSomthingForAWhile()
36. /* Don't communicate by sharing, share by communicating. */
37. // Instanciates a channel of strings c := make(chan string) go work(c)
38. func work(c chan string) { }
39. func work(c chan string) { for { } }
40. func work(c chan string) { for { msg := <- c } }
41. func work(c chan string) { for { msg := <- c fmt.Println(msg) } }
42. c <- "Hello World!" time.Sleep(5) c <- "Have a nice day!" time.Sleep(5) c <- "Bye bye!"
43. func work(quit, c chan int) { }
44. func work(quit, c chan int) { select { } }
45. func work(quit, c chan int) { select { case n := <- c : } }
46. func work(quit, c chan int) { select { case n := <- c : process(n) } }
47. func work(quit, c chan int) { select { case n := <- c : process(n) case <- quit : } }
48. func work(quit, c chan int) { select { case n := <- c : process(n) case <- quit : return } }
49. // Why Go's concurrency is special ?
50. define("C10k problem")
51. // Most evident tool type Thread struct {
 …
 }
52. /* Be naive : One thread per connection */
53. for { }
54. for { conn := tcp.accept() }
55. for { conn := tcp.accept() newThread() }
56. for { conn := tcp.accept() newThread().run( func() { }) }
57. for { conn := tcp.accept() newThread().run( func() { handleConnection(conn) }) }
58. #BEGIN JAVA #END JAVA // Quick & dirty POC
59. #BEGIN JAVA #END JAVA while (true) { } // Quick & dirty POC
60. #BEGIN JAVA #END JAVA while (true) { new Thread(() -> { }); } // Quick & dirty POC
61. #BEGIN JAVA #END JAVA while (true) { new Thread(() -> { sleep(Long.MAX_VALUE); }); } // Quick & dirty POC
62. #BEGIN JAVA #END JAVA while (true) { new Thread(() -> { sleep(Long.MAX_VALUE); }); } // What will happen ?
63. Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread at java.lang.Thread.start0(Native Method) at java.lang.Thread.start(Thread.java:714) at Test.main(Test.java:19) $ javac Test.java && java Test
64. /* - Each thread has is own stack - Stack's size is hard to predict => alloc ~1 Mo per thread */
65. |- — — — — — — - - - - -| | Thread Stack 1 | |- - - - - - - - - - - -| | . | | . | | . | | . | | . | | . | | . | | . | | . | |_ _ _ _ _ _ _ _ _ _ _ _|
66. |- — — — — — — - - - - -| | Thread Stack 1 | |- - - - - - - - - - - -| | Guard Page | | — — — — — — — - - - - | | . | | . | | . | | . | | . | | . | | . | |_ _ _ _ _ _ _ _ _ _ _ _|
67. |- — — — — — — - - - - -| | Thread Stack 1 | |- - - - - - - - - - - -| | Guard Page | | — — — — — — — - - - - | | Thread Stack 2 | |- - - - - - - - - - - -| | . | | . | | . | | . | | . | |_ _ _ _ _ _ _ _ _ _ _ _|
68. |- — — — — — — - - - - -| | Thread Stack 1 | |- - - - - - - - - - - -| | Guard Page | | — — — — — — — - - - - | | Thread Stack 2 | |- - - - - - - - - - - -| | Guard Page | |- - - - - - - - - - - -| | . | | . | | . | |_ _ _ _ _ _ _ _ _ _ _ _|
69. // Let's try something else … pool := NewThreadPool(n)
70. pool.submit(work)
71. work := func() { // Blocks until done … readFromNetwork() }
72. if pool.hasAvailableThread == false { gameOver() }
73. // We need different tools IO.asynchronous = true
74. /* The Hollywood Principle : "Don't call us, we'll call you" */
75. b := readFromNetwork() //Block here /* With synchronous I/O */
76. readFromNetwork(func(b []byte) { //Call when data are available }) /* With asynchronous I/O */
77. // Let's try something else … type EventDriven struct {
 …
 }
78. // Event Driven // Always use async I/O // Considers I/O as events producers // Events are gathered by a loop
79. const ( NewConnectionEvent = 1 DataAvailableEvent = 2 DataSentEvent = 3 … )
80. type Event struct {
 type EventType callback func() result []byte 
 }
81. loop := NewEventLoop() thread.run(loop)
82. func (l loop) run() { }
83. func (l loop) run() { for { } }
84. func (l loop) run() { for { events := os.GatherEvents() } }
85. func (l loop) run() { for { events := os.GatherEvents() l.dispatch(events) } }
86. func (l loop) dispatch(e []Event) { }
87. func (l loop) dispatch(e []Event) { for event := range e { } }
88. func (l loop) dispatch(e []Event) { for event := range e { event.callback(e.result) } }
89. // Drawbacks
90. // Callbacks hells
91. s.onNewConnection(func(…){ … }).onDataAvailable(func(…){ … }) s.sendData(data, func(…){ … })
92. // Singled threaded // Bad for vertical scaling thread.run(loop)
93. // We need different tools
94. |- — — — — — — - - - - -| | | | | | | | | | | |- - - - - - - - - - - -| | | | | | | | | | | |_ _ _ _ _ _ _ _ _ _ _ _| // User space // Kernel Space
95. |- — — — — — — - - - - -| | | | | | | | | | | |- - - - - - - - - - - -| | | | | | | | | | Process/Mem management| |_ _ _ _ _ _ _ _ _ _ _ _| // User space // Kernel Space
96. |- — — — — — — - - - - -| | | | | | | | | | | |- - - - - - - - - - - -| | | | | | Drivers | | | | Process/Mem management| |_ _ _ _ _ _ _ _ _ _ _ _| // User space // Kernel Space
97. |- — — — — — — - - - - -| | | | | | | | | | | |- - - - - - - - - - - -| | SysCall Interface | | | | Drivers | | | | Process/Mem management| |_ _ _ _ _ _ _ _ _ _ _ _| // User space // Kernel Space
98. |- — — — — — — - - - - -| | Applications | | | | | | | | | |- - - - - - - - - - - -| | SysCall Interface | | | | Drivers | | | | Process/Mem management| |_ _ _ _ _ _ _ _ _ _ _ _| // User space // Kernel Space
99. |- — — — — — — - - - - -| | Applications | | | | Daemons | | | | | |- - - - - - - - - - - -| | SysCall Interface | | | | Drivers | | | | Process/Mem management| |_ _ _ _ _ _ _ _ _ _ _ _| // User space // Kernel Space
100. |- — — — — — — - - - - -| | Applications | | | | Daemons | | | | Librairies | |- - - - - - - - - - - -| | SysCall Interface | | | | Drivers | | | | Process/Mem management| |_ _ _ _ _ _ _ _ _ _ _ _| // User space // Kernel Space
101. |- — — — — — — - - - - -| | | | | | NewOSThread() | | | | | |- — — — — — — - - - - -| | | | | | | | | | | |_ _ _ _ _ _ _ _ _ _ _ _| // Kernel threads
102. |- — — — — — — - - - - -| | | | | | NewOSThread() | | | | | | |- - - - - | - - - - - -| | ∨ | | | | kernel_thread(…) | | | | | |_ _ _ _ _ _ _ _ _ _ _ _| // Kernel threads
103. |- — — — — — — - - - - -| | | | User Thread 1 | | | | | | | |- — — — — — — - - - - -| | | | | | | | | | | |_ _ _ _ _ _ _ _ _ _ _ _| /* Users threads */
104. |- — — — — — — - - - - -| | | | User Thread 1 | | User Thread 2 | | | | | |- — — — — — — - - - - -| | | | | | | | | | | |_ _ _ _ _ _ _ _ _ _ _ _| /* Users threads */
105. |- — — — — — — - - - - -| | | | User Thread 1 | | User Thread 2 | | User Thread 3 | | | |- — — — — — — - - - - -| | | | | | | | | | | |_ _ _ _ _ _ _ _ _ _ _ _| /* Users threads */
106. |- — — — — — — - - - - -| | — — — — — — — — | | | User Thread 1 | | | | User Thread 2 | | | | User Thread 3 | | | - - - - - - - - | |- — — — — — — - - - - -| | | | | | | | | | | |_ _ _ _ _ _ _ _ _ _ _ _| /* Users threads */
107. |- — — — — — — - - - - -| | — — — — — — — — | | | User Thread 1 | | | | User Thread 2 | | | | User Thread 3 | | | - - - | - - - - | |- - - - - | - - - - - -| | ∨ | | | | kernel_thread(…) | | | | | |_ _ _ _ _ _ _ _ _ _ _ _| /* Users threads N:M */
108. // User Threads // Cheaper than kernel threads // Backed by one or more K threads // App is responsible for scheduling
109. goroutines == User threads
110. // Goroutines are // Cheap in memory : 2 Ko only // Cheap to create/destroy // Cheap to switch
111. for { }
112. for { conn := tcp.accept() }
113. for { conn := tcp.accept() go handleConnection(conn) }
114. func handleConnection(c net.Conn){ }
115. func handleConnection(c net.Conn){ data := c.Read(4096) }
116. func handleConnection(c net.Conn){ data := c.Read(4096) response := process(data) }
117. func handleConnection(c net.Conn){ data := c.Read(4096) response := process(data) c.Write(response) }
118. data := c.Read(4096)
119. data := c.Read(4096) // Blocks the goroutine until // data are available
120. data := c.Read(4096) // But don't block the thread // and other goroutines
121. // Goroutines scheduling // Scheduling is cooperative // Blocking IOs used as switch point // When a gorountine blocks another // is wake up
122. /* Now you can be naive : One thread per connection */ goroutine
123. /* The gopher way : Focus on what you want to do */
124. // Let's go ?
125. // October 10, 2016 · PARIS
126. /* Bibliography golang.org tour.golang.org talks.golang.org */
127. /* Bibliography The Go scheduler How Goroutines work Performance Without The Event Loop */
128. // Thanks // Questions ?