Concurrent Programming with Go

Question 1

What is the difference between concurrency and multi tasking?

Answer 1

Concurrency is having multiple tasks but executing a piece of each in a single thread and parallelism is to execute multiple tasks simultaneously.

Question 2

How do we call a []int?

Answer 2

Slice of int.

Question 3

What does this code do?

if b, ok := methd(); ok {fmt.println(“ok”)}

Answer 3

Will print ok if ok is true.

Question 4

Do threads and goroutine have its own stack? How big is the stack in each case?

Answer 4

Yes. OS has ~1MB and goroutine starts at 2KB.

Question 5

Can the goroutine stack grow?

Answer 5

Yes.

Question 6

Who manages the threads and the goroutines?

Answer 6

OS and go runtime respectively.

Question 7

How to create an anonymous function in go?

Answer 7

var abc := 1;
func (param int) {
}

Question 8

Should we share values from the main thread stack with goroutines? How to pass then?

Answer 8

No. Via params.

Question 9

What happens if your main function calls a go routine and do not wait for it?

Answer 9

It finishes (and the app exits) prematurely and the goroutine won’t finish in time.

Question 10

What are the two main challenges of concurrency?

Answer 10

Coordinate tasks and share memory between the tasks and main thread.

Question 11

What does the sync.WaitGroup do?

Answer 11

Waits for a collection of goroutines to finish.

Question 12

What does a mutex do?

Answer 12

Ensures that a shared variable is accessed only once even when multiple goroutines try to access it at the same time

Question 13

What does the “–race” in go run –race main.go do?

Answer 13

It adds instrumentation to the executable to find and report racing conditions.

Question 14

What is the warning generated by a racing condition when using –race flag?

Answer 14

WARNING: DATA RACE

Question 15

Is the DATA RACE warning only generated when something fails?

Answer 15

No, it reports the racing condition even when the application does not panic.

Question 16

How to create a mutex? Should we pass a copy of the mutex to the methods or the pointer?

Answer 16

m := &sync.mutex{}. Pass *m (as pointer).

Question 17

What is the downside of using the “raw” sync.mutex? How to solve it?

Answer 17

Read operations should not block each other, only the write operation should block reads. Using RWMutex instead.

Question 18

How to use a RWMutex?

Answer 18

RLock() to lock reads and Lock() to lock write operations.

Question 19

When is best using RWMutex? Why not using it every time?

Answer 19

When read operations are much more often than write operations. It has some performance penalties when compared to a regular mutex.

Question 20

What does the defer fmt.PrintLn(“Hi”) do?

Answer 20

Is executed after the nearest enclosing brackets is found.

Question 21

What does Rob Pike says about mutexes and shared memory?

Answer 21

Don’t communicate by sharing memory, share memory by communicating.

Question 22

What is the difference between unbuffered and buffered channels?

Answer 22

Unbuffered has to have a matching writer and receiver and unbuffered can define how many messages can exist without a receiver.

Question 23

Is a channel bidirectional by default? Can I have send-only and receive-only channels?

Answer 23

Yes. Yes.

Question 24

How to close a channel? What happens when an app tries to send data in the channel? What happens when it reads from a closed one?

Answer 24

Close(ch). The app panics. It reads the default value (0 for int).

Question 25

Cite 1 usecase for closing a channel.

Answer 25

When you iterate over a channel (waiting for messages), e.g for msg := range ch {}. The loop will only exits when the channel is closed.