Concurrent execution model in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start a new goroutine that prints "Hello".

Go

go [1]()

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

Afmt.Println

BprintHello

Cmain

DhelloWorld

Attempts:

3 left

💡 Hint

Common Mistakes

Using fmt.Println directly after go without parentheses.

Trying to start a goroutine with a variable name instead of a function.

The go keyword starts a new goroutine. You need to call a function name after it. Here, printHello is the function that prints "Hello".

2fill in blank

medium

Complete the code to wait for the goroutine to finish using a channel.

Go

done := make(chan bool)
go func() {
    fmt.Println("Working...")
    done[1]true
}()
<-done

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

A<-

B:=

C->

D=

Attempts:

3 left

💡 Hint

Common Mistakes

Using assignment = instead of channel send operator.

Using -> which is invalid in Go.

To send a value into a channel, use the <- operator pointing to the channel. Here, done <- true sends true to the done channel.

3fill in blank

hard

Fix the error in the code to correctly launch a goroutine with a parameter.

Go

func printNumber(n int) {
    fmt.Println(n)
}

func main() {
    for i := 1; i <= 3; i++ {
        go printNumber([1])
    }
    time.Sleep(time.Second)
}

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

A&i

B3

Ci+1

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the address of i causing all goroutines to print the last value.

Passing a constant instead of the loop variable.

The loop variable i is passed directly to the goroutine function. This captures the current value correctly. Using &i would pass the address, causing all goroutines to print the same value.

4fill in blank

hard

Fill both blanks to create a buffered channel and send two values without blocking.

Go

ch := make(chan int, [1])
ch[2] 1
ch <- 2

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

A2

B<-

C=

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using assignment = instead of send operator.

Creating an unbuffered channel which blocks on send.

A buffered channel with capacity 2 allows sending two values without blocking. The send operator <- is used to send values into the channel.

5fill in blank

hard

Fill all three blanks to create a select statement that waits on two channels and prints which one received a value.

Go

select {
case msg1 := <-[1]:
    fmt.Println("Received from", [2], ":", msg1)
case msg2 := <-[3]:
    fmt.Println("Received from", "chan2", ":", msg2)
}

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

Achan1

B"chan1"

Cchan2

D"chan2"

Attempts:

3 left

💡 Hint

Common Mistakes

Using channel variables as strings in print statements.

Mixing up channel names and string literals.

The select waits on channels chan1 and chan2. The printed name is a string, so "chan1" is used to show the channel name in output.

Practice

1. What is a goroutine in Go's concurrent execution model?

easy

A. A lightweight thread managed by the Go runtime

B. A type of variable used for synchronization

C. A special function that runs only once

D. A package for handling errors

Solution

1. Step 1: Understand goroutine concept

   A goroutine is a function or method that runs concurrently with other goroutines.

2. Step 2: Identify goroutine characteristics

   It is lightweight and managed by Go's runtime, unlike OS threads which are heavier.

3. Final Answer:

   A lightweight thread managed by the Go runtime -> Option A

4. Quick Check:

   Goroutine = lightweight thread [OK]

Hint: Goroutine = lightweight thread in Go [OK]

Common Mistakes:

• Confusing goroutine with OS thread
• Thinking goroutine is a variable type
• Assuming goroutine runs only once

2. Which of the following is the correct syntax to start a goroutine that calls function doWork()?

easy

A. go doWork()

B. goroutine doWork()

C. start doWork()

D. run doWork()

Solution

1. Step 1: Recall goroutine syntax

   In Go, to start a goroutine, prefix the function call with the keyword go.

2. Step 2: Match syntax with options

   Only go doWork() uses the correct keyword and syntax.

3. Final Answer:

   go doWork() -> Option A

4. Quick Check:

   Start goroutine with 'go' keyword [OK]

Hint: Use 'go' before function call to start goroutine [OK]

Common Mistakes:

• Using 'goroutine' keyword instead of 'go'
• Using 'start' or 'run' which are invalid
• Omitting the 'go' keyword

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

package main
import (
  "fmt"
  "time"
)
func main() {
  go fmt.Println("Hello from goroutine")
  fmt.Println("Hello from main")
  time.Sleep(100 * time.Millisecond)
}

medium

A. No output

B. Hello from goroutine\nHello from main

C. Hello from main

D. Hello from main\nHello from goroutine

Solution

1. Step 1: Understand goroutine and main execution

   The goroutine prints "Hello from goroutine" concurrently, while main prints "Hello from main" immediately.

2. Step 2: Analyze timing with Sleep

   The time.Sleep allows the goroutine time to run before the program exits, so both lines print.

3. Final Answer:

   Hello from main\nHello from goroutine -> Option D

4. Quick Check:

   Sleep allows goroutine output after main [OK]

Hint: Sleep lets goroutine finish before program ends [OK]

Common Mistakes:

• Ignoring need for sleep to let goroutine run
• Assuming goroutine output always prints first
• Expecting no output due to race condition

4. Identify the error in this Go code snippet that tries to run a goroutine:

package main
import "fmt"
func main() {
  go func() {
    fmt.Println("Running")
  }()
}

medium

A. Missing import of time package

B. Program exits before goroutine runs

C. Syntax error in anonymous function

D. Cannot use go with anonymous functions

Solution

1. Step 1: Check syntax correctness

   The anonymous function syntax and goroutine start are correct; no syntax errors.

2. Step 2: Analyze program flow

   The main function exits immediately after starting the goroutine, so "Running" may never print.

3. Final Answer:

   Program exits before goroutine runs -> Option B

4. Quick Check:

   Program ends before goroutine runs [OK]

Hint: Add sleep or sync to wait for goroutine [OK]

Common Mistakes:

• Thinking syntax is wrong for anonymous goroutine
• Forgetting program ends immediately
• Assuming goroutine blocks main automatically

5. You want to run 3 goroutines that each print their number (1, 2, 3). Which code correctly prints all numbers reliably before the program exits?

package main
import (
  "fmt"
  "sync"
)
func main() {
  var wg sync.WaitGroup
  for i := 1; i <= 3; i++ {
    wg.Add(1)
    go func(n int) {
      defer wg.Done()
      fmt.Println(n)
    }(i)
  }
  // What should be here?
}

hard

A. wg.Done()

B. time.Sleep(1 * time.Second)

C. wg.Wait()

D. close(wg)

Solution

1. Step 1: Understand WaitGroup usage

   WaitGroup tracks goroutines; wg.Add(1) before start, wg.Done() after done.

2. Step 2: Ensure main waits for all goroutines

   Calling wg.Wait() blocks main until all goroutines call Done().

3. Final Answer:

   wg.Wait() -> Option C

4. Quick Check:

   WaitGroup.Wait() waits for goroutines [OK]

Hint: Use wg.Wait() to wait all goroutines finish [OK]

Common Mistakes:

• Using Sleep instead of WaitGroup for sync
• Trying to close WaitGroup (not allowed)
• Calling Done() in main instead of goroutine