Explicit Locks — ReentrantLock, ReadWriteLock & StampedLock

class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count;

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

if (lock.tryLock(500, TimeUnit.MILLISECONDS)) {
    try {
        updateInventory();
    } finally {
        lock.unlock();
    }
} else {
    throw new ServiceBusyException("Inventory is busy, try again");
}

lock.lockInterruptibly();   // a thread blocked here can be cancelled with interrupt()
try {
    process();
} finally {
    lock.unlock();
}

ReentrantLock fairLock = new ReentrantLock(true);

class BoundedBuffer<T> {
    private final Queue<T> items = new ArrayDeque<>();
    private final int capacity;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull  = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    BoundedBuffer(int capacity) { this.capacity = capacity; }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (items.size() == capacity) {
                notFull.await();          // producers wait here
            }
            items.add(item);
            notEmpty.signal();            // wake exactly one consumer
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (items.isEmpty()) {
                notEmpty.await();         // consumers wait here
            }
            T item = items.remove();
            notFull.signal();             // wake exactly one producer
            return item;
        } finally {
            lock.unlock();
        }
    }
}

class ProductCache {
    private final Map<Long, Product> cache = new HashMap<>();
    private final ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
    private final Lock readLock  = rw.readLock();
    private final Lock writeLock = rw.writeLock();

    public Product get(long id) {
        readLock.lock();              // many threads can hold this at once
        try {
            return cache.get(id);
        } finally {
            readLock.unlock();
        }
    }

    public void put(long id, Product p) {
        writeLock.lock();             // exclusive: waits for all readers to leave
        try {
            cache.put(id, p);
        } finally {
            writeLock.unlock();
        }
    }
}

class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead();     // no locking
        double cx = x, cy = y;
        if (!sl.validate(stamp)) {               // a write happened — fall back
            stamp = sl.readLock();
            try {
                cx = x;
                cy = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.hypot(cx, cy);
    }

    void move(double dx, double dy) {
        long stamp = sl.writeLock();
        try {
            x += dx;
            y += dy;
        } finally {
            sl.unlockWrite(stamp);
        }
    }
}