Difference Between Thread.sleep() and Object.wait()

Thread.sleep() and Object.wait() both pause a thread, which is why they are often confused. sleep() pauses the current thread for a fixed time and keeps any locks it holds. wait() pauses the thread until another thread signals it with notify() or notifyAll(), and releases the lock while it waits. In this lesson, you will see the most important difference, what happens to the lock, in code, and then compare the two methods side by side.

Example: Who Can Get the Lock?

Let's see an example where one thread pauses while holding a lock, first with sleep and then with wait, and a second thread tries to take the same lock.

public class SleepVsWait {
    static final Object lock = new Object();
 
    static void test(String label, boolean useWait)
            throws InterruptedException {
        Thread pauser = new Thread(() -> {
            synchronized (lock) {
                try {
                    if (useWait) {
                        lock.wait(500);
                    } else {
                        Thread.sleep(500);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        pauser.start();
        Thread.sleep(100);
 
        long start = System.nanoTime();
        synchronized (lock) {
            long waited = (System.nanoTime() - start) / 1_000_000;
            System.out.println(label + ": Srihitha got the lock after waiting "
                + (waited > 200 ? "a long time" : "almost no time"));
        }
        pauser.join();
    }
 
    public static void main(String[] args) throws InterruptedException {
        test("sleep()", false);
        test("wait() ", true);
    }
}

sleep(): Srihitha got the lock after waiting a long time
wait() : Srihitha got the lock after waiting almost no time

Explanation: With sleep, the pausing thread kept the lock, so the main thread had to wait about 400 milliseconds until it woke up and left the block. With wait, the pausing thread released the lock as soon as it started waiting, so the main thread got it almost immediately.

Differences Between sleep() and wait()

Common Mistakes

Calling sleep inside synchronized and expecting other threads to proceed. They're blocked until it finishes.

Calling wait outside synchronized. It throws.

Polling with sleep instead of waiting for a signal. It wastes time and reacts slowly.

Interview Corner

Practice

1. Easy: Print the thread state of a thread that is in sleep(1000) and of one in lock.wait().
2. Harder: Replace a "sleep 100 ms and check a flag" loop with wait/notifyAll, and measure how much faster the waiting thread reacts.

Key Takeaways