What is the difference between ReentrantLock and synchronized?

synchronizedis Java's built-in locking mechanism. It is simple, automatic, and great when you just need to protect a critical section.

ReentrantLock gives you more control: timed lock attempts, interruptible waiting, optional fairness, and explicit locking/unlocking. It has the same basic mutual-exclusion idea as synchronized, but with extended capabilities.

With synchronized method:

private int count = 0;

public synchronized void increment() {
    count++;
}

Or with a synchronized block:

private final Object lock = new Object();
private int count = 0;

public void increment() {
    synchronized (lock) {
        count++;
    }
}

With ReentrantLock:

private final ReentrantLock lock = new ReentrantLock();
private int count = 0;

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

If synchronized already works, why have ReentrantLock? Because some systems need more control than “wait until the lock is available.”

With synchronized, if a thread reaches the lock, it waits until it can enter.

With ReentrantLock, you can ask: “Can I get the lock right now?” or “Can I get it within two seconds?”

if (lock.tryLock()) {
    try {
        // critical section
    } finally {
        lock.unlock();
    }
} else {
    // lock was busy, do something else
}

if (lock.tryLock(2, TimeUnit.SECONDS)) {
    try {
        // critical section
    } finally {
        lock.unlock();
    }
} else {
    // could not acquire lock within timeout
}

The timed version of tryLock allows a thread to wait for a limited amount of time before giving up. This is useful when waiting forever would be undesirable or dangerous.

Reentrant means the same thread can acquire the same lock more than once without deadlocking itself.

lock.lock();
try {
    // same thread can acquire again
    lock.lock();
    try {
        // nested protected work
    } finally {
        lock.unlock();
    }
} finally {
    lock.unlock();
}

The lock keeps a hold count. If the same thread locks twice, it must unlock twice before another thread can acquire it.

ReentrantLock can be created as fair:

Lock lock = new ReentrantLock(true);

A fair lock tries to grant access to the longest-waiting thread. This can reduce starvation, but it may reduce throughput because the system gives up some scheduling flexibility. Fair locks are usually more predictable, but often slightly slower than the default non-fair behavior.

This connects directly to the account transfer problem. If you need to lock two accounts, you still need consistent lock ordering to avoid deadlock.

public void transfer(Account from, Account to, int amount) {
    Account first = from.id() < to.id() ? from : to;
    Account second = from.id() < to.id() ? to : from;

    first.lock().lock();
    try {
        second.lock().lock();
        try {
            from.withdraw(amount);
            to.deposit(amount);
        } finally {
            second.lock().unlock();
        }
    } finally {
        first.lock().unlock();
    }
}

This is the ReentrantLock version of nested synchronized blocks. The idea is the same: acquire locks in a consistent order so two threads do not grab opposite locks and wait forever.