Master Go Interview Essentials: Concurrency, Interfaces, GC, and More

1. Go Concurrency

Goroutine is not a thread; it is a lightweight coroutine scheduled by the Go runtime.

Lightweight: initial stack 2KB, grows as needed.

High concurrency: can run hundreds of thousands of goroutines.

The underlying scheduling model is the GMP model:

G – Goroutine (coroutine)

M – Machine (OS thread)

P – Processor (local run queue)

Work‑stealing algorithm steps:

G is enqueued to a local P queue.

M fetches tasks from P to execute.

If a P is empty, an idle M steals half of the Gs from another non‑empty P.

Channel: safe communication and synchronization

Channel is the core communication mechanism in Go concurrency.

Buffered: send is non‑blocking, receive blocks.

Unbuffered: send and receive must pair, otherwise they block.

func main() {
    c := make(chan int)
    go func() {
        fmt.Println("sub goroutine starts")
        c <- 42
        fmt.Println("sub goroutine sent")
    }()
    fmt.Println("main goroutine waiting")
    val := <-c
    fmt.Println("main goroutine received:", val)
}

Key points:

Unbuffered channel (synchronous) blocks the sender until a receiver is ready.

Buffered channel (asynchronous) allows a limited number of sends without blocking. select enables fair scheduling and timeout control.

Interview tip: channel implementation uses a mutex plus a FIFO queue; understanding this helps analyze deadlocks and performance issues.

func main() {
    ch := make(chan int)
    ch <- 1 // fatal error: all goroutines are asleep - deadlock!
}

Main goroutine blocks on send.

No other goroutine receives → deadlock.

2. Go Interface

An interface is an implicit behavioral contract: no explicit implements declaration is needed; a type satisfies an interface if its method set matches.

type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }

func main() {
    var s Speaker = Dog{}
    fmt.Println(s.Speak()) // Woof
}

Underlying structures:

Empty interface ( eface) stores type and data pointers.

type eface struct {
    _type *_type
    data  unsafe.Pointer
}

Non‑empty interface ( iface) stores a method table.

type iface struct {
    tab  *itab
    data unsafe.Pointer
}

type itab struct {
    inter *interfacetype
    _type *_type
    fun   []uintptr
}

Key insights:

Method tables enable dynamic calls. interface(nil) != (*T)(nil).

Interfaces can cause heap escape, affecting performance.

3. Go Garbage Collection

GC consists of three phases:

Mark – scan all reachable objects.

Sweep – reclaim unreachable objects.

Concurrent GC – reduces stop‑the‑world time.

Three‑color marking algorithm:

White: potential garbage, not visited, will be reclaimed.

Gray: reachable but not fully scanned.

Black: fully scanned, live objects.

Write barrier enforces the invariant that black objects never point directly to white objects; on each pointer write, the affected objects are marked gray.

Analogy: when placing any item into a room already checked (black), you must notify the collector and mark the item gray.

4. Go Toolchain

Escape analysis

go build -gcflags='-m' main.go
# Use -m=2 for more detailed escape reports

pprof performance analysis

go tool pprof http://localhost:6060/debug/  // import _ "net/http/pprof" first

Race detector

go run -race main.go

5. Error Handling

func main() {
    err := loadConfig()
    if errors.Is(err, ErrNotFound) {
        fmt.Println("Error: The specific item was not found.")
    } else {
        fmt.Println("Error: Some other error occurred.")
    }

    var dbErr *DatabaseError
    if errors.As(err, &dbErr) {
        fmt.Printf("Extracted DB Error Code: %d, Message: %s
", dbErr.Code, dbErr.Msg)
    } else {
        fmt.Println("Not a DatabaseError type.")
    }
}

errors.Is

– checks underlying error type. errors.As – converts to a specific error type.

Interview tip: adopt a three‑layer error architecture – business errors, domain errors, system errors.

6. Struct Memory Layout

type A struct { a int8; b int64; c int8 }
type B struct { a int8; c int8; b int64 }

Struct A occupies 24 bytes.

Struct B occupies 16 bytes.

The Go compiler aligns fields according to memory‑alignment rules; fields are placed in the order defined, but padding may be inserted.

Optimization tips:

Group small fields together.

Place large fields later.

Avoid interleaving bool/byte/pointer fields.

Interview point: understanding padding and alignment helps write high‑performance structs.

7. High‑Frequency Interview Questions & Interactive Exercises

Typical questions include:

Goroutine vs OS thread.

Role of P in the GMP model.

Interface underlying structure.

Why interface(nil) != (*T)(nil).

Go GC three‑color marking principle.

Impact of struct field order on memory layout.

Difference between errors.Is and errors.As.

How a channel can cause deadlock.

Interactive exercises:

Write an example that causes escape and explain why.

Implement a safe communication scenario using a channel.

Create a mock type that satisfies an interface.

Conclusion

This article links the core Go capabilities—concurrency model (goroutine, GMP, channel), interface implementation, GC three‑color marking and write barriers, toolchain utilities (escape analysis, pprof, race detector), error handling layers, and struct memory‑layout optimization—providing classic examples, interview questions, and interactive practice to help readers move from “can write Go” to “understand Go deeply” and succeed in interviews.