Golang - Tutorial

CES-27 Processamento Distribuído
Golang
Prof Juliana Bezerra

Prof Vitor Curtis
What is Go?
• Go (or Golang) is an open source programming language that makes
it easy to build simple, reliable, and efficient software.
▫ https://golang.org/
• History
▫ Started in 2007 by Google
▫ Open and stable version in 2012 Tony Hoare (1934-?)
Turing Award in 1980
▫ Go is based on CSP
▫ CSP
 Communicating Sequential Processes
 Created by Hoare in 1978
 A formal language for describing patterns of interaction in concurrent
systems
 Occam and Erlang are two well known languages that stem from CSP
 One of the most successful models for providing high-level linguistic
support for concurrency
 Paradigm for expressing concurrency based on message-passing
 Models of concurrency: message passing (with processes, messages no shared
data) instead of shared memory (with threads, locks, mutexes)
Motivation to create Go
• Started as an answer to software problems at Google:
▫ multicore processors
▫ networked systems
▫ massive computation clusters
▫ scale:
 10⁷ lines of code
 10³ programmers
 10⁶ machines
• Goals at Google:
▫ To eliminate the slowness of software development
▫ To make the process more productive and scalable
▫ Go was designed by and for people who develop large
software systems
Go deals with concurrency!
• Go provides two important concepts:
▫ goroutine: a thread of control within the program,

with its own local variables and stack. Cheap, easy to
create.
 A goroutine consumes almost 2KB memory from the
heap. Note: Thread in Java consumes 1MB.
 So, you can spin millions of goroutines at any time.
▫ channel: carries typed messages between goroutines.

Example: Hello World
• The Go Playground
• https://play.golang.org/
Example: Visualizing Goroutines
• https://play.golang.org/p/MPV8CdrFWGi
1. What is the result?
2. Try to set zero for sleeping time
3. Try to not set ‘multiplyByTwo’ as goroutine
Example: Adding a channel
• https://play.golang.org/p/mIRGjGxYM3
1. What is the result? See the blocking code!
2. Try to repeat the ‘Println’ command below the current one
3. What can we do to print the result twice?
Example: Two single directional channels
• https://play.golang.org/p/aQIBDS99_d
1. What is the result?
2. See the difference in declaration of channels in ‘multiplyByTwo’ function.
• Try to eliminate channels’ direction here
Example: Multiple concurrent goroutines
• https://play.golang.org/p/8ocrB53QS_
• There is no guarantee as to which goroutine will accept which input, or which goroutine
will return an output first.
• Try to add an ID to goroutines to check the order of response
• Try to make the last goroutine sleep a bit
Example: Producer-Consumer
• The problem
▫ Two processes (the producer and the consumer) who share a common,
fixed-size buffer used as a queue.
▫ The producer's job is to generate data, put it into the buffer, and start
again.
▫ At the same time, the consumer is consuming the data (i.e., removing it
from the buffer), one piece at a time.
▫ The problem is to make sure that the producer won't try to add data into
the buffer if it's full and that the consumer won't try to remove data from
an empty buffer.
• A trivial solution
• This solution contains a race condition that can

lead to a deadlock. E.g:
▫ The consumer has just read the variable itemCount,
noticed it's zero and is just about to move inside the if
block.
▫ Just before calling sleep, the consumer is interrupted
and the producer is resumed.
▫ The producer creates an item, puts it into the buffer,
and increases itemCount.
▫ Because the buffer was empty prior to the last
addition, the producer tries to wake up the consumer.
▫ Unfortunately the consumer wasn't yet sleeping, and
the wakeup call is lost. When the consumer resumes,
it goes to sleep and will never be awakened again.
This is because the consumer is only awakened by the
producer when itemCount is equal to 1.
▫ The producer will loop until the buffer is full, after
which it will also go to sleep.
• A solution using semaphores and mutex
Note: mutex seems to work as a semaphore with value of 1

(binary semaphore), but there is difference in the fact that mutex
has ownership concept. Ownership means that mutex can only be
"incremented" back (set to 1) by the same process that
"decremented" it (set to 0), and all others tasks wait until mutex
is available for decrement (effectively meaning that resource is
available), which ensures mutual exclusivity and avoids deadlock.
• A solution using monitors
Note: A monitor is a shared object with operations (e.g. set data, get data),
internal state, and a number of condition queues. Only one operation of a
given monitor may be active at a given point in time. A process that calls a busy
monitor is delayed until the monitor is free.
Example: Producer-Consumer in Go
• https://play.golang.org/p/a_HBATTBu54
• With explanation: https://gist.github.com/drio/dd2c4ad72452e3c35e7e
• Other way to implement

consume
• Original: https://play.golang.org/p/a_HBATTBu54
• Test with 2 producers and 1 consumer
▫ Is it ok?
▫ What do we need to consume all messages?

 https://play.golang.org/p/C7rHvuSHf1Z
• Original: https://play.golang.org/p/a_HBATTBu54
• Test with 1 producer and 2 consumers
▫ Add an id to consumers to identify them
▫ Is it ok?
▫ What do we need to see both consumers operating?

 https://play.golang.org/p/N7Nu9clWKUl
Tips for non-blocking operations in Go
• Channel has size 1
▫ It synchronizes the production with the consumption
• Using buffered channels
▫ Consider a channel of ‘Item’. E.g. int
▫ For producer For consumer

Tips for non-blocking operations in Go
• Closing buffered channels
▫ Consider a channel of ‘Item’. E.g. int
▫ For producer
 Buffered channels are best closed by producers
 The channel close event is signaled to the consumers
 You can not write to closed channels
▫ For consumer
 If there are items yet to be popped off, the popping off happens as usual.
 When the queue is empty and closed, the read will not block. It returns “zero-
value” of the channel item type.
We can also combine the non-blocking and

A solution: to know if the received value is valid
valid checks into one
OR
• Original:
https://play.golang.org/p/a_HBATTBu54
• Test with buffered channel

▫ 1. Add the channel dimension. E.g. 5
 Why the output prints only until 6?
▫ 2. Try to run ‘consume’ not as a gorountine

 Eliminate the ‘go’ directive
 Why occurs a deadlock at the end?
▫ A possible answer
 Producer close the channel after his
production
 Consumer consumes everything in buffer,
but it knows when it is empty and closed
 To keep ‘consume’ as goroutine, it needs to
inform the ‘main’ when finishing (idea
similar to ‘done’ channel)
 https://play.golang.org/p/B0tLTKJzbhX
Other benefits of Go
• Goroutines have growable segmented stacks
▫ It means they will use more memory only when
needed.
• Goroutines have a faster startup time than threads
• Goroutines come with built-in primitives to

communicate safely between themselves (channels)
• Goroutines and OS threads do not have 1:1 mapping

▫ A single goroutine can run on multiple threads
Goroutines are multiplexed into small number of OS
threads
Other benefits of Go
• Go uses Static Type System
▫ Type system is really important for large scale applications.
• Go uses garbage collection to allocation and removal of

the object
▫ So, no more malloc() and free() statements!!!
• Go is compiled language.
▫ It means performance is almost nearer to lower level
languages.
Install Go
• Install:
▫ http://golang.org/doc/install.html
• IDEs
Editores de texto
A simple, open source,

cross-platform Go IDE.
With debugging
Extras
Why do we need concurrency?
• Hardware limitations
▫ Comparison of increasing the processing power with the
time:
 Single-thread performance and the frequency of the

processor remained steady for almost a decade.
 Adding more transistor is not the solution: cost and quantum
properties (like tunneling)
Why do we need concurrency?
• Solutions for hardware limitations
▫ More cores to the processor Cost
▫ More cache to the processor Physical limits: the bigger the

cache, the slower it gets
▫ Hyper-threading
CONCURRENC Y
If we cannot rely on the hardware improvements,

the only way to go is more efficient software to
increase the performance

Golang - Tutorial

Uploaded by

Golang - Tutorial

Uploaded by

CES-27 Processamento Distribuído

Prof Juliana Bezerra

▫ goroutine: a thread of control within the program,

▫ channel: carries typed messages between goroutines.

• This solution contains a race condition that can

Note: mutex seems to work as a semaphore with value of 1

• Other way to implement

▫ What do we need to consume all messages?

▫ What do we need to see both consumers operating?

• Using buffered channels

▫ Consider a channel of ‘Item’. E.g. int

▫ For producer For consumer

We can also combine the non-blocking and

• Test with buffered channel

▫ 2. Try to run ‘consume’ not as a gorountine

• Goroutines have a faster startup time than threads

• Goroutines come with built-in primitives to

• Goroutines and OS threads do not have 1:1 mapping

• Go uses garbage collection to allocation and removal of

A simple, open source,

 Single-thread performance and the frequency of the

▫ More cache to the processor Physical limits: the bigger the

If we cannot rely on the hardware improvements,

You might also like