Semaphore in Golang

// 3 parking slots
var slots = make(chan struct{}, 3)

func park(carID int) {
	slots <- struct{}{}        // drive up to the gate; blocks if the lot is full
	defer func() { <-slots }() // on exit, free the slot for the next car

	fmt.Printf("car %d parked\n", carID)
	time.Sleep(200 * time.Millisecond) // time spent parked
	fmt.Printf("car %d leaving\n", carID)
}

func main() {
	start := time.Now()

	const maxConcurrent = 3
	gate := make(chan struct{}, maxConcurrent)

	var wg sync.WaitGroup
	for carID := 1; carID <= 12; carID++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()

			gate <- struct{}{}        // acquire a slot
			defer func() { <-gate }() // release it

			fmt.Printf("car %d parked\n", id)
			time.Sleep(200 * time.Millisecond)
		}(carID)
	}

	wg.Wait()
	fmt.Printf("lot cleared in %s\n", time.Since(start))
}

func tryPark(carID int) bool {
	select {
	case gate <- struct{}{}:
		defer func() { <-gate }()
		fmt.Printf("car %d got a slot\n", carID)
		time.Sleep(200 * time.Millisecond)
		return true
	default:
		fmt.Printf("car %d found the lot full, driving on\n", carID)
		return false
	}
}

import "golang.org/x/sync/semaphore"

func main() {
	ctx := context.Background()
	lot := semaphore.NewWeighted(10) // 10 slot-units total

	vehicles := []struct {
		id   int
		size int64 // slots this vehicle occupies
	}{
		{1, 1}, {2, 3}, {3, 2}, {4, 1}, {5, 3}, {6, 2},
	}

	var wg sync.WaitGroup
	for _, v := range vehicles {
		wg.Add(1)
		go func(id int, size int64) {
			defer wg.Done()

			if err := lot.Acquire(ctx, size); err != nil {
				return // ctx cancelled while waiting
			}
			defer lot.Release(size)

			fmt.Printf("vehicle %d (%d slots) parked\n", id, size)
			time.Sleep(200 * time.Millisecond)
		}(v.id, v.size)
	}
	wg.Wait()
}

// Exercise 1: Photo Upload Processing with a Concurrency Limit
// Build a program that simulates uploading 10 photos to a server, but the
// server can only accept a maximum of 3 uploads at the same time (rate limit).
//
// Requirements:
// 1. Create a semaphore with capacity 3 (sem := make(chan struct{}, 3)).
// 2. Write a function uploadPhoto(id int, sem chan struct{}, wg *sync.WaitGroup)
//    — simulate the upload with time.Sleep(500 * time.Millisecond). Print when
//    the upload starts and when it finishes, including the photo id.
// 3. Spawn 10 goroutines (1 per photo) from main, all calling uploadPhoto.
// 4. Prove that at most 3 run at the same time — the easiest way: add an
//    "active" counter (use sync.Mutex or sync/atomic, since this counter is
//    accessed by many goroutines at once) that increases when an upload
//    starts and decreases when it finishes. Print the counter value every
//    time it changes, and make sure it is never greater than 3 at any point.
// 5. Measure the total execution time. With 10 photos, 3 concurrent slots and
//    500ms per photo — what total time should you expect? (Hint: ceil(10/3)
//    batches of 500ms.)

// Exercise 2: API Request Processing with a Rate Limit
// Simulate sending 15 requests to an external API that allows a maximum of 4
// concurrent requests (a rate limit imposed by the server).
//
// Requirements:
// 1. Create a semaphore with capacity 4.
// 2. Result struct:
//        type APIResult struct {
//            RequestID int
//            Success   bool
//            Duration  time.Duration
//        }
// 3. Write a function
//    sendRequest(id int, sem chan struct{}, results chan<- APIResult, wg *sync.WaitGroup):
//    - Acquire a semaphore slot first.
//    - Record the start time (time.Now()).
//    - Simulate the request with time.Sleep(300 * time.Millisecond).
//    - Simulate deterministic failure: use id % 4 == 0 as the rule (not rand,
//      so results stay predictable when debugging) — treat this request as
//      Success: false when id is divisible by 4, otherwise Success: true.
//    - Send an APIResult (fill Duration with time.Since(start)) to results.
//    - Release the semaphore slot.
// 4. In main, run all 15 requests (goroutine + semaphore), collecting results
//    through the results channel (the WaitGroup + goroutine-that-closes
//    pattern you already know).
// 5. At the end, print a summary: total successful requests, total failed
//    requests, and the average Duration across all requests.

// Exercise 3: Batch File Processing with a Rate Limit and a Timeout
// Simulate processing 20 file uploads to cloud storage, with a maximum of 5
// concurrent uploads (semaphore), but the whole process must be force-stopped
// if it runs longer than 2 seconds (context timeout).
//
// Requirements:
// 1. Create a semaphore with capacity 5.
// 2. Create a ctx with context.WithTimeout of 2 seconds (defer cancel()).
// 3. Write a function:
//        func uploadFile(ctx context.Context, id int, sem chan struct{},
//                        results chan<- string, wg *sync.WaitGroup)
// 4. Before acquiring a semaphore slot, first check whether ctx is already
//    cancelled — if it was cancelled before this goroutine could start, do not
//    process at all, just return (skip this file). A select on ctx.Done() with
//    a default is the simplest check.
// 5. Acquire the slot with a select (NOT a bare sem <- struct{}{}) — so that
//    if it is waiting for a free slot and ctx times out first, it stops
//    immediately instead of waiting for a slot. On the ctx.Done() branch,
//    return without processing.
// 6. If it does get a slot, simulate the upload with
//    time.Sleep(400 * time.Millisecond).
// 7. Send the message "file<id> uploaded successfully" to results — also using
//    a select with ctx.Done() as the alternative (results is unbuffered, so
//    the send can block).
// 8. Release the semaphore slot at the end (only if a slot was actually
//    acquired) — a deferred <-sem placed right after a successful acquire.
// 9. In main, run 20 uploadFile goroutines, collect results through the
//    results channel (the WaitGroup + goroutine-that-closes pattern), print
//    each result, then at the end print how many files succeeded and the
//    reason for stopping (ctx.Err()).