Concurrency Quiz - Languages Golang

Free practice quiz: Concurrency (Languages Golang). 52 multiple-choice questions with answers and explanations. Play online, no sign-up needed.

This Languages Golang practice quiz has 52 multiple-choice questions on Concurrency, and 52 of them come with an explanation. Try the 5 sample questions below (tap an option to check yourself), then play the full quiz online. No sign-up needed.

Sample questions

1. In Go, what is the primary mechanism for achieving concurrency?

   1. Threads and Locks
   2. Goroutines and Channels
   3. Processes and Message Queues
   4. Async/Await patterns
   Show answer

   Answer: B. Goroutines and Channels

   Go's concurrency model is built around lightweight, independently executing functions called goroutines, and a powerful communication mechanism called channels, which are used for safe data exchange between goroutines.

2. When using unbuffered channels in Go, what is the behavior of a send operation?

   1. It succeeds immediately and returns
   2. It blocks until a receiving goroutine is ready to receive the value
   3. It is placed in a buffer and continues immediately
   4. It causes a panic if no receiver is ready
   Show answer

   Answer: B. It blocks until a receiving goroutine is ready to receive the value

   Unbuffered channels require both the sender and receiver to be ready simultaneously for a communication to occur. This is known as rendezvous.

3. In Go, what is the `nil` channel behavior when used with `select`?

   1. A `select` statement with a `nil` channel case will never be chosen
   2. A `select` statement with a `nil` channel case will always be chosen
   3. A `select` statement with a `nil` channel case will cause a panic
   4. A `select` statement with a `nil` channel case will block indefinitely if other cases are also blocked
   Show answer

   Answer: A. A `select` statement with a `nil` channel case will never be chosen

   Receive or send operations on a `nil` channel block forever. Therefore, a `select` statement that includes a case involving a `nil` channel will never proceed on that case if there are other valid (non-`nil`) cases available. If all cases are `nil` or blocked, the `select` will block.

4. Consider a scenario where multiple goroutines are writing to the same `map[string]int`. What is the most appropriate way to ensure thread safety?

   1. Use a `sync.WaitGroup` to coordinate the goroutines.
   2. Use a `sync.RWMutex` to protect the map.
   3. Use a buffered channel to send map updates.
   4. Use `sync.Once` to initialize the map.
   Show answer

   Answer: B. Use a `sync.RWMutex` to protect the map.

   Maps in Go are not inherently safe for concurrent read/write access. A `sync.RWMutex` is ideal here because it allows multiple readers to access the map concurrently, while writes are exclusive. A regular `sync.Mutex` would also work but would be less performant if reads are frequent.

5. Which Go package provides synchronization primitives like Mutexes, WaitGroups, and Once?

   1. fmt
   2. net/http
   3. sync
   4. context
   Show answer

   Answer: C. sync

   The `sync` package in Go's standard library offers essential primitives for building concurrent programs, including `Mutex`, `RWMutex`, `WaitGroup`, `Once`, `Cond`, and `Pool`.

More questions in this quiz

Answers and explanations are in the full quiz.

1. What is a goroutine in Go?
2. Which keyword is used to launch a goroutine in Go?
3. What is a channel in Go used for?
4. What does it mean for a channel to be buffered in Go?
5. What is the purpose of `sync.WaitGroup` in Go?
6. What is a mutex in Go, and what is its primary purpose?
7. In Go, how can you detect if a channel is closed?
8. What is the Go keyword used to signal that a goroutine has completed its work on a `sync.WaitGroup`?
9. What is a 'select' statement in Go concurrency?
10. What is the Go `context` package primarily used for in concurrent programming?
11. Consider the following Go code snippet. What is the most likely output if the `wg.Add(1)` is called before `go func() {...}()`?
12. What is the purpose of `sync.Mutex` in Go?
13. Which of the following correctly describes a potential issue with using `select` in Go when all cases are blocked indefinitely?
14. What is the Go construct used for managing a pool of workers that process tasks from a channel?
15. What is the `sync.RWMutex` in Go?
16. When a channel is closed in Go, what happens when a goroutine attempts to send a value to it?
17. What is the purpose of `defer` in Go concurrency?
18. What is the Go `sync.Once` type used for?
19. What happens if you try to close an already closed channel in Go?
20. What is the purpose of `sync.Cond` in Go?
21. When a buffered channel in Go is full, what is the behavior of a send operation?
22. What is a 'fan-out' pattern in Go concurrency?
23. What is a 'fan-in' pattern in Go concurrency?
24. What does the `context.WithCancel` function return?
25. What is the output of the following Go code and why?
26. What is a 'done' channel in Go used for?
27. What is the default behavior of a channel send operation if there is no receiver ready?
28. Which of the following is NOT a valid way to synchronize goroutines in Go?
29. What is the main difference between `sync.Mutex` and `sync.RWMutex`?
30. What is the purpose of `sync.Once`'s `Do` method?
31. In Go, what is the 'worker pool' concurrency pattern?
32. What is the difference between `context.WithCancel`, `context.WithDeadline`, and `context.WithTimeout`?
33. What happens when a `select` statement has multiple cases that are ready to proceed simultaneously?
34. What is the purpose of a "ping-pong" pattern in Go concurrency?
35. Which of the following is true about Go's scheduler?
36. What is a common way to signal multiple goroutines to shut down gracefully in Go?
37. What does the `context.Context` interface represent?
38. What is the purpose of a `select` statement with a `default` case?
39. What is the outcome of receiving from a closed, empty buffered channel in Go?
40. What is the main concern when multiple goroutines access and modify shared variables without synchronization?
41. What is the role of `sync.Map.LoadOrStore`?
42. In Go, what is a 'context cancellation signal' used for?
43. What is the primary purpose of `sync.Barrier`?
44. What is the correct way to create a buffered channel of integers with a capacity of 5 in Go?
45. What does the `select` statement guarantee if multiple cases are ready?
46. What is the primary function of `sync.Pool.Get()`?
47. What is the purpose of `context.WithValue`?

More quizzes

• Syntax▶ Play
• Web Development▶ Play

Browse all Golang quizzes

More to play