400 Golang Interview Questions with Answers 2026

Concurrency: Worker Pools, select patterns, context cancellation, and race detection.

Architecture: Interface-driven design, Hexagonal Architecture, and Sentinel errors.

Tooling & Observability: Pprof profiling, Benchmarking, and OpenTelemetry integration.

Production & Security: gRPC, Protobuf, SQL injection prevention, and Distroless Docker builds.

B) It is a local context that holds the runqueue of goroutines to be executed on an M.

C) It acts as a garbage collection trigger when heap threshold is reached.

D) It manages the network poller for non-blocking I/O operations.

E) It is a physical CPU core assigned strictly to one goroutine.

F) It is a synonym for the main goroutine's stack frame.

Correct Answer: B

Overall Explanation: The P (Processor) acts as a resource mediator between Goroutines (G) and Machine threads (M), allowing for efficient "work-stealing" and scheduling scalability.

Detail Explanation:

B) Correct: P provides the context and local runqueue needed to execute Gs on an M.

C) Incorrect: GC is managed by the runtime coordinator, not specifically the 'P' abstraction.

D) Incorrect: The Network Poller is a separate runtime component.

E) Incorrect: P is a logical processor, not a fixed physical core.

F) Incorrect: Stack frames are part of the 'G' structure.

Question 2: Which scenario is most likely to cause a memory leak in a concurrent Go application?

B) Forgetting to close a response body in an HTTP handler.

C) Writing to a buffered channel that has reached its capacity.

D) Launching a goroutine that blocks on a channel that is never closed or written to.

E) Using Locker interfaces instead of concrete sync.Mutex types.

F) Declaring a global slice and appending data to it periodically.

Correct Answer: D

Overall Explanation: Goroutine leaks occur when a goroutine is started but can never exit because it is waiting on a synchronization primitive that will never be satisfied.

Detail Explanation:

B) Incorrect: This leaks file descriptors/connections, but 'D' is a more fundamental Go-specific concurrency leak.

C) Incorrect: This causes a block/slowdown, but not necessarily a permanent leak if the reader eventually proceeds.

D) Correct: This is a classic "zombie" goroutine that remains in memory forever.

E) Incorrect: Interfaces do not cause memory leaks.

F) Incorrect: While this grows memory, it's a logic error rather than a specific concurrency leak pattern.

Question 3: When should you prefer using an io.Reader interface over passing a []byte slice in a function signature?

B) When you want to ensure the function can only read the data once.

C) To allow the function to process data streams of unknown size without loading everything into RAM.

D) When you need to use the unsafe package for pointer arithmetic.

E) To force the compiler to move the variable from the stack to the heap.

F) When you are strictly working with JSON-encoded data only.

Correct Answer: C

Overall Explanation: The io.Reader interface enables streaming and memory efficiency, adhering to the "Accept interfaces, return structs" proverb.

Detail Explanation:

B) Incorrect: While readers are often consumed, that isn't the primary architectural reason.

C) Correct: Streaming via io.Reader prevents OOM (Out of Memory) errors for large files or network streams.

D) Incorrect: io.Reader has no direct relation to the unsafe package.

E) Incorrect: Escape analysis is handled by the compiler regardless of the interface usage.

F) Incorrect: Readers are used for any binary or text data, not just JSON.

This is a huge original question bank

You get support from instructors if you have questions

Each question has a detailed explanation

Mobile-compatible with the Udemy app

30-day money-back guarantee if you're not satisfied