java.util.concurrent.locks

---

1. Thread Synchronization with ReentrantLock

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        try {
            lock.lock();
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        try {
            lock.lock();
            return count;
        } finally {
            lock.unlock();
        }
    }
}

2. Inter-Thread Communication with Condition Variables

public class ConditionVariableExample {
    private final Object lock = new Object();
    private boolean dataReady = false;

    private void produceData() {
        synchronized (lock) {
            dataReady = true;
            lock.notifyAll();
        }
    }

    private void consumeData() {
        synchronized (lock) {
            while (!dataReady) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // Consume data
        }
    }
}

3. Reader-Writer Lock for Concurrent Data Access

public class ReaderWriterLockExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    private int data = 0;

    public void read() {
        try {
            lock.readLock().lock();
            System.out.println(data);
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write() {
        try {
            lock.writeLock().lock();
            data++;
        } finally {
            lock.writeLock().unlock();
        }
    }
}

4. Semaphore for Resource Allocation

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3);

    public void accessResource() {
        try {
            semaphore.acquire();
            // Use resource
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

5. CountDownLatch for Synchronizing Events

public class CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(3);

    public void task1() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Execute task 1
    }

    public void task2() {
        // Execute task 2
        latch.countDown();
    }

    public void task3() {
        // Execute task 3
        latch.countDown();
    }
}

6. Phaser for Parallel Tasks

public class PhaserExample {
    private final Phaser phaser = new Phaser(3);

    public void task1() {
        // Execute task 1
        phaser.arriveAndAwaitAdvance();
    }

    public void task2() {
        // Execute task 2
        phaser.arriveAndAwaitAdvance();
    }

    public void task3() {
        // Execute task 3
        phaser.arriveAndDeregister();
    }
}

7. Exchanger for Data Exchange

public class ExchangerExample {
    private final Exchanger<Object> exchanger = new Exchanger<>();

    public void swapData() {
        try {
            Object data1 = exchanger.exchange(new Object());
            Object data2 = exchanger.exchange(data1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

8. StampedLock for Optimistic Concurrency

public class StampedLockExample {
    private final StampedLock lock = new StampedLock();

    private int data = 0;

    public void read() {
        long stamp = lock.tryOptimisticRead();
        int currentData = data;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                currentData = data;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        // Use data
    }

    public void write() {
        long stamp = lock.writeLock();
        try {
            data++;
        } finally {
            lock.unlockWrite(stamp);
        }
    }
}

9. Synchronizer for Thread Synchronization

public class SynchronizerExample {
    private final Synchronizer<Object> synchronizer = new Synchronizer<>();

    public void task1() {
        try {
            Object result = synchronizer.acquireInterruptibly(1000);
            // Process result
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void task2() {
        // Generate result
        synchronizer.release(result);
    }
}

10. LockSupport for Thread Suspension

public class LockSupportExample {
    public void suspendThread() {
        Thread thread = new Thread(() -> {
            while (true) {
                LockSupport.park(); // Suspend thread
            }
        });
        thread.start();
    }

    public void resumeThread() {
        LockSupport.unpark(thread); // Resume thread
    }
}

11. Semaphore with Fairness

public class FairSemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3, true);

    public void accessResource() {
        try {
            semaphore.acquire();
            // Use resource
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

12. ReentrantLock with Timeout

public class ReentrantLockWithTimeoutExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void lockWithTimeout() {
        try {
            if (lock.tryLock(1000, TimeUnit.MILLISECONDS)) {
                // Acquire lock
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

13. CyclicBarrier for Synchronizing Threads

public class CyclicBarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(3);

    public void task1() {
        try {
            barrier.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
        // Execute task 1
    }

    public void task2() {
        try {
            barrier.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
        // Execute task 2
    }

    public void task3() {
        try {
            barrier.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
        // Execute task 3
    }
}

14. StampedLock with Read-Write Locks

public class StampedLockWithReadWriteLocksExample {
    private final StampedLock lock = new StampedLock();

    private int data = 0;

    public void read() {
        long stamp = lock.readLock();
        try {
            int currentData = data;
        } finally {
            lock.unlockRead(stamp);
        }
    }

    public void write() {
        long stamp = lock.writeLock();
        try {
            data++;
        } finally {
            lock.unlockWrite(stamp);
        }
    }
}

15. CountDownLatch with Multiple Awaiters

public class CountDownLatchWithMultipleAwaitersExample {
    private final CountDownLatch latch = new CountDownLatch(3);

    public void task1() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Execute task 1
    }

    public void task2() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // Execute task 2
    }

    public void task3() {
        latch.countDown();
    }

    public void task4() {
        latch.countDown();
    }

    public void task5() {
        latch.countDown();
    }
}

16. Exchanger with Object Transfer

public class ExchangerWithObjectTransferExample {
    private final Exchanger<Object> exchanger = new Exchanger<>();

    public void task1() {
        try {
            Object object = exchanger.exchange(new Object());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void task2() {
        try {
            Object object = exchanger.exchange(new Object());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

17. ConditionVariable with Multiple Waiters

public class ConditionVariableWithMultipleWaitersExample {
    private final Object lock = new Object();
    private final ConditionVariable cv = lock.newCondition();
    private boolean dataReady = false;

    public void producer() {
        synchronized (lock) {
            while (!dataReady) {
                try {
                    cv.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // Produce data
        }
    }

    public void consumer() {
        synchronized (lock) {
            dataReady = true;
            cv.signalAll();
        }
    }
}

18. StampedLock with Write-Write Lock

public class StampedLockWithWriteWriteLockExample {
    private final StampedLock lock = new StampedLock();

    private int data = 0;

    public void write1() {
        long stamp = lock.writeLock();
        try {
            data++;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    public void write2() {
        long stamp = lock.tryWriteLock(1000, TimeUnit.MILLISECONDS);
        try {
            data++;
        } finally {
            lock.unlockWrite(stamp);
        }
    }
}

19. ConditionVariable with Timed Waiting

public class ConditionVariableWithTimedWaitingExample {
    private final Object lock = new Object();
    private final ConditionVariable cv = lock.newCondition();
    private boolean dataReady = false;

    public void producer() {
        synchronized (lock) {
            dataReady = true;
            cv.signalAll();
        }
    }

    public void consumer() {
        synchronized (lock) {
            try {
                cv.await(1000, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (dataReady) {
                // Consume data
            }
        }
    }
}

20. ReaderWriterLock with Priority

public class ReaderWriterLockWithPriorityExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock(true);

    private int data = 0;

    public void read() {
        try {
            lock.readLock().lock();
            int currentData = data;
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write() {
        try {
            lock.writeLock().lock();
            data++;
        } finally {
            lock.writeLock().unlock();
        }
    }
}

21. ReentrantLock with Interrupt Handling

public class ReentrantLockWithInterruptHandlingExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void lockWithInterruptHandling() {
        try {
            lock.lockInterruptibly();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

22. CyclicBarrier with BarrierAction