Goroutines and Channels in practice

GOROUTINESAND
CHANNELSIN
PRACTICE
GUILHERMEGARNIER

We're hiring!https://blog.guilhermegarnier.com
@gpgarnier https://talentos.globo.com

CONCURRENCYIS
HARD
Threads are expensive
Hard to share state
Hard to manage threads lifecycle

WHYISGODIFFERENT?
simple concurrency model
embraces concurrency with
goroutines
easy to share state with
channels

WHAT'SA
GOROUTINE?
Abstraction above OS threads
Don't have an identity like thread IDs
Not suspended unless sleeping, blocked or on a function call

SCHEDULING
Goroutines Threads
Scheduled by Go runtime OS kernel
Work
distribution
de ned in the
code
de ned by the Go
scheduler

GOM:NSCHEDULER
Maps M goroutines to N threads

numGoroutines := 2
wg := sync.WaitGroup{}
wg.Add(numGoroutines)

for i := 0; i < numGoroutines; i++ {
go func() {
defer wg.Done()
for i := 0; i < 100; i++ {
for j := 0; j < 10000000; j++ {
}
}
}()
}

wg.Wait()

TRACINGTHEEXECUTION
Runnable goroutines
Running goroutines
go run main.go (multithread)
GOMAXPROCS=1 go run main.go (single thread)

numGoroutines := 2
wg := sync.WaitGroup{}

go func() {
defer wg.Done()
for i := 0; i < 100; i++ {
for j := 0; j < 10000000; j++ {
}
time.Sleep(1 * time.Nanosecond)
}
}()
}

wg.Wait()

TRACINGTHEEXECUTION
Runnable goroutines
Running goroutines
GOMAXPROCS=1 go run main.go (single thread, with sleep)

STACKSIZE
THREADS
xed (~ 1-8 MB)
wasteful for small jobs
not enough for large jobs
GOROUTINES
dynamic
starts small (~ 4 kB)
grows and shrinks when
needed

GOROUTINESMEMORYUSAGE
source: Concurrency in Go, page 44
memConsumed := func() uint64 {...}
var ch <-chan interface{}
var wg sync.WaitGroup

const numGoroutines = 100000

before := memConsumed()
go func() { wg.Done(); <-ch }()
}
wg.Wait()
after := memConsumed()

fmt.Printf("%.3f bytes", float64(after-before)/numGoroutines)

GOROUTINESMEMORYUSAGE
Mem (GB) Goroutines
1 370 k
2 740 k
4 1.5 M
8 2.9 M
16 5.9 M
32 11.8 M
64 23.7 M
source: Concurrency in Go, page 44

STATESHARING
Do not communicate by sharing memory; instead,
share memory by communicating
https://blog.golang.org/share-memory-by-communicating

EXAMPLE:HEALTHCHECKSINJAVA
public class Main {
public static void main(String args[]) {
String[] urls = {"url1", "url2", ...};
Thread[] threads = new Thread[urls.length];
for (int i = 0; i < urls.length; i++) {
threads[i] = new Thread(new Healthcheck(urls[i]));
threads[i].start();
}

try {
for (Thread t : threads) {
t.join();
}
} catch (Exception e) {}

System.out.println(Healthcheck.getOkCount() + " ok, " +
Healthcheck.getErrCount() + " errors");
}
}

EXAMPLE:HEALTHCHECKSINJAVA
class Healthcheck implements Runnable {
private static int okCount = 0;
private static int errCount = 0;

public static synchronized void addOk() { Healthcheck.okCount++; }
public static synchronized void addErr() { Healthcheck.errCount++; }
public static int getOkCount() { return Healthcheck.okCount; }
public static int getErrCount() { return Healthcheck.errCount; }

public void run() {
try {
if (getStatusCode(this.url) == 200) {
Healthcheck.addOk();
} else {
Healthcheck.addErr();
}
} catch(Exception e) {
Healthcheck.addErr();
}
}

private int getStatusCode(String url) throws Exception {
...
}
}

EXAMPLE:HEALTHCHECKSINGO
type Results struct {
okCount int
errCount int
}

func main() {
urls := []string{"url1", "url2", ...}

r := runChecks(urls)
fmt.Printf("%d ok, %d errorsn", r.okCount, r.errCount)
}

VERSION1:SEQUENTIALCODE
func runChecks(urls []string) Results {
r := Results{}
for _, url := range urls {
resp, err := http.Head(url)
if err != nil || resp.StatusCode != http.StatusOK {
r.errCount++
} else {
r.okCount++
}
}

return r
}

VERSION2:USINGGOROUTINES
r := Results{}
lock := sync.Mutex{}
go func(url string) {
lock.Lock()
r.errCount++
lock.Unlock()
} else {
lock.Lock()
r.okCount++
lock.Unlock()
}
}(url)
}

// Wrong way to wait for goroutines to finish
time.Sleep(2 * time.Second)

return r
}

VERSION3:USINGCHANNELS
r := Results{}
responses := make(chan bool, len(urls))
success := err == nil && resp.StatusCode == http.StatusOK
responses <- success
}(url)
}

for i := 0; i < len(urls); i++ {
success := <-responses
if success {
r.okCount++
} else {
r.errCount++
}
}

return r
}

WHAT'SA
CHANNEL?
a conduit for streaming information
concurrency-safe
allows decoupling between sender and receiver

UNBUFFEREDCHANNELS
sender and receiver block each other
provide guarantee of delivery
stream := make(chan int)
go func() {
stream <- 1
}()
go func() {
<-stream
}()

BUFFEREDCHANNELS
created with a maximum capacity
sender and receiver block each other when it's full
no guarantee of delivery
stream := make(chan int, 1)
go func() {
stream <- 1
stream <- 2 // blocks until the first receiver
}()
go func() {
<-stream // blocks until the first sender
<-stream
}()

CLOSEDCHANNELS
We can't send values anymore (panic!)
We can still receive values sent before closing it
If empty, receiving values gives the zero value of the channel type
ch := make(chan string, 2)
ch <- "foo"
ch <- "bar"
close(ch)

fmt.Println(<-ch) // "foo"
fmt.Println(<-ch) // "bar"
fmt.Println(<-ch) // ""

CLOSEDCHANNELS
How to receive until the channel closes?
If the channel is empty, range blocks until the channel is closed
ch := make(chan string, 2)

go func() {
ch <- "foo"
ch <- "bar"
close(ch)
}()

for v := range ch {
fmt.Println(v)
}

MULTIPLEXINGCHANNELS
If more than one condition is ready, a case is randomly chosen
select {
case v := <-ch1:
fmt.Println("value read from ch1")
case v := <-ch2:
fmt.Println("value read from ch2")
case ch1 <- 10:
fmt.Println("value sent to ch1")
default:
fmt.Println("channels not ready")
}

UNBLOCKINGRECEIVES
ch := make(chan int)
select {
case v, ok := <-ch:
if ok {
fmt.Printf("Value is %d", v)
} else {
fmt.Print("channel is closed")
}
default:
fmt.Print("channel is empty")
}

TIMINGOUT
ch := make(chan int)
select {
case v := <-ch:
fmt.Printf("Value is %d", v)
case <- time.After(2*time.Second):
fmt.Print("no data after 2 seconds")
}

PIPELINES
// Inputs an infinite stream
randomNumbers := func() <-chan int {
go func() {
defer close(stream) // This will never run
for {
stream <- rand.Intn(100)
}
}()
return stream
}

// Transforms
double := func(input <-chan int) <-chan int {
go func() {
defer close(stream)
for i := range input {
stream <- i * 2
}
}()
return stream
}

PIPELINES
// Filters
onlyMultiplesOf10 := func(input <-chan int) <-chan int {
go func() {
defer close(stream)
for i := range input {
if i%10 == 0 {
stream <- i
}
}
}()
return stream
}

pipeline := onlyMultiplesOf10(double(randomNumbers()))
for i := range pipeline { // Infinite loop
fmt.Println(i)
}

LIMITINGTHENUMBEROFRUNNINGGOROUTINES
max := 3 // Max simultaneous goroutines
running := make(chan struct{}, max)

for url := range urls {
running <- struct{}{} // waits for a free slot
defer func() {
<-running // releases slot
}()
// do work
}(url)
}

LIMITINGTHENUMBEROFRUNNINGGOROUTINES
max := 3 // Max simultaneous goroutines
running := make(chan struct{}, max)

go func() {
for range time.Tick(100 * time.Millisecond) {
fmt.Printf("%d goroutines runningn", len(running))
}
}()

running <- struct{}{} // waits for a free slot
defer func() {
<-running // releases slot
}()
// do work
}(url)
}

FORCINGGOROUTINESTOSTOP
Using a done channel
done := make(chan struct{})
go func() {
defer func() {
done <- struct{}{}
}()
bufio.NewReader(os.Stdin).ReadByte() // read input from stdin
}()

go func() {
defer close(stream)
for {
select {
case <-done:
return
default:
}
}
}()
return stream
}

Using context
ctx, cancelFunc := context.WithCancel(context.Background())
go func() {
defer cancelFunc()
}()

go func() {
defer close(stream)
for {
select {
case <-ctx.Done():
return
default:
}
}
}()
return stream
}

Using context with timeout
ctx, cancelFunc := context.WithTimeout(context.Background(), 10*time.Second)
go func() {
defer cancelFunc()
}()

go func() {
defer close(stream)
for {
select {
case <-ctx.Done(): // cancelFunc called or timeout reached
return
default:
}
}
}()
return stream
}

DEADLOCK
ch1 := make(chan int)
ch2 := make(chan int)

go func() {
n := <-ch2
ch1 <- 2 * n
}()

n := <-ch1
ch2 <- 2 * n

DEADLOCK
$ go run main.go
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
main.go:12 +0xaa

goroutine 17 [chan receive]:
main.main.func1(0xc4200720c0, 0xc420072060)
main.go:8 +0x3e
created by main.main
main.go:7 +0x89
exit status 2

GOROUTINELEAK
urls := make(chan string)

go func() {
// defer close(urls)
urls <- "http://example.com/1"
urls <- "http://example.com/2"
}()

go func() {
defer fmt.Println("This will never run")
http.Get(url)
fmt.Println(url)
}
}()

RACEDETECTORTOOL
r := Results{}
lock := sync.Mutex{}
lock.Lock()
r.errCount++
lock.Unlock()
} else {
lock.Lock()
r.okCount++
lock.Unlock()
}
}(url)
}

// Wrong way to wait for goroutines to finish
time.Sleep(2 * time.Second)

return r
}

RACEDETECTORTOOL
$ go build -race
$ ./main
==================
WARNING: DATA RACE
Read at 0x00c4200ee2c0 by main goroutine:
main.runChecks()
main.go:35 +0x16b
main.main()
main.go:45 +0x87

Previous write at 0x00c4200ee2c0 by goroutine 7:
main.runChecks.func1()
main.go:26 +0x178

Goroutine 7 (finished) created at:
main.runChecks()
main.go:18 +0x123
main.main()
main.go:45 +0x87
==================
==================
WARNING: DATA RACE
...
==================
Found 2 data race(s)

RACEDETECTORTOOL
r := Results{lock: &sync.Mutex{}}
var wg sync.WaitGroup
wg.Add(1)
defer wg.Done()
r.lock.Lock()
r.errCount++
r.lock.Unlock()
} else {
r.lock.Lock()
r.okCount++
r.lock.Unlock()
}
}(url)
}

wg.Wait() // Blocks until all `wg.Done()` calls
return r
}

CONCLUSIONS
Go treats concurrency as rst-class citizen
Goroutines make it easier to handle concurrent code
Channels make it easier to share state and handle goroutines
lifecycle
Concurrency problems are still possible
Do not abuse concurrency

THANKYOU!
Slides:
https://blog.guilhermegarnier.com
@gpgarnier
https://blog.guilhermegarnier.com/talk-goroutines/

Goroutines and Channels in practice

More Related Content

What's hot (20)

Similar to Goroutines and Channels in practice (20)

Recently uploaded (20)

Goroutines and Channels in practice