Concurrency with Goroutines 🐹

package main

import (
    "fmt"
    "sync"
)

// A goroutine is a function that runs CONCURRENTLY with the rest of
// your program. The Go runtime manages them (~2KB of stack each), so
// running thousands is cheap. You start one by writing  go <call>.
func sayHello(name string, wg *sync.WaitGroup) {
    defer wg.Done() // tell the WaitGroup "I'm finished" when this returns
    fmt.Println("Hello,", name)
}

func main() {
    // A WaitGroup is a counter the main goroutine waits on.
    var wg sync.WaitGroup

    names := []string{"Alice", "Bob", "Charlie"}
    for _, name := range names {
        wg.Add(1)             // +1 to the counter for each goroutine
        go sayHello(name, &wg) // 'go' launches it concurrently and moves on
    }

    wg.Wait() // BLOCK here until the counter hits 0 (all Done() called)
    fmt.Println("all greetings done")
}

Hello, Charlie
Hello, Alice
Hello, Bob
all greetings done

package main

import "fmt"

func main() {
    // A channel is a typed pipe goroutines use to pass values safely.
    // make(chan T) with NO size = UNBUFFERED: a send blocks until a
    // receiver is ready (it hands the value over directly).
    done := make(chan string)

    go func() {
        // This runs in a separate goroutine. The send (ch <- value)
        // waits until main is ready to receive on the other end.
        done <- "worker finished" // SEND a value into the channel
    }()

    msg := <-done                  // RECEIVE — blocks until a value arrives
    fmt.Println("got:", msg)       // got: worker finished

    // make(chan T, n) = BUFFERED, capacity n. Sends DON'T block until
    // the buffer is full, so you can send a few values up front.
    nums := make(chan int, 3)      // holds up to 3 ints without a reader
    nums <- 10                     // doesn't block (buffer has room)
    nums <- 20
    nums <- 30
    close(nums)                    // no more sends; receivers can drain it

    // Ranging over a channel reads values until it is closed.
    total := 0
    for n := range nums {
        total += n
    }
    fmt.Println("buffered total:", total) // buffered total: 60
}

got: worker finished
buffered total: 60

package main

import "fmt"

func main() {
    // 🎯 YOUR TURN — fill in the blanks marked with ___

    ch := make(chan string) // an unbuffered string channel

    go func() {
        // 1) SEND the text "pong" into ch
        ___              // 👉 ch <- "pong"
    }()

    // 2) RECEIVE one value from ch into the variable reply
    reply := ___         // 👉 <-ch
    fmt.Println("server says:", reply)

    // ✅ Expected output:
    //    server says: pong
}

server says: pong

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string)

    // Send a value after 100ms from a separate goroutine.
    go func() {
        time.Sleep(100 * time.Millisecond)
        ch <- "work finished"
    }()

    // select waits on SEVERAL channel operations at once and runs
    // whichever is ready first. Here it races a real result against a
    // 1-second timeout, so the result (100ms) always wins.
    select {
    case msg := <-ch:
        fmt.Println("got:", msg)             // got: work finished
    case <-time.After(1 * time.Second):
        fmt.Println("timed out")
    }

    // A 'default' case makes select NON-BLOCKING: if nothing is ready
    // right now, run default instead of waiting. ch is empty here, so:
    select {
    case msg := <-ch:
        fmt.Println("got:", msg)
    default:
        fmt.Println("no value ready right now") // this one runs
    }
}

got: work finished
no value ready right now

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup  // waits for all 100 goroutines
    var mu sync.Mutex      // a lock that guards the shared counter
    count := 0             // shared state — many goroutines touch it

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()      // only ONE goroutine past this at a time
            count++        // safe: the lock makes count++ exclusive
            mu.Unlock()    // let the next goroutine in
        }()
    }

    wg.Wait()                       // wait for every increment to finish
    fmt.Println("count:", count)    // count: 100  (always — no lost updates)
}

count: 100

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    // 2) Signal completion when this function returns
    defer ___            // 👉 wg.Done()
    fmt.Println("worker", id, "done")
}

func main() {
    // 🎯 YOUR TURN — fill in the blanks marked with ___
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        // 1) Add ONE to the WaitGroup before launching each worker
        ___              // 👉 wg.Add(1)
        go worker(i, &wg)
    }

    // 3) Block until all three workers have signalled Done
    ___                  // 👉 wg.Wait()
    fmt.Println("all workers finished")

    // ✅ Expected output (the three "worker N done" lines may be in
    //    ANY order; the last line is always last):
    //    worker 1 done
    //    worker 2 done
    //    worker 3 done
    //    all workers finished
}

worker 1 done
worker 2 done
worker 3 done
all workers finished

package main

import "fmt"

// "Don't communicate by sharing memory; share memory by communicating."
// Each stage owns its data and passes it on through a channel.

// Stage 1: generate produces numbers, then CLOSES its output channel.
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)        // closing tells the next stage "no more"
        for _, n := range nums {
            out <- n
        }
    }()
    return out                  // <-chan int = receive-only (read it, can't send)
}

// Stage 2: square reads from 'in' and writes squares to a new channel.
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {     // ends when 'in' is closed and drained
            out <- n * n
        }
    }()
    return out
}

func main() {
    // Pipeline: generate -> square -> consume. No mutex, no shared
    // variable — the channels carry the data between stages.
    for v := range square(generate(1, 2, 3, 4, 5)) {
        fmt.Print(v, " ")
    }
    fmt.Println()               // 1 4 9 16 25
}

1 4 9 16 25