Concurrent execution model in Go - Mini Project: Build & Apply

Concurrent Execution Model in Go

📖 Scenario: You are building a simple program to understand how Go runs tasks at the same time using goroutines. Imagine you want to greet three friends, but you want to say hello to each one without waiting for the others.

🎯 Goal: Learn how to start multiple tasks concurrently using goroutines and see their greetings printed in any order.

📋 What You'll Learn

Create a function that prints a greeting message

Start multiple goroutines to run the greeting function concurrently

Use a channel to wait for all goroutines to finish

Print all greetings without waiting for each one sequentially

💡 Why This Matters

🌍 Real World

Concurrent execution helps programs do many things at once, like handling multiple users or tasks without waiting.

💼 Career

Understanding goroutines and channels is essential for Go developers working on fast, efficient, and scalable software.

1

Create a function to print greetings

Write a function called greet that takes a string parameter name and prints "Hello, " followed by the name. Use fmt.Println inside the function.

Go

package main

import "fmt"

func greet(name string) {
    // Your code here
}

func main() {

}

Hint

Use fmt.Println("Hello, " + name) inside the greet function to print the greeting.

2

Create a channel to wait for goroutines

Inside main, create a channel called done of type chan bool to signal when a goroutine finishes.

Go

package main

import "fmt"

func greet(name string) {
    fmt.Println("Hello, " + name)
}

func main() {
    // Your code here
}

Hint

Use done := make(chan bool) to create the channel.

3

Start goroutines to greet friends concurrently

In main, start three goroutines using go greet(name) for "Alice", "Bob", and "Charlie". After each greeting, send true to the done channel to signal completion.

Go

package main

import "fmt"

func greet(name string) {
    fmt.Println("Hello, " + name)
}

func main() {
    done := make(chan bool)
    // Your code here
}

Hint

Use anonymous functions with go func() { ... }() to call greet and then send true to done.

4

Wait for all goroutines to finish and print greetings

In main, add a for loop that runs three times. Each time, receive from the done channel to wait for a goroutine to finish. This ensures all greetings are printed before the program ends.

Go

package main

import "fmt"

func greet(name string) {
    fmt.Println("Hello, " + name)
}

func main() {
    done := make(chan bool)

    go func() {
        greet("Alice")
        done <- true
    }()

    go func() {
        greet("Bob")
        done <- true
    }()

    go func() {
        greet("Charlie")
        done <- true
    }()

    // Your code here
}

Hint

Use for i := 0; i < 3; i++ { <-done } to wait for all goroutines.

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