Go Concurrency

// go keyword starts a goroutine — returns immediately
go doWork()

// With an anonymous function
go func() {
    fmt.Println("running concurrently")
}()

// Pass args at launch — value captured now, not when goroutine runs
msg := "hello"
go func(s string) {
    fmt.Println(s)
}(msg)

// main returning kills all goroutines immediately
func main() {
    go doWork()
    // program may exit before doWork runs — use WaitGroup or channel
}

// make(chan T) — unbuffered channel
ch := make(chan int)

go func() { ch <- 42 }()  // send — blocks until received
v := <-ch                   // receive — blocks until sent
fmt.Println(v)              // 42

// Comma-ok — detect if channel is closed
v, ok := <-ch  // ok=false when channel is closed and drained

// close signals no more values will be sent
jobs := make(chan string, 3)
jobs <- "a"; jobs <- "b"; jobs <- "c"
close(jobs)

// range drains channel then exits when closed
for j := range jobs {
    fmt.Println(j) // a, b, c
}

// chan<- T  send-only      <-chan T  receive-only
// Use in signatures to document intent and let the compiler enforce it

func producer(out chan<- int) {
    for i := 0; i < 5; i++ {
        out <- i
    }
    close(out)
}

func consumer(in <-chan int) {
    for v := range in {
        fmt.Println(v)
    }
}

ch := make(chan int)
go producer(ch)
consumer(ch)

// Sender doesn't block until buffer is full
ch := make(chan int, 3)
ch <- 1; ch <- 2; ch <- 3
// ch <- 4  would block here — buffer full

fmt.Println(len(ch)) // 3 — items currently buffered
fmt.Println(cap(ch)) // 3 — total capacity

// Semaphore — limit to N goroutines running at once
const maxWorkers = 5
sem := make(chan struct{}, maxWorkers)

for _, task := range tasks {
    sem <- struct{}{}           // acquire — blocks when 5 are running
    go func(t Task) {
        defer func() { <-sem }() // release on exit
        process(t)
    }(task)
}

// select blocks until one case is ready — random if multiple are ready
select {
case v := <-ch1:
    fmt.Println("from ch1:", v)
case v := <-ch2:
    fmt.Println("from ch2:", v)
case ch3 <- 99:
    fmt.Println("sent to ch3")
}

// default — makes select non-blocking
select {
case v := <-results:
    handle(v)
default:
    fmt.Println("nothing ready")
}

var wg sync.WaitGroup

urls := []string{"a.com", "b.com", "c.com"}

for _, url := range urls {
    wg.Add(1)                  // before launching — not inside the goroutine
    go func(u string) {
        defer wg.Done()       // defer so it runs even on panic
        fetch(u)
    }(url)
}

wg.Wait()
fmt.Println("all fetches done")

results := make(chan string, len(urls))

var wg sync.WaitGroup
for _, url := range urls {
    wg.Add(1)
    go func(u string) {
        defer wg.Done()
        results <- fetch(u)
    }(url)
}

// Close results once all workers finish
go func() { wg.Wait(); close(results) }()

for r := range results {
    fmt.Println(r)
}

type SafeCounter struct {
    mu    sync.Mutex
    count int
}

func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()  // defer prevents forgetting to unlock on every path
    c.count++
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

sc := &SafeCounter{}
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
    wg.Add(1)
    go func() { defer wg.Done(); sc.Inc() }()
}
wg.Wait()
fmt.Println(sc.Value()) // 1000

// RLock/RUnlock — many readers allowed simultaneously
// Lock/Unlock   — exclusive write, blocks all readers and writers
type Cache struct {
    mu    sync.RWMutex
    items map[string]string
}

func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    v, ok := c.items[key]
    return v, ok
}

func (c *Cache) Set(key, val string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = val
}

// Do(f) runs f exactly once, even if called from many goroutines
var (
    once     sync.Once
    instance *DB
)

func GetDB() *DB {
    once.Do(func() {
        instance = connectDB()
    })
    return instance
}

// All concurrent callers wait for Do to finish, then get the same instance
for i := 0; i < 10; i++ {
    go func() { use(GetDB()) }()
}

ctx, cancel := context.WithCancel(context.Background())
defer cancel()  // always defer — releases context resources

go func() {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("stopped:", ctx.Err())
            return
        case v := <-work:
            process(v)
        }
    }
}()

cancel() // ctx.Done() is closed, goroutine exits on next select

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()

// HTTP request honours the deadline automatically
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, err := http.DefaultClient.Do(req)
if errors.Is(err, context.DeadlineExceeded) {
    fmt.Println("timed out")
}

// Manual check in your own goroutine
select {
case result := <-compute(ctx):
    use(result)
case <-ctx.Done():
    fmt.Println("deadline exceeded")
}