// expects-nondeterministic: thread scheduling decides the interleaving, so the output order varies between runs
import java.util.*;
 
// Ride Matching Service Class
class RideMatchingService {
 
    // Method handling ride request
    public void requestRide(String riderId) {
 
        // Creating a new thread for the ride
        Thread matchThread = new Thread(() -> {
            System.out.println("Matching rider " + riderId + " to a driver...");
            // Simulate some processing
            try {
                Thread.sleep(1000); // Simulate a 1-second matching process
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Ride matched for rider " + riderId);
        });
        matchThread.start();
    }
}
 
class Main {
    public static void main(String[] args) {
        RideMatchingService rideService1 = new RideMatchingService();
        RideMatchingService rideService2 = new RideMatchingService();
 
        rideService1.requestRide("Alex");
        System.out.println("task1 running...");
 
        rideService2.requestRide("John Doe");
        System.out.println("task2 running...");
    }
}

import threading
import time
 
 
class RideMatchingService:
    def request_ride(self, rider_id: str) -> None:
        def match() -> None:
            print(f"Matching rider {rider_id} to a driver...")
            time.sleep(1)  # Simulate a 1-second matching process
            print(f"Ride matched for rider {rider_id}")
 
        # Non-daemon by default, same as Java — the process waits for it.
        match_thread = threading.Thread(target=match)
        match_thread.start()
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    ride_service_1 = RideMatchingService()
    ride_service_2 = RideMatchingService()
 
    ride_service_1.request_ride("Alex")
    print("task1 running...")
 
    ride_service_2.request_ride("John Doe")
    print("task2 running...")

// expects-nondeterministic: thread-pool tasks interleave, so the output order varies between runs
import java.util.concurrent.*;
 
// Using the newFixedThreadPool to manage threads (originally "EmailService")
class Main {
    private static final ExecutorService executor = Executors.newFixedThreadPool(10); // Thread pool with 10 threads
 
    // Method to send email
    public static void sendEmail(String recipient) {
        executor.execute(() -> {
            System.out.println("Sending email to " + recipient + " on " + Thread.currentThread().getName());
            try {
                // Simulate dummy work (sending an email)
                Thread.sleep(1000);  // Simulate delay
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();  // Handle interruption
            }
            System.out.println("Email sent to " + recipient);
        });
    }
 
    // Main method to simulate sending multiple emails
    public static void main(String[] args) {
        for (int i = 1; i <= 25; i++) {
            sendEmail("user" + i + "@gmail.com");  // Send email to 1000 users
        }
        executor.shutdown();  // Gracefully shut down the executor
    }
}

# expects-nondeterministic: thread-pool tasks interleave, so the output order varies between runs
from concurrent.futures import ThreadPoolExecutor
import threading
import time
 
# Thread pool with 10 workers, same shape as newFixedThreadPool(10)
executor = ThreadPoolExecutor(max_workers=10)
 
 
def send_email(recipient: str) -> None:
    # ThreadPoolExecutor has no separate execute(); submit() covers both
    # fire-and-forget and result-returning calls — we just ignore the Future.
    print(f"Sending email to {recipient} on {threading.current_thread().name}")
    time.sleep(1)  # Simulate delay
    print(f"Email sent to {recipient}")
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    for i in range(1, 26):
        executor.submit(send_email, f"user{i}@gmail.com")
 
    executor.shutdown(wait=True)  # Gracefully wait for every submitted task

import java.util.concurrent.*;
 
// Future and Submit example (originally "FutureExample")
class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);
 
        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(1000);
            return 77;
        });
 
        System.out.println("Doing other work...");
 
        Integer result = future.get(); // blocks until result is ready
        System.out.println("Result: " + result);
 
        executor.shutdown();
    }
}

from concurrent.futures import ThreadPoolExecutor
import time
 
 
def compute() -> int:
    time.sleep(1)
    return 77
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    with ThreadPoolExecutor(max_workers=2) as executor:
        future = executor.submit(compute)
 
        print("Doing other work...")
 
        result = future.result()  # blocks until result is ready
        print(f"Result: {result}")

// expects-nondeterministic: thread scheduling decides the interleaving, so the output order varies between runs
import java.util.concurrent.*;
 
class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(() -> System.out.println("Task running before shutdown."));
 
        executor.shutdown();  // Stop accepting new tasks; let submitted ones finish
        System.out.println("Executor shutdown initiated.");
    }
}

import java.util.concurrent.*;
import java.util.List;
 
class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(1);
 
        // First task grabs the only thread; the rest queue up behind it.
        executor.execute(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException ignored) {
                Thread.currentThread().interrupt();
            }
        });
        executor.execute(() -> System.out.println("Queued task 1"));
        executor.execute(() -> System.out.println("Queued task 2"));
 
        List<Runnable> pendingTasks = executor.shutdownNow();
        System.out.println("Pending tasks not started: " + pendingTasks.size());
    }
}

from concurrent.futures import ThreadPoolExecutor
import time
 
 
def graceful_shutdown_demo() -> None:
    executor = ThreadPoolExecutor(max_workers=2)
    executor.submit(lambda: print("Task running before shutdown."))
 
    # shutdown(wait=True) lets already-submitted tasks finish, then returns.
    executor.shutdown(wait=True)
    print("Executor shutdown complete (graceful).")
 
 
def immediate_shutdown_demo() -> None:
    executor = ThreadPoolExecutor(max_workers=1)
 
    # First task grabs the only worker; Python threads cannot be forcibly
    # killed (there is no equivalent of interrupting a running thread the
    # way shutdownNow() attempts to) — cancel_futures only drops tasks that
    # haven't started yet.
    long_task = executor.submit(time.sleep, 3)
    queued_1 = executor.submit(print, "Queued task 1")
    queued_2 = executor.submit(print, "Queued task 2")
 
    executor.shutdown(wait=False, cancel_futures=True)
    pending = sum(1 for f in (queued_1, queued_2) if f.cancelled())
    print(f"Pending tasks not started: {pending}")
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    graceful_shutdown_demo()
    immediate_shutdown_demo()

import java.util.concurrent.*;
 
// ── Driver (was "SessionCleaner") ───────────────────────────────────────────
class Main {
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
 
        Runnable task = () -> System.out.println("Cleaning up expired sessions...");
 
        scheduler.scheduleAtFixedRate(task, 0, 5, TimeUnit.SECONDS);
 
        // A real cleaner runs forever; we let it fire three times (0s, 5s, 10s)
        // then stop the scheduler so the demo terminates.
        Thread.sleep(11_000);
        scheduler.shutdownNow();
        System.out.println("Stopped session cleaner after 3 cycles.");
    }
}

import threading
import time
 
 
def clean_expired_sessions() -> None:
    print("Cleaning up expired sessions...")
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    # Python's stdlib has no ScheduledExecutorService-style fixed-rate
    # scheduler. The idiomatic replacement is a loop that waits on a
    # threading.Event: wait() returns early if the event is set (cancel
    # requested), otherwise it returns after the timeout (next tick).
    stop_event = threading.Event()
 
    def scheduler_loop() -> None:
        while not stop_event.wait(timeout=2):  # fires every 2s, like scheduleAtFixedRate
            clean_expired_sessions()
 
    scheduler_thread = threading.Thread(target=scheduler_loop, daemon=True)
 
    clean_expired_sessions()  # initialDelay = 0, so the first run fires immediately
    scheduler_thread.start()
 
    # A real cleaner runs forever; we let it fire a couple more times (scaled
    # down from the Java demo's 5s interval for a snappier example) then stop
    # the scheduler so the demo terminates.
    time.sleep(4.5)
    stop_event.set()
    scheduler_thread.join()
    print("Stopped session cleaner after 3 cycles.")

// expects-nondeterministic: the final count differs each run
import java.util.concurrent.*;
 
// Purchase counter with no protection
class PurchaseCounter {
    // Shared count value
    private int count = 0;
 
    // Increment the counter
    public void increment() {
        // READ current value
        // INCREMENT it
        // WRITE it back
        count++;                 // <-- not atomic, unsafe
    }
 
    // Fetch the current count
    public int getCount() {
        return count;
    }
}
 
// ── Driver — demonstrates the race condition (was "RaceConditionDemo") ────
class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a shared counter
        PurchaseCounter counter = new PurchaseCounter();
 
        // Task that bumps the counter 1000 times
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
 
        // Run the same task in two threads
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
 
        // Expect 2000, but rarely get it
        System.out.println("Final Count: " + counter.getCount());
    }
}

# expects-nondeterministic: the final count differs each run
import threading
import time
 
 
class PurchaseCounter:
    def __init__(self) -> None:
        self._count = 0
 
    def increment(self) -> None:
        # READ current value
        current = self._count
        # Force a handoff to the other thread right here, between the read
        # and the write, so the lost update actually happens.
        time.sleep(0)
        # WRITE it back (already INCREMENTed above)
        self._count = current + 1
 
    def get_count(self) -> int:
        return self._count
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    counter = PurchaseCounter()
 
    def task() -> None:
        for _ in range(1000):
            counter.increment()
 
    t1 = threading.Thread(target=task)
    t2 = threading.Thread(target=task)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
 
    # Expect 2000, but rarely get it — same lost-update race as Java.
    print(f"Final Count: {counter.get_count()}")

class SafeCounter {
    private int count = 0;
 
    // Entire method is protected by the instance's monitor lock
    public synchronized void increment() {
        count++;          // atomic under the lock
    }
 
    public synchronized int getCount() {
        return count;
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) throws InterruptedException {
        SafeCounter counter = new SafeCounter();
 
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
 
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
 
        // Always 2000 — the synchronized method removes the race.
        System.out.println("Final Count: " + counter.getCount());
    }
}

class SafeCounter {
    private final Object lock = new Object();
    private int count = 0;
 
    public void increment() {
        // Lock only the code that truly needs protection
        synchronized (lock) {
            count++;
        }
    }
 
    public int getCount() {
        // No lock needed for simple read, or use block if strict consistency required
        return count;
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) throws InterruptedException {
        SafeCounter counter = new SafeCounter();
 
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
 
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
 
        // Always 2000 — the synchronized block removes the race.
        System.out.println("Final Count: " + counter.getCount());
    }
}

import threading
 
 
class SafeCounter:
    def __init__(self) -> None:
        self._lock = threading.Lock()
        self._count = 0
 
    def increment(self) -> None:
        with self._lock:
            self._count += 1  # atomic under the lock
 
    def get_count(self) -> int:
        with self._lock:
            return self._count
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    counter = SafeCounter()
 
    def task() -> None:
        for _ in range(1000):
            counter.increment()
 
    t1 = threading.Thread(target=task)
    t2 = threading.Thread(target=task)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
 
    # Always 2000 — the lock removes the race.
    print(f"Final Count: {counter.get_count()}")

class SharedData {
    volatile boolean flag = false;
 
    public void writer() {
        flag = true;
    }
 
    public void reader() {
        if (flag) {
            // guaranteed to see true if another thread wrote it
        }
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) throws InterruptedException {
        SharedData data = new SharedData();
 
        Thread writerThread = new Thread(data::writer);
        writerThread.start();
        writerThread.join();
 
        // volatile guarantees this thread sees the write made on the other thread
        System.out.println("Flag visible after join? " + data.flag);
    }
}

// expects-nondeterministic: the final count lands below 2000 each run
class Counter {
    volatile int count = 0;
 
    public void increment() {
        count++; // Still unsafe!
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
 
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
 
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
 
        // Expect 2000, but volatile alone doesn't prevent the lost-update race.
        System.out.println("Final Count: " + counter.count);
    }
}

import java.util.concurrent.atomic.AtomicInteger;
 
class PurchaseAtomicCounter {
 
    // A thread-safe integer backed by hardware-level CAS
    private final AtomicInteger likes = new AtomicInteger(0);
 
    // Atomically add 1 to the like counter
    public void incrementLikes() {
        int prev, next;
        do {
 
            // Step 1  – read the current value.
            //           (May be outdated if another thread wins the race.)
            prev = likes.get();
 
            // Step 2  – compute the desired next value.
            next = prev + 1;
 
            // Step 3  – attempt to swap:
            /*          "If current value is still 'prev', set it to 'next'."
             *          Returns true on success, false if another thread
             *          already changed the value (retry needed).
             */
        } while (!likes.compareAndSet(prev, next));
    }
 
    // Read-only accessor
    public int getCount() {
        return likes.get();
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) throws InterruptedException {
        PurchaseAtomicCounter counter = new PurchaseAtomicCounter();
 
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementLikes();
            }
        };
 
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
 
        // Always 2000 — compareAndSet retries until it wins, no lost updates.
        System.out.println("Final Count: " + counter.getCount());
    }
}

import threading
 
 
class PurchaseAtomicCounter:
    def __init__(self) -> None:
        self._lock = threading.Lock()
        self._likes = 0
 
    def increment_likes(self) -> None:
        with self._lock:
            self._likes += 1
 
    def get_count(self) -> int:
        with self._lock:
            return self._likes
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    counter = PurchaseAtomicCounter()
 
    def task() -> None:
        for _ in range(1000):
            counter.increment_likes()
 
    t1 = threading.Thread(target=task)
    t2 = threading.Thread(target=task)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
 
    # Always 2000 — Lock-guarded, not lock-free, but race-free.
    print(f"Final Count: {counter.get_count()}")

// expects-nondeterministic: thread scheduling decides the interleaving, so the output order varies between runs
import java.util.concurrent.locks.ReentrantLock;
 
class TicketBooking {
    // Number of seats initially available
    private int availableSeats = 1;
 
    // Dedicated lock for this shared resource
    private final ReentrantLock lock = new ReentrantLock();
 
    // Public method to book a ticket
    public void bookTicket(String user) {
        System.out.println(user + " is trying to book...");
 
        // Acquire the lock – blocks until available
        lock.lock();
        try {
            System.out.println(user + " acquired lock.");
 
            // Critical section: check and update shared state
            if (availableSeats > 0) {
                System.out.println(user + " successfully booked the ticket.");
                availableSeats--;
            } else {
                System.out.println(user + " could not book the ticket. No seats left.");
            }
        } finally {
            // Always release the lock in a finally block
            System.out.println(user + " is releasing the lock.");
            lock.unlock();
        }
    }
}
 
class Main {
    public static void main(String[] args) {
        // Shared instance of TicketBooking
        TicketBooking bookingSystem = new TicketBooking();
 
        // Create two threads representing two users trying to book at the same time
        Thread user1 = new Thread(() -> bookingSystem.bookTicket("User 1"));
        Thread user2 = new Thread(() -> bookingSystem.bookTicket("User 2"));
 
        // Start both threads
        user1.start();
        user2.start();
 
        // Wait for both threads to finish
        try {
            user1.join();
            user2.join();
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted: " + e.getMessage());
        }
    }
}

import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;
 
// ───────────────────────── ExpiringReentrantLock ─────────────────────────
 
// Lock with a built-in "auto-release after N ms" timer
class ExpiringReentrantLock {
    // underlying mutual-exclusion lock
    private final ReentrantLock lock = new ReentrantLock();
 
    // single-thread scheduler to run the expiry task
    private final ScheduledExecutorService scheduler =
            Executors.newSingleThreadScheduledExecutor();
 
    // volatile flag: set to true by the owner, cleared by the timer or owner
    private volatile boolean isLocked = false;
 
    // Tries to acquire immediately; if successful, schedules auto-unlock signal
    public boolean tryLockWithExpiry(long timeoutMillis) {
 
        // attempt immediate acquisition (no blocking)
        boolean acquired = lock.tryLock();
        if (acquired) {
            isLocked = true; // signal that a timed session is active
 
            // schedule a flag-clearing task after timeout
            // NOTE: the scheduler thread cannot call lock.unlock() directly
            // because ReentrantLock only permits the OWNER thread to unlock.
            // Instead, we clear the flag so the owner thread knows to release.
            scheduler.schedule(() -> {
                if (isLocked) {
                    System.out.println("Timeout reached – signalling owner to release.");
                    isLocked = false; // owner thread will pick this up
                }
            }, timeoutMillis, TimeUnit.MILLISECONDS);
        }
        return acquired;
    }
 
    // Called by the owner thread to release the lock.
    // If the timer already cleared the flag, this still performs cleanup.
    public void unlockSafely() {
        if (lock.isHeldByCurrentThread()) {
            isLocked = false;
            lock.unlock();
            System.out.println("Lock released by " + Thread.currentThread().getName());
        }
    }
 
    // Graceful shutdown for the scheduler
    public void shutdown() {
        scheduler.shutdownNow();
    }
}
 
// ───────────────────────────── Driver code ──────────────────────────────
 
class Main {
    public static void main(String[] args) {
        // shared expiring lock
        ExpiringReentrantLock expLock = new ExpiringReentrantLock();
 
        /* Idle user grabs the lock, simulates going idle for 5 s,
           then checks the flag and releases the lock */
        Thread idleUser = new Thread(() -> {
            if (expLock.tryLockWithExpiry(3000)) {
                System.out.println("IdleUser acquired lock, going idle...");
                try { Thread.sleep(5000); } // simulate long idle
                catch (InterruptedException ignored) {}
                // Release – timer has already cleared isLocked by now
                expLock.unlockSafely();
            }
        }, "IdleUser");
 
        /* Active user starts after 1 s and keeps retrying every 1000 ms
           until the idle thread releases the lock */
        Thread activeUser = new Thread(() -> {
            try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
            while (true) {
                if (expLock.tryLockWithExpiry(3000)) {
                    System.out.println("ActiveUser booked!");
                    expLock.unlockSafely();
                    break;
                } else {
                    System.out.println("ActiveUser still waiting...");
                    try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
                }
            }
        }, "ActiveUser");
 
        idleUser.start();
        activeUser.start();
 
        try {
            idleUser.join();
            activeUser.join();
        } catch (InterruptedException ignored) {}
 
        expLock.shutdown();
    }
}

import threading
import time
 
 
class ExpiringLock:
    def __init__(self) -> None:
        self._lock = threading.Lock()
 
    def try_lock_with_expiry(self, timeout_seconds: float) -> bool:
        acquired = self._lock.acquire(blocking=False)
        if acquired:
            timer = threading.Timer(timeout_seconds, self._expire)
            timer.daemon = True
            timer.start()
        return acquired
 
    def _expire(self) -> None:
        # Best-effort: only release if still locked (the owner may already
        # have released it). A production version would guard this window
        # with its own bookkeeping lock.
        if self._lock.locked():
            print("Timeout reached - force-releasing the lock.")
            try:
                self._lock.release()
            except RuntimeError:
                pass  # already released between the check and here
 
    def unlock_safely(self) -> None:
        if self._lock.locked():
            try:
                self._lock.release()
                print("Lock released.")
            except RuntimeError:
                pass
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    exp_lock = ExpiringLock()
 
    def idle_user() -> None:
        if exp_lock.try_lock_with_expiry(1.0):
            print("IdleUser acquired lock, going idle...")
            time.sleep(2.0)  # goes idle past the 1s expiry
            exp_lock.unlock_safely()
 
    def active_user() -> None:
        time.sleep(0.5)
        while True:
            if exp_lock.try_lock_with_expiry(1.0):
                print("ActiveUser booked!")
                exp_lock.unlock_safely()
                break
            print("ActiveUser still waiting...")
            time.sleep(0.5)
 
    t1 = threading.Thread(target=idle_user)
    t2 = threading.Thread(target=active_user)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
 
// Booking system that waits up to 2 s for a lock
class TicketBookingTryLock {
 
    // shared resource: initial seat count
    private int availableSeats = 1;
 
    // exclusive lock protecting seat updates
    private final ReentrantLock lock = new ReentrantLock();
 
    // attempts to book a ticket for the given user
    public void bookTicket(String user) {
        System.out.println(user + " is trying to book...");
 
        // remember whether we actually got the lock
        boolean lockAcquired = false;
        try {
            // wait up to 2 s before giving up
            lockAcquired = lock.tryLock(2, TimeUnit.SECONDS);
 
            if (lockAcquired) {
                System.out.println(user + " acquired lock.");
 
                // critical section – safe to inspect/update seats
                if (availableSeats > 0) {
                    System.out.println(user + " successfully booked the ticket.");
                    availableSeats--;
                } else {
                    System.out.println(user + " could not book the ticket. No seats left.");
                }
 
                // simulate a long operation that holds the lock
                // this helps demonstrate the timeout behavior for the next user
                Thread.sleep(3000);
            } else {
                System.out.println(user + " could not acquire lock. Try again later.");
            }
        }
        catch (InterruptedException e) {
            // restore interrupt status and log
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }
        finally {
            // release only if we were the owner
            if (lockAcquired) {
                System.out.println(user + " is releasing the lock.");
                lock.unlock();
            }
        }
    }
}
 
 
class Main {
    public static void main(String[] args) {
 
        // one shared booking system
        TicketBookingTryLock booking = new TicketBookingTryLock();
 
        // first user attempts booking immediately
        Thread user1 = new Thread(() -> booking.bookTicket("User 1"));
 
        // second user arrives 500 ms later and may time-out
        Thread user2 = new Thread(() -> {
            try { Thread.sleep(500); } catch (InterruptedException ignored) {}
            booking.bookTicket("User 2");
        });
 
        user1.start();
        user2.start();
    }
}

import threading
import time
 
 
class TicketBooking:
    def __init__(self) -> None:
        self.available_seats = 1
        self._lock = threading.Lock()
 
    def book_ticket(self, user: str) -> None:
        print(f"{user} is trying to book...")
 
        self._lock.acquire()  # blocks until available
        try:
            print(f"{user} acquired lock.")
            if self.available_seats > 0:
                print(f"{user} successfully booked the ticket.")
                self.available_seats -= 1
            else:
                print(f"{user} could not book the ticket. No seats left.")
        finally:
            print(f"{user} is releasing the lock.")
            self._lock.release()
 
 
class TicketBookingTryLock:
    def __init__(self) -> None:
        self.available_seats = 1
        self._lock = threading.Lock()
 
    def book_ticket(self, user: str) -> None:
        print(f"{user} is trying to book...")
 
        lock_acquired = self._lock.acquire(timeout=2)  # wait up to 2s
        try:
            if lock_acquired:
                print(f"{user} acquired lock.")
                if self.available_seats > 0:
                    print(f"{user} successfully booked the ticket.")
                    self.available_seats -= 1
                else:
                    print(f"{user} could not book the ticket. No seats left.")
                time.sleep(3)  # hold the lock, to show the next user timing out
            else:
                print(f"{user} could not acquire lock. Try again later.")
        finally:
            if lock_acquired:
                print(f"{user} is releasing the lock.")
                self._lock.release()
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    print("--- Plain lock()/unlock() ---")
    booking = TicketBooking()
    user1 = threading.Thread(target=booking.book_ticket, args=("User 1",))
    user2 = threading.Thread(target=booking.book_ticket, args=("User 2",))
    user1.start()
    user2.start()
    user1.join()
    user2.join()
 
    print("\n--- tryLock(timeout) ---")
    timed_booking = TicketBookingTryLock()
    tuser1 = threading.Thread(target=timed_booking.book_ticket, args=("User 1",))
 
    def delayed_user2() -> None:
        time.sleep(0.5)
        timed_booking.book_ticket("User 2")
 
    tuser2 = threading.Thread(target=delayed_user2)
    tuser1.start()
    tuser2.start()
    tuser1.join()
    tuser2.join()

import java.util.concurrent.locks.*;
 
// Shared stock price data guarded by a ReadWriteLock
class StockData {
    private double price = 100.0;  // initial price
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
 
    // Writer: updates price
    public void updatePrice(double newPrice) {
        lock.writeLock().lock();  // acquire write lock
        try {
            System.out.printf("%s updating price to %.2f%n",
                    Thread.currentThread().getName(), newPrice);
            price = newPrice;
        } finally {
            lock.writeLock().unlock(); // release write lock
        }
    }
 
    // Reader: reads price
    public void readPrice() {
        lock.readLock().lock();   // acquire read lock
        try {
            System.out.printf("%s read price: %.2f%n",
                    Thread.currentThread().getName(), price);
        } finally {
            lock.readLock().unlock();  // release read lock
        }
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) throws InterruptedException {
        StockData stock = new StockData();
 
        // Sequenced (not concurrent) so the demo's output stays deterministic;
        // the class itself is what actually provides the concurrency safety.
        Thread reader1 = new Thread(stock::readPrice, "Reader-1");
        reader1.start();
        reader1.join();
 
        Thread writer = new Thread(() -> stock.updatePrice(105.50), "Writer-1");
        writer.start();
        writer.join();
 
        Thread reader2 = new Thread(stock::readPrice, "Reader-2");
        reader2.start();
        reader2.join();
    }
}

// expects-nondeterministic: thread scheduling decides the interleaving, so the output order varies between runs
import java.util.concurrent.Semaphore;
 
// Enforces a max-devices policy for a premium account
class PremiumAccount {
 
    // fixed number of login permits (tokens)
    private final Semaphore deviceSlots;
 
    // constructor sets permit count
    public PremiumAccount(int maxDevices) {
        this.deviceSlots = new Semaphore(maxDevices);
    }
 
    // user attempts to log in
    public boolean login(String user) throws InterruptedException {
        System.out.println(user + " trying to log in...");
 
        // try to grab a permit immediately (non-blocking)
        if (deviceSlots.tryAcquire()) {
            System.out.println(user + " successfully logged in.");
            return true;
        } else {
            System.out.println(user + " denied login - too many devices.");
            return false;
        }
    }
 
    // user logs out and returns the permit
    public void logout(String user) {
        System.out.println(user + " logging out.");
        deviceSlots.release();  // release permit for next device
    }
}
 
// Quick demo – 2 device limit
class Main {
    public static void main(String[] args) throws InterruptedException {
        PremiumAccount account = new PremiumAccount(2);
 
        Thread u1 = new Thread(() -> trySession(account, "User-A"));
        Thread u2 = new Thread(() -> trySession(account, "User-B"));
        Thread u3 = new Thread(() -> trySession(account, "User-C")); // should fail first
 
        u1.start(); u2.start();
        Thread.sleep(100);  // ensure first two log in
        u3.start();
 
        u1.join(); u2.join(); u3.join();
    }
 
    // helper for a user session
    private static void trySession(PremiumAccount acc, String name) {
        try {
            if (acc.login(name)) {
                Thread.sleep(500);  // simulate watching a video
                acc.logout(name);
            }
        } catch (InterruptedException ignored) { }
    }
}

# expects-nondeterministic: thread scheduling decides which user's logout prints first
import threading
import time
 
 
class PremiumAccount:
    def __init__(self, max_devices: int) -> None:
        self._device_slots = threading.Semaphore(max_devices)
 
    def login(self, user: str) -> bool:
        print(f"{user} trying to log in...")
        if self._device_slots.acquire(blocking=False):
            print(f"{user} successfully logged in.")
            return True
        print(f"{user} denied login - too many devices.")
        return False
 
    def logout(self, user: str) -> None:
        print(f"{user} logging out.")
        self._device_slots.release()
 
 
def try_session(account: PremiumAccount, name: str) -> None:
    if account.login(name):
        time.sleep(0.5)  # simulate watching a video
        account.logout(name)
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    account = PremiumAccount(2)
 
    u1 = threading.Thread(target=try_session, args=(account, "User-A"))
    u2 = threading.Thread(target=try_session, args=(account, "User-B"))
    u3 = threading.Thread(target=try_session, args=(account, "User-C"))  # should fail first
 
    u1.start()
    u2.start()
    time.sleep(0.1)  # ensure the first two log in
    u3.start()
 
    u1.join()
    u2.join()
    u3.join()

// expects-nondeterministic: thread scheduling decides the interleaving, so the output order varies between runs
// ──────────────────────────────────────────────────────────────
// A simple mutable account object guarded by its intrinsic lock
// ──────────────────────────────────────────────────────────────
class BankAccount {
 
    // Name helps us identify the account in logs
    private final String name;
 
    // Shared mutable state that needs protection
    private int balance;
 
    // Constructor – sets initial state
    public BankAccount(String name, int balance) {
        this.name = name;
        this.balance = balance;
    }
 
    // Read-only helper used only for logging
    public String getName() {
        return name;
    }
 
    // Deposit is a critical section – guard with the object's lock
    public synchronized void deposit(int amount) {
        balance += amount;
    }
 
    public synchronized void withdraw(int amount) { balance -= amount; }
 
    public int getBalance() { return balance; }
}
 
class TransferTask implements Runnable {
    private final BankAccount from;
    private final BankAccount to;
    private final int amount;
 
    public TransferTask(BankAccount from, BankAccount to, int amount) {
        this.from = from; this.to = to; this.amount = amount;
    }
 
    @Override
    public void run() {
        // First lock: 'from' account
        synchronized (from) {
            System.out.println(Thread.currentThread().getName() +
                               " locked " + from.getName());
 
            // Artificial delay widens timing window
            try { Thread.sleep(100); } catch (InterruptedException ignored) {}
 
            // Second lock: 'to' account - may block if another thread owns it
            synchronized (to) {
                System.out.println(Thread.currentThread().getName() +
                                   " locked " + to.getName());
                from.withdraw(amount);
                to.deposit(amount);
                System.out.println("Transferred " + amount + " from " +
                                   from.getName() + " to " + to.getName());
            }
        }
    }
}
 
// ── Driver (was "DeadlockDemoMain") ────────────────────────────────────────
class Main {
    public static void main(String[] args) throws Exception {
        BankAccount accountA = new BankAccount("Account-A", 1000);
        BankAccount accountB = new BankAccount("Account-B", 1000);
 
        // T1 transfers A to B
        Thread t1 = new Thread(new TransferTask(accountA, accountB, 100), "T1");
        // T2 transfers B to A (reverse order - causes deadlock)
        Thread t2 = new Thread(new TransferTask(accountB, accountA, 200), "T2");
 
        t1.start();
        t2.start();
 
        // A real deadlock has no timer and blocks forever; we bound the wait
        // here only so this sandboxed demo can observe and report it.
        t1.join(3000);
        t2.join(3000);
 
        if (t1.isAlive() || t2.isAlive()) {
            System.out.println("⚠️ Both threads are still blocked after 3s — this is the deadlock.");
            System.exit(0);
        }
 
        // This line is never reached - deadlock occurred
        System.out.println("Both threads finished execution.");
    }
}

import threading
import time
 
 
class BankAccount:
    def __init__(self, name: str, balance: int) -> None:
        self.name = name
        self._balance = balance
        # Java's synchronized(obj) locks the object's own monitor, so any
        # code can lock on it directly. Python has no implicit per-object
        # monitor, so the Lock is exposed explicitly and locked on directly.
        self.lock = threading.Lock()
 
    def deposit(self, amount: int) -> None:
        self._balance += amount
 
    def withdraw(self, amount: int) -> None:
        self._balance -= amount
 
 
def transfer(src: BankAccount, dst: BankAccount, amount: int) -> None:
    name = threading.current_thread().name
    with src.lock:
        print(f"{name} locked {src.name}")
        time.sleep(0.1)  # widen the timing window
 
        with dst.lock:
            print(f"{name} locked {dst.name}")
            src.withdraw(amount)
            dst.deposit(amount)
            print(f"Transferred {amount} from {src.name} to {dst.name}")
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    account_a = BankAccount("Account-A", 1000)
    account_b = BankAccount("Account-B", 1000)
 
    t1 = threading.Thread(target=transfer, args=(account_a, account_b, 100), name="T1", daemon=True)
    t2 = threading.Thread(target=transfer, args=(account_b, account_a, 200), name="T2", daemon=True)
 
    t1.start()
    t2.start()
 
    # A real deadlock has no timer and blocks forever; we bound the wait
    # here only so this sandboxed demo can observe and report it.
    t1.join(timeout=3)
    t2.join(timeout=3)
 
    if t1.is_alive() or t2.is_alive():
        print("Both threads are still blocked after 3s - this is the deadlock.")
    else:
        print("Both threads finished execution.")  # never reached — deadlock occurred

// expects-nondeterministic: thread scheduling decides the interleaving, so the output order varies between runs
import java.util.*;
 
// ── Driver (was "LockOrderingSimple") ──────────────────────────────────────
class Main {
 
    static class Resource {
        int id;
        int value;
 
        public Resource(int id, int value) {
            this.id = id;
            this.value = value;
        }
    }
 
    public static void main(String[] args) {
        Resource r1 = new Resource(101, 500);
        Resource r2 = new Resource(102, 300);
 
        Runnable task1 = () -> transfer(r1, r2, 50);
        Runnable task2 = () -> transfer(r2, r1, 30);
 
        new Thread(task1, "T1").start();
        new Thread(task2, "T2").start();
    }
 
    public static void transfer(Resource a, Resource b, int amount) {
        Resource[] locks = new Resource[] {a, b};
 
        // Sort by unique ID - guarantees a consistent global lock order
        Arrays.sort(locks, (x, y) -> Integer.compare(x.id, y.id));
 
        synchronized (locks[0]) {
            System.out.println(Thread.currentThread().getName() +
                               " locked " + locks[0].id);
            try {
                Thread.sleep(50);
            } catch (InterruptedException ignored) {}
 
            synchronized (locks[1]) {
                System.out.println(Thread.currentThread().getName() +
                                   " locked " + locks[1].id);
                System.out.println("Transferred " + amount +
                                   " from " + a.id + " to " + b.id);
            }
        }
    }
}

import threading
import time
 
 
class Resource:
    def __init__(self, resource_id: int, value: int) -> None:
        self.id = resource_id
        self.value = value
        self.lock = threading.Lock()
 
 
def transfer(a: Resource, b: Resource, amount: int) -> None:
    name = threading.current_thread().name
    # Sort by unique ID - guarantees a consistent global lock order
    first, second = sorted((a, b), key=lambda r: r.id)
 
    with first.lock:
        print(f"{name} locked {first.id}")
        time.sleep(0.05)
 
        with second.lock:
            print(f"{name} locked {second.id}")
            print(f"Transferred {amount} from {a.id} to {b.id}")
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    r1 = Resource(101, 500)
    r2 = Resource(102, 300)
 
    t1 = threading.Thread(target=transfer, args=(r1, r2, 50), name="T1")
    t2 = threading.Thread(target=transfer, args=(r2, r1, 30), name="T2")
 
    t1.start()
    t2.start()
    t1.join()
    t2.join()

// expects-nondeterministic: lock acquisition races, so which thread wins varies between runs
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
 
// ── Driver (was "TryLockWithTimeout") ──────────────────────────────────────
class Main {
 
    static class Resource {
        final int id;
        final ReentrantLock lock = new ReentrantLock();
 
        public Resource(int id) { this.id = id; }
    }
 
    public static void main(String[] args) {
        Resource r1 = new Resource(1);
        Resource r2 = new Resource(2);
 
        Runnable task1 = () -> tryTransfer(r1, r2);
        Runnable task2 = () -> tryTransfer(r2, r1);
 
        new Thread(task1, "T1").start();
        new Thread(task2, "T2").start();
    }
 
    public static void tryTransfer(Resource a, Resource b) {
        boolean acquiredA = false;
        boolean acquiredB = false;
 
        try {
            acquiredA = a.lock.tryLock(100, TimeUnit.MILLISECONDS);
            if (acquiredA) {
                System.out.println(Thread.currentThread().getName() +
                                   " locked Resource " + a.id);
                Thread.sleep(50);
 
                acquiredB = b.lock.tryLock(100, TimeUnit.MILLISECONDS);
                if (acquiredB) {
                    System.out.println(Thread.currentThread().getName() +
                                       " locked Resource " + b.id);
                    System.out.println("Transfer successful between " +
                                       a.id + " and " + b.id);
                } else {
                    System.out.println(Thread.currentThread().getName() +
                                       " could not lock Resource " + b.id +
                                       " - backing off");
                }
            } else {
                System.out.println(Thread.currentThread().getName() +
                                   " could not lock Resource " + a.id +
                                   " - backing off");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (acquiredB) b.lock.unlock();
            if (acquiredA) a.lock.unlock();
        }
    }
}