https://talks.obedmr.com/
The Go Programming Language Book
Presentation and code examples:
https://github.com/CodersSquad/hello-gophers
Concurrent programming is the expression of a program as a composition of several autonomous activities.
Golang provides 2 styles of concurrent programming:
In Go, each concurrently executing activity is called a goroutine.
goroutine
When a program starts, its only goroutine is the one that calls the main function. It's called the main goroutine.
main goroutine
f() // call f(); wait for it to return go f() // create a new goroutine that calls f(); don't wait
Source code: spinner.go
spinner.go
func main() { go spinner(100 * time.Millisecond) const n = 45 fibN := fib(n) // slow fmt.Printf("\rFibonacci(%d) = %d\n", n, fibN) }
func fib(x int) int { if x < 2 { return x } return fib(x-1) + fib(x-2) }
func spinner(delay time.Duration) { for { for _, r := range `-\|/` { fmt.Printf("\r%c", r) time.Sleep(delay) } } }
Source code: clock1.go
clock1.go
func main() { listener, err := net.Listen("tcp", "localhost:9090") if err != nil { log.Fatal(err) } for { conn, err := listener.Accept() if err != nil { log.Print(err) // e.g., connection aborted continue } handleConn(conn) // handle one connection at a time } }
func handleConn(c net.Conn) { defer c.Close() for { _, err := io.WriteString(c, time.Now().Format("15:04:05\n")) if err != nil { return // e.g., client disconnected } time.Sleep(1 * time.Second) } }
Test with netcat.sh
netcat.sh
./netcat.sh
Test with netcat1.go
netcat1.go
func mustCopy(dst io.Writer, src io.Reader) { if _, err := io.Copy(dst, src); err != nil { log.Fatal(err) } } func main() { conn, err := net.Dial("tcp", "localhost:9090") if err != nil { log.Fatal(err) } defer conn.Close() mustCopy(os.Stdout, conn) }
This is the real concurrent one
Source code: clock2.go
clock2.go
func main() { listener, err := net.Listen("tcp", "localhost:9090") if err != nil { log.Fatal(err) } for { conn, err := listener.Accept() if err != nil { log.Print(err) // e.g., connection aborted continue } go handleConn(conn) // handle connections concurrently } }
Go Proverbs
Don't communicate by sharing memory, share memory by communicating.
Concurrency is not parallelism.
Channels orchestrate; mutexes serialize.
If goroutines are the activities of a concurrent Go program, channels are the connections between them.
A channel is a communication mechanism that lets one goroutine send values to another goroutine.
A channel is a reference to the data structure created by make
A channel has 2 operations, send and receive, also known as communications.
ch := make(chan int) // ch has type 'chan int' ch <- x // a send statement x = <-ch // a receive expression in an assignment statement <-ch // a receive statement; result is discarded close(ch) // To close a channel
Channels created with simple make is called as unbuffered channel.
make
But make could use a second parameter which indicates the channel's capacity. If this capacity is non-zero, make will created a buffered channel.
ch = make(chan int) // unbuffered channel ch = make(chan int, 0) // unbuffered channel ch = make(chan int, 3) // buffered channel with capacity 3
Source code: netcat2.go
netcat2.go
func main() { ... done := make(chan int) go func() { io.Copy(os.Stdout, conn) // NOTE: ignoring errors log.Println("done") done <- 2 // signal the main goroutine }() x := 1 x = <-done // wait for background goroutine to finish log.Println("Channel Closed with value: ", x) close(done) }
Pipelines are used to connect goroutines together so that the output of one can be the input to another.
Source code: pipeline.go
pipeline.go
func main() { naturals := make(chan int) squares := make(chan int) // Counter go counter(naturals) // Squarer go squarer(naturals, squares) // Printer (in main goroutine) for x := range squares { fmt.Println(x) } }
Counter goroutine code
func counter(naturals chan int) { for x := 0; x < 100; x++ { naturals <- x } close(naturals) }
Squarer goroutine code
func squarer(naturals, squares chan int) { for x := range naturals { squares <- x * x } close(squares) }
Follow the instructions in the link: https://github.com/CodersSquad/go-clockwall
Take a look on The Go Programming Language book
gmail | tec | intel