Thread Priority and sleep()

Java gives every thread an integer priority that hints to the thread scheduler how much CPU preference it should receive relative to other threads, and it gives every thread the ability to pause its own execution for a fixed period using Thread.sleep(). Both mechanisms influence when a thread runs, but neither one guarantees exact timing or exact ordering, because the underlying OS scheduler ultimately makes the real decisions.

Why it matters

Thread.sleep() is the simplest way to pause, and it appears in retries, polling loops and tests. It forces you to deal with InterruptedException, which most beginners swallow incorrectly. Priorities are the opposite case: they look powerful but are only a hint, and relying on them for correctness is a mistake.

Thread Priority

Every thread has a priority in the range 1 to 10, controlled by setPriority(int) and read with getPriority(). Three named constants exist on Thread: MIN_PRIORITY (1), NORM_PRIORITY (5, the default for new threads unless inherited from the parent), and MAX_PRIORITY (10). A higher priority is only a hint to the scheduler that this thread should be favored for CPU time — it does not guarantee that a higher-priority thread runs first, runs more often, or finishes earlier, and behavior can vary noticeably across operating systems and JVM implementations. Priority should never be used as a substitute for proper synchronization or correctness logic.

• Thread.MIN_PRIORITY = 1
• Thread.NORM_PRIORITY = 5 (default)
• Thread.MAX_PRIORITY = 10

Thread.sleep()

Thread.sleep(long millis) pauses the currently executing thread for at least the given number of milliseconds (an overload also accepts nanoseconds), moving it into the TIMED_WAITING state. Because sleeping is interruptible, sleep() declares a checked exception, InterruptedException, which must be caught or declared. Importantly, sleeping does not release any intrinsic locks the thread currently holds — a thread that sleeps while inside a synchronized block continues to hold that lock the entire time, which can block other threads unexpectedly if not designed carefully.

sleep() Is Not a Precision Timer

sleep() guarantees the thread will sleep for at least the requested duration, not exactly that duration — OS scheduling granularity, system load, and JVM garbage collection pauses can all add extra delay. It should be used for approximate pacing (throttling, retry backoff, simple demos) rather than for time-critical operations.

Example

public class PriorityAndSleepDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread low = new Thread(() -> System.out.println("Low priority thread ran"));
        low.setPriority(Thread.MIN_PRIORITY);

        Thread high = new Thread(() -> System.out.println("High priority thread ran"));
        high.setPriority(Thread.MAX_PRIORITY);

        System.out.println("low priority: " + low.getPriority());
        System.out.println("high priority: " + high.getPriority());

        low.start();
        high.start();
        low.join();
        high.join();

        System.out.println("Main thread sleeping for 300ms...");
        Thread.sleep(300);
        System.out.println("Main thread resumed after sleep");
    }
}

low priority: 1
high priority: 10
Main thread sleeping for 300ms...
Main thread resumed after sleep
(Note: "Low priority thread ran" and "High priority thread ran" can print in either order —
priority is only a scheduling hint, not a guaranteed execution order.)

Exercise

Print a countdown from 3 to 1, pausing 200 milliseconds between numbers, and then print Go. Handle the checked exception that sleep can throw.

Expected output: 3, 2, 1, Go

public class Countdown {
    public static void main(String[] args) {
        for (int i = 3; i >= 1; i--) {
            System.out.println(i);
            // TODO: pause for 200 milliseconds, handling InterruptedException
        }
        System.out.println("Go");
    }
}

public class Countdown {
    public static void main(String[] args) {
        for (int i = 3; i >= 1; i--) {
            System.out.println(i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
        }
        System.out.println("Go");
    }
}

Quick quiz

Interview questions