Program stability concepts in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of deferred function with panic

What is the output of this Go program?

Go

package main
import "fmt"
func main() {
    defer fmt.Println("deferred")
    panic("panic occurred")
    fmt.Println("after panic")
}

A deferred

B

deferred
panic: panic occurred

C

after panic
deferred

D

panic: panic occurred
deferred

💡 Hint

Remember that deferred functions run before the program exits due to panic.

In Go, deferred functions run even if a panic occurs. So "deferred" prints before the panic message.

❓ Predict Output

intermediate

Recover usage in goroutine

What will this Go program print?

Go

package main
import (
    "fmt"
    "time"
)
func safeGo() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic")
        }
    }()
    panic("panic in goroutine")
}
func main() {
    go safeGo()
    time.Sleep(100 * time.Millisecond)
    fmt.Println("main finished")
}

A

main finished
Recovered from panic

B

Recovered from panic
main finished

C

panic: panic in goroutine
main finished

D panic: panic in goroutine

💡 Hint

Recover only works if called inside deferred function in the same goroutine.

The panic inside safeGo is recovered, so "Recovered from panic" prints. Then main prints "main finished".

❓ Predict Output

advanced

Race condition detection output

What will happen when running this Go program with the race detector enabled?

Go

package main
import (
    "fmt"
    "sync"
)
func main() {
    var x int
    var wg sync.WaitGroup
    wg.Add(2)
    go func() {
        x = 1
        wg.Done()
    }()
    go func() {
        x = 2
        wg.Done()
    }()
    wg.Wait()
    fmt.Println(x)
}

A Prints 1 or 2, race detector reports data race

B Always prints 1, no race detected

C Compilation error due to missing synchronization

D Always prints 2, no race detected

💡 Hint

Two goroutines write to the same variable without synchronization.

The variable x is written concurrently without locks, causing a data race detected by the race detector.

❓ Predict Output

advanced

Effect of closing a channel twice

What happens when this Go program runs?

Go

package main
func main() {
    ch := make(chan int)
    close(ch)
    close(ch)
}

A Compilation error

B Deadlock error

C Panic: close of closed channel

D Program exits normally

💡 Hint

Closing a channel twice is not allowed in Go.

Closing a channel that is already closed causes a runtime panic.

❓ Predict Output

expert

Output of select with nil channel

What is the output of this Go program?

Go

package main
import "fmt"
func main() {
    var ch chan int // nil channel
    select {
    case ch <- 1:
        fmt.Println("sent 1")
    case <-ch:
        fmt.Println("received")
    default:
        fmt.Println("default case")
    }
}

A default case

B sent 1

C received

D Deadlock

💡 Hint

Operations on nil channels block forever unless default case is present.

Both send and receive on nil channel block, so select chooses default immediately.