ctx := context.Background()

ctx, cancel := context.WithCancel(context.Background())
    // `ctx` → মূল context object
    // `cancel` → এই function কল করলে context “cancel” হয়ে যায়।
 
// এখানে আমরা একটি goroutine চালু করছি যা ৩ সেকেন্ড পর পর্যন্ত ব্লক হয়ে থাকবে
go func() {
    <-time.After(3 * time.Second)
    // ৩ সেকেন্ড পর পর্যন্ত ব্লক হয়ে থাকো, তারপর এগিয়ে যাও
    cancel() // cancel after 3 seconds
}()
 
<-ctx.Done()
fmt.Println("Context canceled:", ctx.Err())

Context canceled: context canceled

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel() // এটা main() ফাংশন return করার ঠিক আগে রান হবে।
 
select {
case <-time.After(5 * time.Second):
    fmt.Println("Work finished")
case <-ctx.Done():
    fmt.Println("Timeout:", ctx.Err())
}

Timeout: context deadline exceeded

deadline := time.Now().Add(2 * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel()

select {
case <-ctx.Done():
    fmt.Println("🛑 Stopped:", ctx.Err())
}

select {
case <-ctx.Done():
    // Context ক্যানসেল হয়ে গেছে (টাইমআউট বা ম্যানুয়াল)!
    // এখানে সব কাজ বন্ধ করতে হবে, রিসোর্স পরিষ্কার করতে হবে।
    fmt.Println("কাজ বন্ধ করছি...")
    return // goroutine থেকে বের হয়ে যাই
default:
    // Context এখনো অ্যাক্টিভ আছে, কাজ চালিয়ে যাই
    fmt.Println("কাজ চলছে...")
}

package main
 
import (
	"context"
	"fmt"
	"time"
)
 
// worker হলো একটি goroutine যা context শেষ না হওয়া পর্যন্ত কাজ করে
func worker(ctx context.Context, name string) {
	fmt.Printf("👷 %s: কাজ শুরু...\n", name)
	for {
		select {
		case <-ctx.Done():
			// সিগন্যাল পেয়েছি!
			fmt.Printf("🛑 %s: ক্যানসেল সিগন্যাল পেলাম, কাজ বন্ধ করছি।\n", name)
			return // goroutine থেকে প্রস্থান
 
		default:
			// Context ঠিক থাকলে কাজ চালিয়ে যাই
			fmt.Printf("⚙️ %s: কাজ করছি...\n", name)
			time.Sleep(1 * time.Second) // কাজের সিমুলেশন
		}
	}
}
 
func main() {
	// ১. একটি parent context তৈরি করি
	parentCtx := context.Background()
 
	// ২. ৩ সেকেন্ডের একটি টাইমআউট সহ child context তৈরি করি
	ctx, cancel := context.WithTimeout(parentCtx, 3*time.Second)
	
	// ৩. (খুবই গুরুত্বপূর্ণ) কাজ শেষে cancel() কল করা
	// এটি নিশ্চিত করে যে context-এর সাথে যুক্ত সব রিসোর্স মুক্ত হবে।
	// যদিও টাইমআউট হলে এটি নিজে থেকেই ক্যানসেল হবে, 
	// কিন্তু যদি worker আগে কাজ শেষ করে ফেলে, তবে defer cancel() রিসোর্স লিক ঠেকায়।
	defer cancel()
 
	fmt.Println("🚀 main: ওয়ার্কার চালু করছি (৩ সেকেন্ড টাইমআউট)...")
	go worker(ctx, "Worker-1")
 
	// main goroutine-কে ৫ সেকেন্ড চালু রাখি যাতে worker-এর প্রস্থান দেখতে পারি
	time.Sleep(5 * time.Second) 
	fmt.Println("👋 main: প্রোগ্রাম শেষ।")
}

🚀 main: ওয়ার্কার চালু করছি (৩ সেকেন্ড টাইমআউট)...
👷 Worker-1: কাজ শুরু...
⚙️ Worker-1: কাজ করছি...
⚙️ Worker-1: কাজ করছি...
⚙️ Worker-1: কাজ করছি...
🛑 Worker-1: ক্যানসেল সিগন্যাল পেলাম, কাজ বন্ধ করছি।
👋 main: প্রোগ্রাম শেষ।

package main
 
import (
	"context"
	"fmt"
	"time"
)
 
// step3: আসল কাজ এখানে হয় (ডেটাবেস কোয়েরি সিমুলেশন)
func step3(ctx context.Context) {
	fmt.Println("  [Step 3]: ডেটাবেস কোয়েরি শুরু... (২ সেকেন্ড লাগবে)")
	select {
	case <-time.After(2 * time.Second):
		// কাজ সম্পন্ন
		fmt.Println("  [Step 3]: ডেটাবেস কোয়েরি সফল।")
	case <-ctx.Done():
		// কাজ শেষ হওয়ার আগেই ক্যানসেল সিগন্যাল এলো
		fmt.Println("  [Step 3]: 🛑 ডেটাবেস কোয়েরি ক্যানসেলড!")
	}
}
 
// step2: ডেটা প্রসেস করে
func step2(ctx context.Context) {
	fmt.Println(" [Step 2]: ডেটা প্রসেসিং শুরু...")
	// কাজ করার আগে চেক করা (Early exit)
	if ctx.Err() != nil {
		fmt.Println(" [Step 2]: 🛑 শুরুতেই ক্যানসেল ছিলো, কাজ শুরুই করলাম না।")
		return
	}
	
	step3(ctx) // context নিচে পাস করা
	fmt.Println(" [Step 2]: ডেটা প্রসেসিং শেষ।")
}
 
// step1: রিকোয়েস্ট হ্যান্ডেল করে
func step1(ctx context.Context) {
	fmt.Println("[Step 1]: রিকোয়েস্ট হ্যান্ডেলিং শুরু...")
	step2(ctx) // context নিচে পাস করা
	fmt.Println("[Step 1]: রিকোয়েস্ট হ্যান্ডেলিং শেষ।")
}
 
func main() {
	// === সিনারিও ১: সফল (টাইমআউটের আগেই কাজ শেষ) ===
	fmt.Println("--- সিনারিও ১: সফল রিকোয়েস্ট (টাইমআউট ৩ সেকেন্ড) ---")
	ctxSuccess, cancelSuccess := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancelSuccess()
	step1(ctxSuccess)
 
	fmt.Println("\n--- সিনারিও ২: ক্যানসেলড (টাইমআউট ১ সেকেন্ড) ---")
	// === সিনারিও ২: ক্যানসেলড (টাইমআউটের আগেই সিগন্যাল) ===
	ctxTimeout, cancelTimeout := context.WithTimeout(context.Background(), 1*time.Second)
	defer cancelTimeout()
	step1(ctxTimeout)
	
	// ক্যানসেলেশনের প্রভাব দেখার জন্য একটু অপেক্ষা
	time.Sleep(2 * time.Second) 
	fmt.Println("--- প্রোগ্রাম শেষ ---")
}

--- সিনারিও ১: সফল রিকোয়েস্ট (টাইমআউট ৩ সেকেন্ড) ---
[Step 1]: রিকোয়েস্ট হ্যান্ডেলিং শুরু...
 [Step 2]: ডেটা প্রসেসিং শুরু...
  [Step 3]: ডেটাবেস কোয়েরি শুরু... (২ সেকেন্ড লাগবে)
  [Step 3]: ডেটাবেস কোয়েরি সফল।
 [Step 2]: ডেটা প্রসেসিং শেষ।
[Step 1]: রিকোয়েস্ট হ্যান্ডেলিং শেষ।

--- সিনারিও ২: ক্যানসেলড (টাইমআউট ১ সেকেন্ড) ---
[Step 1]: রিকোয়েস্ট হ্যান্ডেলিং শুরু...
 [Step 2]: ডেটা প্রসেসিং শুরু...
  [Step 3]: ডেটাবেস কোয়েরি শুরু... (২ সেকেন্ড লাগবে)
  [Step 3]: 🛑 ডেটাবেস কোয়েরি ক্যানসেলড!
 [Step 2]: ডেটা প্রসেসিং শেষ।
[Step 1]: রিকোয়েস্ট হ্যান্ডেলিং শেষ।
--- প্রোগ্রাম শেষ ---

deadline := time.Now().Add(2 * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel()

Background()
   └── WithCancel()
         └── WithTimeout()
               └── WithDeadline()

func fetchData(ctx context.Context, url string) error

func fetchData(url string, ctx context.Context)

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

func worker(ctx context.Context, ch <-chan int) {
    for {
        select {
        case v := <-ch:
            fmt.Println(v)
        case <-ctx.Done():
            fmt.Println("Worker stopped")
            return
        }
    }
}

package main
 
import (
    "context"
    "fmt"
    "time"
)
 
func main() {
    ctx, cancel := context.WithCancel(context.Background())
 
    go func() {
        for {
            select {
            case <-ctx.Done():
                fmt.Println("🛑 Goroutine stopped")
                return
            default:
                fmt.Println("🏃 Running...")
                time.Sleep(500 * time.Millisecond)
            }
        }
    }()
 
    time.Sleep(2 * time.Second)
    cancel() // stop after 2 seconds
    time.Sleep(1 * time.Second)
}

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
 
go func() {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("⏰ Timeout reached:", ctx.Err())
            return
        default:
            fmt.Println("⚙️ Working...")
            time.Sleep(500 * time.Millisecond)
        }
    }
}()
time.Sleep(4 * time.Second)

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println(name, "stopped")
            return
        default:
            fmt.Println(name, "working...")
            time.Sleep(700 * time.Millisecond)
        }
    }
}
 
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()
 
    go worker(ctx, "🧱 Worker 1")
    go worker(ctx, "🔧 Worker 2")
    go worker(ctx, "⚙️ Worker 3")
 
    <-ctx.Done()
    fmt.Println("All workers stopped:", ctx.Err())
}

select {
case <-ctx.Done():
    fmt.Println("Cleaning up resources...")
    return
}

func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d shutting down\n", id)
            return
        default:
            fmt.Printf("Worker %d doing work\n", id)
            time.Sleep(500 * time.Millisecond)
        }
    }
}
 
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
 
    for i := 1; i <= 3; i++ {
        go worker(ctx, i)
    }
 
    <-ctx.Done()
    fmt.Println("🛑 All workers canceled:", ctx.Err())
}

Background Context (Root)
    └─→ HTTP Request Context
         ├─→ Database Query Context
         ├─→ API Call Context
         └─→ Redis Cache Context

func handler(w http.ResponseWriter, r *http.Request) {
    // ১. http.Request নিজেই একটি context নিয়ে আসে
    ctx := r.Context()
 
    fmt.Println("Processing request...")
 
    select {
    case <-time.After(5 * time.Second): // ভারী কাজ সিমুলেশন
        w.Write([]byte("Request Processed"))
    case <-ctx.Done(): // ২. যদি ইউজার ব্রাউজার কেটে দেয়
        err := ctx.Err()
        fmt.Println("Request canceled by user:", err)
        http.Error(w, err.Error(), http.StatusRequestTimeout)
    }
}
 

func getUser(ctx context.Context, db *sql.DB, id int) {
    // ১. প্যারেন্ট context থেকে নতুন context, যার মেয়াদ মাত্র ৫০ মিলি-সেকেন্ড
    queryCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
    defer cancel() // অবশ্যই কল করবেন
 
    // ২. QueryContext ব্যবহার করুন
    // যদি ৫০ms-এর মধ্যে DB উত্তর না দেয়, এটি অটোমেটিক ক্যান্সেল হবে
    row := db.QueryContext(queryCtx, "SELECT name FROM users WHERE id=?", id)
    
    // ... scan and return
}
 

// Key-এর জন্য আলাদা type ব্যবহার করুন যাতে collision না হয়
type key int
const userKey key = 1
 
// Value সেট করা
func WithUser(ctx context.Context, u *User) context.Context {
    return context.WithValue(ctx, userKey, u)
}
 
// Value বের করা
func UserFrom(ctx context.Context) (*User, bool) {
    u, ok := ctx.Value(userKey).(*User)
    return u, ok
}
 

func mainHandler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
 
    // সাধারণ কাজ
    processData(ctx)
 
    // রিকোয়েস্ট শেষ, কিন্তু আমরা লগ সেভ করতে চাই
    // প্যারেন্ট (ctx) ক্যানসেল হলেও এটি ক্যানসেল হবে না
    go saveAuditLog(context.WithoutCancel(ctx)) 
}