package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var wg sync.WaitGroup
 
    wg.Add(5) // ৫টা goroutine হবে
 
    for i := 1; i <= 5; i++ {
        go func(id int) {
            defer wg.Done()
            fmt.Println("Goroutine চলছে:", id)
        }(i)
    }
 
    wg.Wait() // সব goroutine শেষ না হওয়া পর্যন্ত অপেক্ষা
    fmt.Println("সব goroutine শেষ হয়েছে ✅")
}

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var counter = 0
    var mu sync.Mutex
    var wg sync.WaitGroup
 
    wg.Add(1000)
 
    for i := 0; i < 1000; i++ {
        go func() {
            defer wg.Done()
            mu.Lock()
            counter++ // এখন নিরাপদ
            mu.Unlock()
        }()
    }
 
    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var counter = 0
    var wg sync.WaitGroup
 
    wg.Add(1000)
 
    for i := 0; i < 1000; i++ {
        go func() {
            defer wg.Done()
            counter++ // ❌ বিপদ! একাধিক goroutine একসাথে লিখছে
        }()
    }
 
    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

go run -race main.go

WARNING: DATA RACE
Read at ...
Previous write at ...

// ❌ DEADLOCK RISK: ভিন্ন order-এ lock নেওয়া
func transfer1(mu1, mu2 *sync.Mutex) {
    mu1.Lock()
    mu2.Lock() // এই order
    // ... transfer logic
    mu2.Unlock()
    mu1.Unlock()
}
 
func transfer2(mu1, mu2 *sync.Mutex) {
    mu2.Lock()
    mu1.Lock() // উল্টো order = Deadlock!
    // ... transfer logic
    mu1.Unlock()
    mu2.Unlock()
}
 
// ✅ SOLUTION: সবসময় একই order-এ lock নিন
func transfer(from, to *Account) {
    // Consistent ordering by memory address
    first, second := from, to
    if uintptr(unsafe.Pointer(from)) > uintptr(unsafe.Pointer(to)) {
        first, second = to, from
    }
    
    first.mu.Lock()
    defer first.mu.Unlock()
    
    second.mu.Lock()
    defer second.mu.Unlock()
    
    // Safe transfer
    from.balance -= amount
    to.balance += amount
}

package main
 
import (
    "fmt"
    "sync"
)
 
// SafeCounter is a thread-safe counter
type SafeCounter struct {
    mu    sync.Mutex
    value int
}
 
// Increment safely increments the counter
func (c *SafeCounter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}
 
// Value safely returns current value
func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}
 
// Add safely adds n to counter
func (c *SafeCounter) Add(n int) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value += n
}
 
func main() {
    counter := &SafeCounter{}
    var wg sync.WaitGroup
    
    // 1000 goroutines safely increment
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }
    
    wg.Wait()
    fmt.Println("Safe Counter:", counter.Value())
}

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var m sync.Map
    var wg sync.WaitGroup
    
    // Write from multiple goroutines
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(key int) {
            defer wg.Done()
            m.Store(key, key*2)
        }(i)
    }
    
    wg.Wait()
    
    // Read safely
    m.Range(func(key, value interface{}) bool {
        fmt.Printf("Key: %v, Value: %v\n", key, value)
        return true // continue iteration
    })
}

data1 := <-ch1 // এখানে আটকে গেল
data2 := <-ch2 // এটি আর চলবে না, যদি ch1 এ ডেটা না আসে

select {
case data := <-ch1:
    // ch1 থেকে ডেটা রিসিভ হলে এটি চলবে
    fmt.Println("ch1 থেকে পেলাম:", data)
case ch2 <- "Hi":
    // ch2-তে ডেটা সেন্ড করা সম্ভব হলে এটি চলবে
    fmt.Println("ch2-তে 'Hi' পাঠালাম")
case <-ch3:
    // ch3 থেকে ডেটা রিসিভ হলে (কিন্তু ডেটা ব্যবহার না করলে)
    fmt.Println("ch3 থেকে সিগন্যাল পেলাম")
}

           [goroutine]
               |
          <--select-->
         /      |     \
        /       |      \
   (অপেক্ষা) (প্রস্তুত) (অপেক্ষা)
      |         |        |
    [ch1]     [ch2]    [ch3]

select {
case data := <-ch:
    fmt.Println("ডেটা রিসিভড:", data)
default:
    // কোনো চ্যানেল রেডি না থাকলে এটি সাথে সাথে চলবে
    fmt.Println("এখনো কোনো ডেটা নেই, আমি অন্য কাজ করছি...")
}

select {
case data := <-longRunningTaskCh:
    fmt.Println("কাজ সম্পন্ন:", data)
case <-time.After(2 * time.Second):
    // 2 সেকেন্ড পার হয়ে গেলে এটি চলবে
    fmt.Println("টাইমআউট! আর অপেক্ষা করা সম্ভব না।")
}

package main
 
import (
    "fmt"
    "sync"
    "time"
)
 
// Fan-In: Multiple inputs → Single output
func fanIn(inputs ...<-chan string) <-chan string {
    out := make(chan string)
    var wg sync.WaitGroup
    
    for _, ch := range inputs {
        wg.Add(1)
        go func(c <-chan string) {
            defer wg.Done()
            for msg := range c {
                out <- msg
            }
        }(ch)
    }
    
    go func() {
        wg.Wait()
        close(out)
    }()
    
    return out
}
 
func producer(name string, count int) <-chan string {
    ch := make(chan string)
    go func() {
        defer close(ch)
        for i := 1; i <= count; i++ {
            ch <- fmt.Sprintf("%s: message %d", name, i)
            time.Sleep(100 * time.Millisecond)
        }
    }()
    return ch
}
 
func main() {
    ch1 := producer("Service-A", 3)
    ch2 := producer("Service-B", 3)
    
    merged := fanIn(ch1, ch2)
    
    for msg := range merged {
        fmt.Println("Received:", msg)
    }
}

package main
 
import (
    "fmt"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)
 
func worker(id int, jobs <-chan int, done <-chan struct{}, wg *sync.WaitGroup) {
    defer wg.Done()
    
    for {
        select {
        case job, ok := <-jobs:
            if !ok {
                fmt.Printf("Worker %d: channel closed\n", id)
                return
            }
            fmt.Printf("Worker %d processing %d\n", id, job)
            time.Sleep(500 * time.Millisecond)
            
        case <-done:
            fmt.Printf("Worker %d: shutdown signal\n", id)
            return
        }
    }
}
 
func main() {
    jobs := make(chan int, 10)
    done := make(chan struct{})
    var wg sync.WaitGroup
    
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(i, jobs, done, &wg)
    }
    
    go func() {
        for j := 1; j <= 10; j++ {
            jobs <- j
            time.Sleep(200 * time.Millisecond)
        }
        close(jobs)
    }()
    
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
    
    <-sigChan
    fmt.Println("\n🛑 Gracefully stopping...")
    
    close(done)
    wg.Wait()
    fmt.Println("✅ Clean shutdown")
}

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
 
    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "🍎 From channel 1"
    }()
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "🍌 From channel 2"
    }()
 
    select {
    case msg1 := <-ch1:
        fmt.Println(msg1)
    case msg2 := <-ch2:
        fmt.Println(msg2)
    }
}

select {
case msg := <-ch1:
    fmt.Println("Received:", msg)
default:
    fmt.Println("No channel ready — moving on 🚀")
}

select {
case msg := <-ch1:
    fmt.Println("Got:", msg)
case <-time.After(2 * time.Second):
    fmt.Println("Timeout! ⏰ No data received.")
}

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
 
for {
    select {
    case msg := <-out:
        fmt.Println(msg)
    case <-ctx.Done():
        fmt.Println("🛑 Stopped by context timeout.")
        return
    }
}

// ❌ BAD: Memory leak
for {
    select {
    case <-ch:
        // process
    case <-time.After(1 * time.Second): // প্রতিবার নতুন timer
        // timeout
    }
}
 
// ✅ GOOD: Timer reuse
timer := time.NewTimer(1 * time.Second)
defer timer.Stop()
for {
    select {
    case <-ch:
        timer.Reset(1 * time.Second)
    case <-timer.C:
        // timeout
    }
}

// ❌ Leak হবে
func leaky() {
    ch := make(chan int)
    go func() {
        val := <-ch // চিরকাল blocked
        fmt.Println(val)
    }()
} // channel close হয়নি
 
// ✅ Proper cleanup
func proper(done <-chan struct{}) {
    ch := make(chan int)
    go func() {
        select {
        case val := <-ch:
            fmt.Println(val)
        case <-done:
            return
        }
    }()
}

// Race Detector
// go run -race main.go
 
// Goroutine count
import "runtime"
fmt.Println("Goroutines:", runtime.NumGoroutine())
 
// pprof for profiling
import _ "net/http/pprof"
go func() {
    http.ListenAndServe("localhost:6060", nil)
}()
// Visit: http://localhost:6060/debug/pprof/

type AppMetrics struct {
    GoroutineCount int
    ActiveWorkers  int
    QueueSize      int
    ProcessedJobs  int64
    FailedJobs     int64
}
 
func monitor() {
    ticker := time.NewTicker(10 * time.Second)
    for range ticker.C {
        m := AppMetrics{
            GoroutineCount: runtime.NumGoroutine(),
        }
        log.Printf("Metrics: Goroutines=%d", m.GoroutineCount)
    }
}