Channel closing behavior in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of reading from a closed channel?

Consider the following Go code. What will be printed when reading from a closed channel?

Go

package main
import "fmt"
func main() {
    ch := make(chan int)
    go func() {
        ch <- 42
        close(ch)
    }()
    val, ok := <-ch
    fmt.Println(val, ok)
    val, ok = <-ch
    fmt.Println(val, ok)
}

A

42 true
0 false

B

42 true
42 true

C

0 false
0 false

D

42 false
0 false

💡 Hint

Think about what happens when you read from a closed channel in Go.

When a channel is closed, reading from it returns the zero value and false for the second value. The first read gets the sent value 42 and ok=true. The second read gets zero value 0 and ok=false.

❓ Predict Output

intermediate

What happens when closing a nil channel?

What will happen if you try to close a nil channel in Go?

Go

package main
func main() {
    var ch chan int
    close(ch)
}

A Deadlock at runtime

B Program exits normally

C Compilation error: cannot close nil channel

D Panic: close of nil channel

💡 Hint

Think about what nil means for channels and what close expects.

Closing a nil channel causes a runtime panic because nil channels are not initialized and cannot be closed.

❓ Predict Output

advanced

What is the output when closing a channel twice?

What happens when you close a channel twice in Go? Consider this code:

Go

package main
import "fmt"
func main() {
    ch := make(chan int)
    close(ch)
    close(ch)
    fmt.Println("Done")
}

A Panic: close of closed channel

B Prints "Done" and exits normally

C Compilation error: cannot close channel twice

D Deadlock at runtime

💡 Hint

Think about what Go does if you close a channel that is already closed.

Closing a channel twice causes a runtime panic with message 'close of closed channel'.

❓ Predict Output

advanced

What is the output of range over a closed channel?

What will this program print?

Go

package main
import "fmt"
func main() {
    ch := make(chan int)
    go func() {
        for i := 1; i <= 3; i++ {
            ch <- i
        }
        close(ch)
    }()
    for v := range ch {
        fmt.Print(v, " ")
    }
}

A 1 2 3 0

B 1 2 3

C 1 2

D Deadlock at runtime

💡 Hint

Remember how ranging over a channel works when it is closed.

The range loop reads all values sent before the channel is closed, then exits cleanly.

🧠 Conceptual

expert

What is the behavior of sending on a closed channel?

What happens if you try to send a value on a closed channel in Go?

A The send succeeds and the value is lost

B The send blocks forever causing a deadlock

C The program panics at runtime with 'send on closed channel'

D The value is silently discarded

💡 Hint

Think about what Go does to prevent sending on closed channels.

Sending on a closed channel causes a runtime panic with message 'send on closed channel'.

Practice

1. What happens when you close a channel in Go?

easy

A. The channel is deleted from memory immediately

B. Senders can still send values without error

C. Receivers know no more values will be sent

D. The channel blocks all operations permanently

Solution

1. Step 1: Understand channel closing purpose

   Closing a channel signals receivers that no more values will be sent.

2. Step 2: Effects on senders and receivers

   Senders cannot send after closing; receivers get zero value and ok=false.

3. Final Answer:

   Receivers know no more values will be sent -> Option C

4. Quick Check:

   close(channel) signals receivers [OK]

Hint: Closing signals receivers no more data comes [OK]

Common Mistakes:

• Thinking senders can send after close
• Believing channel is deleted immediately
• Assuming channel blocks forever after close

2. Which of the following is the correct way to close a channel named ch in Go?

easy

A. ch.Close()

B. ch.close()

C. close channel ch

D. close(ch)

Solution

1. Step 1: Recall Go syntax for closing channels

   The built-in function close() is used with the channel as argument.

2. Step 2: Identify correct syntax

   Only close(ch) is valid; methods like ch.close() or ch.Close() do not exist.

3. Final Answer:

   close(ch) -> Option D

4. Quick Check:

   Use close(channel) syntax [OK]

Hint: Use built-in close(channel) function [OK]

Common Mistakes:

• Trying to call close as a method
• Using incorrect keywords like 'close channel'
• Capitalizing close as Close

3. What is the output of this Go program?

package main
import "fmt"
func main() {
  ch := make(chan int, 2)
  ch <- 10
  ch <- 20
  close(ch)
  for v := range ch {
    fmt.Print(v, " ")
  }
}

medium

A. 10 20

B. 10 20 0

C. Runtime panic: send on closed channel

D. No output

Solution

1. Step 1: Understand channel buffering and closing

   Channel has buffer size 2, two values sent, then channel closed.

2. Step 2: Loop over channel with range

   Range reads all values until channel is closed and drained, printing 10 and 20.

3. Final Answer:

   10 20 -> Option A

4. Quick Check:

   Range over closed channel prints buffered values [OK]

Hint: Range prints all buffered values before stopping [OK]

Common Mistakes:

• Expecting panic on reading closed channel
• Thinking zero value prints after buffered values
• Assuming no output because channel is closed

4. Identify the error in this Go code snippet:

ch := make(chan int)
go func() {
  for i := 0; i < 3; i++ {
    ch <- i
  }
  close(ch)
}()
for {
  v, ok := <-ch
  if !ok {
    break
  }
  fmt.Println(v)
}

medium

A. Channel is unbuffered but sender is in goroutine, no deadlock

B. No error, code runs and prints 0 1 2

C. Closing channel inside goroutine causes panic

D. Receiver loop never ends, causing infinite loop

Solution

1. Step 1: Analyze channel usage and goroutine

   Unbuffered channel with sender in goroutine sends 3 values then closes channel.

2. Step 2: Check receiver loop behavior

   Receiver reads values until channel closes, then breaks loop correctly.

3. Final Answer:

   No error, code runs and prints 0 1 2 -> Option B

4. Quick Check:

   Proper close and ok check ends loop [OK]

Hint: Use ok to detect closed channel and break loop [OK]

Common Mistakes:

• Thinking closing in goroutine causes panic
• Assuming infinite loop without break
• Ignoring need to check ok when receiving

5. Consider this Go program:

package main
import "fmt"
func main() {
  ch := make(chan int)
  go func() {
    for i := 1; i <= 3; i++ {
      ch <- i
    }
    close(ch)
  }()
  for {
    v, ok := <-ch
    if !ok {
      break
    }
    if v%2 == 0 {
      fmt.Println(v)
    }
  }
}

What is the output and why?

hard

A. 2
Only even numbers printed before channel closes

B. 1
2
3
All numbers printed despite channel closing

C. No output because channel is closed before reading

D. Runtime panic due to sending on closed channel

Solution

1. Step 1: Understand sending and closing in goroutine

   Values 1, 2, 3 sent then channel closed properly.

2. Step 2: Receiver loop filters even numbers

   Loop reads until closed; prints only values where v%2 == 0, which is 2.

3. Final Answer:

   2 Only even numbers printed before channel closes -> Option A

4. Quick Check:

   Filter with condition inside loop after close [OK]

Hint: Filter values after reading until channel closes [OK]

Common Mistakes:

• Expecting all values printed
• Thinking channel closes before sending
• Assuming panic on close with goroutine sender