Blocking behavior in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to make the main goroutine wait for the other goroutine to finish.

Go

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.[1]()
		fmt.Println("Hello from goroutine")
	}()
	wg.Wait()
}

Drag options to blanks, or click blank then click option'

ADone

Bdone()

CDone()

DWait()

Attempts:

3 left

💡 Hint

Common Mistakes

Using Done() which adds extra parentheses

Using lowercase done instead of Done

Calling Wait instead of Done inside the goroutine

The WaitGroup's Done method signals that a goroutine has finished. The parentheses are already provided in the code.

2fill in blank

medium

Complete the code to send a value into the channel and block until it is received.

Go

package main

import "fmt"

func main() {
	ch := make(chan int)
	go func() {
		fmt.Println("Received:", <-ch)
	}()
	ch[1] 42
}

Drag options to blanks, or click blank then click option'

A<-

B<-chan

C<-chan<-

D<-chan<-chan

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong arrow direction

Confusing channel type syntax with send operation

To send a value into a channel, use the channel name followed by <- and the value.

3fill in blank

hard

Fix the error in the code to avoid deadlock when receiving from the channel.

Go

package main

import "fmt"

func main() {
	ch := make(chan int)
	go func() {
		ch <- 10
	}()
	value := [1]ch
	fmt.Println(value)
}

Drag options to blanks, or click blank then click option'

A<-chan

B<-

Cchan<-

Dchan

Attempts:

3 left

💡 Hint

Common Mistakes

Using channel type syntax instead of receive operator

Omitting the receive operator causing deadlock

To receive a value from a channel, use the <- operator before the channel name.

4fill in blank

hard

Fill both blanks to create a map that stores word lengths only for words longer than 3 characters.

Go

package main

import "fmt"

func main() {
	words := []string{"go", "code", "chat", "ai"}
	lengths := map[string]int{}
	for _, word := range words {
		if len(word) [1] 3 {
			lengths[word] = [2]
		}
	}
	fmt.Println(lengths)
}

Drag options to blanks, or click blank then click option'

A>

Blen(word)

C<

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using less than instead of greater than

Assigning the word instead of its length

We check if the length of the word is greater than 3, then store the length of the word.

5fill in blank

hard

Fill all three blanks to create a map of uppercase words to their lengths for words longer than 2 characters.

Go

package main

import (
	"fmt"
	"strings"
)

func main() {
	words := []string{"go", "code", "chat", "ai"}
	lengths := map[string]int{}
	for _, word := range words {
		if len(word) [1] 2 {
			lengths[[2]] = [3]
		}
	}
	fmt.Println(lengths)
}

Drag options to blanks, or click blank then click option'

A>

Bstrings.ToUpper(word)

Clen(word)

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using less than instead of greater than

Using the original word instead of uppercase

Assigning the word instead of its length

We check if the word length is greater than 2, then store the uppercase word as key and its length as value.

Practice

1. What does blocking mean in Go programming?

easy

A. Running multiple tasks at the same time

B. Waiting for an operation to finish before moving on

C. Ignoring errors in the program

D. Skipping a function call

Solution

1. Step 1: Understand the meaning of blocking

   Blocking means the program waits for something to finish before continuing.

2. Step 2: Match the definition to options

   Waiting for an operation to finish before moving on correctly describes waiting for an operation to finish before moving on.

3. Final Answer:

   Waiting for an operation to finish before moving on -> Option B

4. Quick Check:

   Blocking = Waiting [OK]

Hint: Blocking means waiting, not running or skipping [OK]

Common Mistakes:

• Confusing blocking with concurrency
• Thinking blocking means ignoring errors
• Assuming blocking skips code

2. Which of the following Go code snippets correctly shows a blocking receive on a channel?

easy

A. value := <-ch

B. go func() { <-ch }()

C. ch <- value

D. select { case ch <- value: }

Solution

1. Step 1: Identify blocking receive syntax

   Receiving from a channel blocks until a value is available, done by value := <-ch.

2. Step 2: Check other options

   go func() { <-ch }() launches a goroutine, so receive is not blocking main code. ch <- value sends, not receives. select { case ch <- value: } sends in select, not receive.

3. Final Answer:

   value := <-ch -> Option A

4. Quick Check:

   Blocking receive = value := <-ch [OK]

Hint: Blocking receive uses '<-ch' without goroutine [OK]

Common Mistakes:

• Confusing send and receive syntax
• Thinking goroutine makes receive blocking
• Using select for receive incorrectly

3. What will be the output of this Go program?

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

medium

A. 42

B. 0

C. Compilation error

D. Deadlock runtime error

Solution

1. Step 1: Analyze channel creation and goroutine

   A channel ch is created and a goroutine sends 42 into it.

2. Step 2: Understand blocking receive

   Main goroutine waits on <-ch until value 42 is sent, then prints it.

3. Final Answer:

   42 -> Option A

4. Quick Check:

   Send and receive synchronize, output = 42 [OK]

Hint: Send in goroutine, receive blocks until value arrives [OK]

Common Mistakes:

• Expecting deadlock without goroutine
• Thinking channel defaults to zero value
• Confusing send and receive order

4. Identify the problem in this Go code and fix it:

package main
func main() {
  ch := make(chan int)
  ch <- 10
  val := <-ch
  println(val)
}

medium

A. Compilation error due to missing import; fix by adding fmt package

B. Runtime panic due to nil channel; fix by initializing channel

C. No problem; code runs and prints 10

D. Deadlock because send blocks without receiver; fix by using a goroutine for send

Solution

1. Step 1: Understand channel blocking behavior

   Sending on an unbuffered channel blocks until a receiver is ready.

2. Step 2: Analyze code flow

   Send happens before receive, but no goroutine to receive yet, causing deadlock.

3. Step 3: Fix by sending in a goroutine

   Wrap send in go func() { ch <- 10 }() to allow receive to proceed.

4. Final Answer:

   Deadlock because send blocks without receiver; fix by using a goroutine for send -> Option D

5. Quick Check:

   Send blocks without receiver = deadlock [OK]

Hint: Send blocks if no receiver; use goroutine to avoid deadlock [OK]

Common Mistakes:

• Ignoring deadlock and expecting output
• Adding imports unnecessarily
• Thinking channel is nil

5. You want to receive from two channels ch1 and ch2 but only proceed when both have sent a value. Which approach correctly uses blocking behavior to achieve this?

hard

A. Use a buffered channel to store values from both channels

B. Use a select statement with both channels in one case

C. Receive from ch1 and ch2 sequentially: val1 := <-ch1; val2 := <-ch2

D. Receive from only one channel and ignore the other

Solution

1. Step 1: Understand blocking on multiple channels

   Receiving sequentially from both channels blocks until each sends a value.

2. Step 2: Evaluate options

   Select cannot wait for both simultaneously in one case. Ignoring one channel misses data. Buffered channel does not guarantee both received.

3. Final Answer:

   Receive from ch1 and ch2 sequentially: val1 := <-ch1; val2 := <-ch2 -> Option C

4. Quick Check:

   Sequential receive blocks until both values arrive [OK]

Hint: Receive from each channel one by one to wait for both [OK]

Common Mistakes:

• Using select to wait for both at once
• Ignoring one channel's value
• Assuming buffered channel solves blocking