Go Language Concurrency Concepts Quiz

1. What are Goroutines in Go?

• Goroutines are a type of variable used in Go programming.
• Goroutines are the main function of a Go program.
• Goroutines are complex data structures for handling errors.
• Goroutines are lightweight threads managed by the Go runtime.

2. How are Goroutines different from threads?

• Goroutines cannot run concurrently like threads.
• Goroutines are the same as processes in Go.
• Goroutines use more memory than OS threads.
• Goroutines are more efficient than OS threads.

3. Explain the purpose and usage of the select statement in Go.

• The select statement creates a new goroutine for executing functions.
• The select statement is a mechanism for file I/O operations.
• The select statement is used to define a new package in Go.
• The select statement lets a goroutine wait on multiple communication operations.

4. What is a nil pointer in Go, and how can it cause runtime errors?

• A nil pointer always points to the last allocated object in memory.
• A nil pointer stores a reference to an invalid value, causing runtime warning.
• A nil pointer is a pointer to an empty object that does not allocate memory.
• A nil pointer points to no object, and dereferencing it leads to a runtime panic. Always check if a pointer is nil before dereferencing it.

5. How does Go handle errors, and what is the idiomatic way to return and handle errors?

• Go uses error values as the last return value to indicate errors.
• Go handles errors through global error variables and checks them automatically.
• Go requires that functions return an error code as the primary return value.
• Go throws exceptions to handle errors in try-catch blocks.

6. What is the difference between a slice and an array in Go?

• A slice is a dynamic view of an array; an array is fixed-size.
• A slice is immutable; an array can change size.
• A slice is a sequential collection; an array is unordered.
• A slice can hold different types; an array is type-less.

7. How do you handle concurrency in Go?

• Concurrency in Go is handled using goroutines and channels.
• Concurrency in Go is handled using callbacks and promises.
• Concurrency in Go is handled using global variables for sharing data.
• Concurrency in Go is handled by using threads directly from OS libraries.

8. What is a channel and how is it used in Go?

• A channel is a data structure that allows goroutines to communicate with each other by sending and receiving data. It can be buffered or unbuffered.
• A channel is a variable that stores global constants in Go, ensuring they are immutable.
• A channel is a function feature that transforms strings into byte arrays and vice versa in Go.
• A channel is a data type that defines the structure of a map in Go, but does not allow communication.

9. Explain the purpose of the defer statement.

• The defer statement is used to register error handlers for exceptions.
• The defer statement is used to run a function in parallel with another function.
• The defer statement is used to delay the execution of a function until the surrounding function returns.
• The defer statement is used to immediately execute a function within a loop.

10. How does Go`s garbage collector work?

• Go`s garbage collector relies solely on manual memory management by the programmer.
• Go`s garbage collector compacts memory by moving objects together to reduce fragmentation.
• Go`s garbage collector uses reference counting to manage memory allocation and deallocation.
• Go`s garbage collector uses a concurrent mark-and-sweep algorithm to identify and reclaim unused memory.

11. What is the use of sync.Mutex in Go?

• sync.Mutex is a data type for channels.
• sync.Mutex manages garbage collection tasks.
• sync.Mutex prevents multiple access to critical sections.
• sync.Mutex enables goroutine creation.

12. Explain the difference between buffered and unbuffered channels.

• Unbuffered channels always drop messages.
• Buffered channels can hold multiple values and block when full.
• Unbuffered channels allow sending without blocking.
• Buffered channels block immediately without storing values.

13. What are Go interfaces, and how are they used?

• Go interfaces define a set of methods that a type must implement to satisfy the interface.
• Go interfaces are primarily used for setting up package-level variables across different files.
• Go interfaces are a way to declare global variables for functions and constants.
• Go interfaces allow for creating fixed-size collections of elements of different types.

14. How do you implement dependency injection in Go?

• Dependency injection in Go is done solely through global variables.
• Dependency injection in Go can only be achieved with reflection.
• Dependency injection in Go requires third-party libraries for implementation.
• Dependency injection in Go can be implemented using constructors or functions that take dependencies as arguments.

15. Explain the use of context in Go.

• Context in Go is a placeholder for global variables across packages.
• Context in Go is a data structure for defining variables only.
• Context in Go is used to manage request-scoped values and provide a way to cancel operations.
• Context in Go is used solely for error handling in functions.

16. What is a closure in Go?

• A closure in Go is a built-in data structure for managing state.
• A closure in Go is a generic function without parameters.
• A closure in Go is a function that captures its surrounding state.
• A closure in Go is a type that denotes an interface.

17. How do you ensure a slice is not nil and has a default capacity?

• Create an array first and convert it into a slice later.
• Use make([]Type, 0, capacity) to create a non-nil slice with a default capacity.
• Assign a slice variable to a new instance without a defined length.
• Initialize a slice directly with nil values and a capacity.

18. What are variadic functions in Go?

• Variadic functions in Go are similar to closures, storing variables.
• Variadic functions in Go can only take a fixed number of arguments.
• Variadic functions in Go are functions that can take a variable number of arguments.
• Variadic functions in Go are used exclusively for error handling.

19. How does Go handle memory allocation?

• Go relies solely on stack allocation for all variables.
• Go handles memory allocation using the built-in new and make functions.
• Go uses manual memory management like C.
• Go uses a reference counting mechanism for memory management.

20. Explain how Go’s type assertion works.

• Type assertion in Go is used to assert that a value has a specific type. It can be done using the type assertion operator (T(t)).
• Type assertion in Go checks the memory address of a variable before using it.
• Type assertion in Go compiles code at runtime for performance optimization.
• Type assertion in Go converts a variable to a string regardless of its type.

21. What are Go maps and how do you handle concurrent access to them?

• Go maps are data structures that store key-value pairs. To handle concurrent access, you can use the sync.Map type, which is designed for concurrent access.
• Go maps are simple lists that hold integers. They require locking mechanisms to manage access.
• Go maps are single-threaded data structures. Concurrency is managed by using global variables only.
• Go maps are arrays that do not allow duplicate keys. They can only be accessed by one goroutine at a time.

22. What is a method set in Go?

• A method set in Go is a feature for managing memory allocation.
• A method set in Go refers to the operations performed on a database.
• A method set in Go defines the set of methods attached to a type, which determines the interfaces the type implements.
• A method set in Go is a collection of all global functions in a program.

23. How can you implement a thread-safe singleton in Go?

• Store the instance in a slice and return the last element.
• Initialize a global variable to store the instance without synchronization.
• Use a mutex to lock a variable after creating the instance each time.
• Use sync.Once to ensure a piece of code runs only once, making a thread-safe singleton pattern.

24. How do you convert a string to a byte slice and vice versa in Go?

• Use bytes.NewBuffer() for string to byte and buffer.String() for byte to string.
• Use byte_array() for converting string to bytes and str_conversion() for the inverse.
• Use the []byte() function to convert a string to a byte slice and the string() function to convert a byte slice to a string.
• Use cast() for string to byte conversion, and byte() to string.

25. What is the sync.WaitGroup used for?

• sync.WaitGroup handles network connections automatically.
• sync.WaitGroup is used for sorting slices efficiently.
• sync.WaitGroup is used to wait for a group of goroutines to finish execution.
• sync.WaitGroup encrypts data during transmission.

26. How can you execute shell commands in Go?

• Use the os/exec package to execute shell commands in Go.
• Implement a custom shell command function directly in Go.
• Execute shell commands by calling native system libraries without imports.
• Use the runtime package to run shell commands in Go.

27. Explain the purpose of Go modules.

• Go modules are used to manage dependencies in Go projects.
• Go modules serve to create user interfaces in Go programs.
• Go modules are a way to compile code more efficiently.
• Go modules are used to optimize network connections in Go applications.

28. How do you define and use generics in Go?

• As of Go 1.18, generics are implemented using type parameters. Syntax: func Foo[T any](arg T) { … }
• Generics in Go are defined using struct types and inheritance.
• Generics allow defining functions that can only take string arguments in Go.
• In Go, generics are implemented using global variables for type flexibility.

29. What is the panic and recover mechanism in Go?

• The panic and recover mechanism allows error handling.
• The panic and recover mechanism automatically logs errors.
• The panic and recover mechanism is used for debugging only.
• The panic and recover mechanism stops all goroutines immediately.

30. Explain the difference between new and make.

• new allocates zeroed storage, while make is used for slices, maps, and channels.
• new is used for arrays while make allocates memory.
• new and make are identical functions in Go.
• new is a built-in function while make is not.