How does tryAcquire() differ from acquire(), and when would you use the timed or multi-permit variants?

## The three ways to take a permit A `Semaphore` offers a spectrum of acquisition strategies, trading **waiting** against **certainty of progress**. ### 1. `acquire()` — wait as long as it takes ```java sem.acquire(); // blocks until a permit is free OR the thread is interrupted (throws InterruptedException) ``` The thread parks until a permit becomes available. Use this when the work *must* eventually run and queuing is acceptable. The blocked thread consumes no CPU (it isn't spinning) but it *is* tied up. There is also `acquireUninterruptibly()` which ignores interruption. ### 2. `tryAcquire()` — take it or leave it, right now ```java if (sem.tryAcquire()) { try { doWork(); } finally { sem.release(); } } else { rejectFast(); // no capacity — shed load instead of queuing } ``` `tryAcquire()` returns `true` and grabs a permit *only* if one is free at that instant; otherwise it returns `false` **immediately**. This is the foundation of **load shedding** / **back-pressure**: under overload you reject (return 503, drop the request, fall back) rather than letting a queue grow unboundedly and exhaust memory or blow latency SLAs. **Important subtlety:** the no-arg, untimed `tryAcquire()` **barges** — it will snatch an available permit even if other threads have been waiting longer, *ignoring the fairness setting*. So on a fair semaphore, `tryAcquire()` can still jump the queue. If you need fairness-respecting non-blocking-ish behaviour, use the timed form. ### 3. `tryAcquire(timeout, unit)` — wait, but not forever ```java if (sem.tryAcquire(200, TimeUnit.MILLISECONDS)) { try { doWork(); } finally { sem.release(); } } else { timeoutFallback(); } ``` Waits up to the timeout, then gives up and returns `false`. This **bounds tail latency**: a request can stall at most `timeout` before failing over. The timed variant **honours fairness** (it queues like `acquire()` and respects FIFO on a fair semaphore). It also throws `InterruptedException` if the thread is interrupted while waiting. ## Multi-permit variants Every form has an n-permit version: `acquire(n)`, `tryAcquire(n)`, `tryAcquire(n, timeout, unit)`, `release(n)`. - `acquire(n)` waits until **all n** permits are available, then takes them **atomically** — you never get a partial allocation. - `release(n)` returns n at once and may unblock several waiters. Use multi-permit when one logical task consumes several units of the bounded resource — e.g. a bulk export that needs 3 worker slots, or weighting larger requests to cost more permits so big jobs naturally limit their own concurrency. **Watch out:** `acquire(n)` on a non-fair semaphore can be starved by a steady stream of single-permit acquirers that keep the count just below n. Fairness mitigates this. ## Choosing | Need | Use | |---|---| | Work must run, queuing OK | `acquire()` | | Reject immediately if busy (load shed) | `tryAcquire()` | | Bound the wait, then fall back | `tryAcquire(timeout, unit)` | | Task needs several units atomically | `acquire(n)` / `tryAcquire(n, …)` | In all cases, pair the successful acquire with a `release` in `finally` — and **only release if you actually acquired** (a common bug is releasing in `finally` after a `tryAcquire` that returned `false`).