Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Thread Priority in Java — priority constants, setting priorities, how the thread scheduler uses priorities, priority inheritance, and why priorities are unreliable for correctness.
What is Thread Priority?
Thread priority is a hint to the thread scheduler about how important a thread is relative to others. Higher-priority threads are generally given more CPU time, but this behavior is platform-dependent and not guaranteed.
Priority Constants
java example
public class PriorityConstants {
public static void main(String[] args) {
System.out.println("=== Thread Priority Constants ===\n");
System.out.println("MIN_PRIORITY: " + Thread.MIN_PRIORITY); // 1
System.out.println("NORM_PRIORITY: " + Thread.NORM_PRIORITY); // 5 (default)
System.out.println("MAX_PRIORITY: " + Thread.MAX_PRIORITY); // 10
System.out.println("\nValid range: 1 to 10");
System.out.println("Default for new threads: 5 (NORM_PRIORITY)");
// Current thread priority
Thread main = Thread.currentThread();
System.out.println("\nMain thread priority: " + main.getPriority());
}
}Output:
| MIN_PRIORITY | 1 |
| NORM_PRIORITY | 5 (default) |
| MAX_PRIORITY | 10 |
| Valid range | 1 to 10 |
| Default for new threads | 5 (NORM_PRIORITY) |
| Main thread priority | 5 |
Setting and Getting Priority
Example
public class SetPriority {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Setting Thread Priority ===\n");
Thread high = new Thread(() -> doWork("HIGH"), "High-Thread");
Thread normal = new Thread(() -> doWork("NORM"), "Normal-Thread");
Thread low = new Thread(() -> doWork("LOW"), "Low-Thread");
// Set priorities BEFORE starting
high.setPriority(Thread.MAX_PRIORITY); // 10
normal.setPriority(Thread.NORM_PRIORITY); // 5
low.setPriority(Thread.MIN_PRIORITY); // 1
System.out.println("Priorities set:");
System.out.println(" " + high.getName() + ": " + high.getPriority());
System.out.println(" " + normal.getName() + ": " + normal.getPriority());
System.out.println(" " + low.getName() + ": " + low.getPriority());
System.out.println("\nStarting all threads simultaneously...\n");
high.start();
normal.start();
low.start();
high.join();
normal.join();
low.join();
System.out.println("\nDone! (Order may vary across runs)");
}
static void doWork(String label) {
long sum = 0;
for (int i = 0; i < 50_000_000; i++) {
sum += i;
}
System.out.println(" [" + label + "] Finished (sum=" + sum + ")");
}
}
Output (may vary — priorities are hints, not guarantees!):
| High-Thread | 10 |
| Normal-Thread | 5 |
| Low-Thread | 1 |
Priority Inheritance
A new thread inherits the priority of the thread that creates it:
java example
public class PriorityInheritance {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Priority Inheritance ===\n");
// Main thread has priority 5
System.out.println("Main priority: " + Thread.currentThread().getPriority());
// Child inherits from parent (main)
Thread child1 = new Thread(() -> {
System.out.println(" Child1 priority: " + Thread.currentThread().getPriority());
// Grandchild inherits from child1 (also 5)
Thread grandchild = new Thread(() -> {
System.out.println(" Grandchild priority: " + Thread.currentThread().getPriority());
});
grandchild.start();
try { grandchild.join(); } catch (InterruptedException e) {}
});
child1.start();
child1.join();
// Now change main priority and create another child
Thread.currentThread().setPriority(8);
System.out.println("\nMain priority changed to: " + Thread.currentThread().getPriority());
Thread child2 = new Thread(() -> {
System.out.println(" Child2 priority: " + Thread.currentThread().getPriority());
});
child2.start();
child2.join();
// Reset
Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
}
}Output:
| Main priority | 5 |
| Child1 priority | 5 |
| Grandchild priority | 5 |
| Main priority changed to | 8 |
| Child2 priority | 8 |
Priority and Scheduling Behavior
Example
public class PriorityEffect {
static volatile boolean running = true;
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Priority Effect on Scheduling ===\n");
System.out.println("Counting iterations in 2 seconds...\n");
long[] counts = new long[3];
Thread highThread = new Thread(() -> {
while (running) counts[0]++;
}, "HIGH-10");
Thread normThread = new Thread(() -> {
while (running) counts[1]++;
}, "NORM-5");
Thread lowThread = new Thread(() -> {
while (running) counts[2]++;
}, "LOW-1");
highThread.setPriority(10);
normThread.setPriority(5);
lowThread.setPriority(1);
highThread.start();
normThread.start();
lowThread.start();
Thread.sleep(2000);
running = false;
highThread.join();
normThread.join();
lowThread.join();
long total = counts[0] + counts[1] + counts[2];
System.out.println("Results after 2 seconds:");
System.out.printf(" HIGH (10): %,15d iterations (%5.1f%%)%n",
counts[0], 100.0 * counts[0] / total);
System.out.printf(" NORM (5): %,15d iterations (%5.1f%%)%n",
counts[1], 100.0 * counts[1] / total);
System.out.printf(" LOW (1): %,15d iterations (%5.1f%%)%n",
counts[2], 100.0 * counts[2] / total);
System.out.println("\n⚠️ Results vary by OS and number of CPU cores!");
System.out.println("On multi-core systems, all threads may get equal time.");
System.out.println("Priority mainly matters when threads > cores.");
}
}
Output (varies significantly by platform):
| HIGH (10) | 892,345,678 iterations ( 34.2%) |
| NORM (5) | 878,123,456 iterations ( 33.7%) |
| LOW (1) | 836,789,012 iterations ( 32.1%) |
Invalid Priority Values
java example
public class InvalidPriority {
public static void main(String[] args) {
System.out.println("=== Invalid Priority Handling ===\n");
Thread t = new Thread(() -> {});
// Valid priorities: 1 to 10
try {
t.setPriority(0); // Below MIN_PRIORITY
} catch (IllegalArgumentException e) {
System.out.println("Priority 0: " + e.getMessage());
}
try {
t.setPriority(11); // Above MAX_PRIORITY
} catch (IllegalArgumentException e) {
System.out.println("Priority 11: " + e.getMessage());
}
try {
t.setPriority(-1);
} catch (IllegalArgumentException e) {
System.out.println("Priority -1: " + e.getMessage());
}
// Valid
t.setPriority(7);
System.out.println("\nPriority 7: ✓ (valid)");
System.out.println("Current priority: " + t.getPriority());
}
}Output:
| Priority 0 | illegal priority value: 0 |
| Priority 11 | illegal priority value: 11 |
| Priority -1 | illegal priority value: -1 |
| Priority 7 | ✓ (valid) |
| Current priority | 7 |
Why Thread Priority is Unreliable
java example
public class PriorityUnreliable {
public static void main(String[] args) {
System.out.println("=== Why Priorities Are Unreliable ===\n");
System.out.println("1. PLATFORM DEPENDENT");
System.out.println(" • Windows: Maps 10 Java priorities to 7 OS levels");
System.out.println(" • Linux: Often ignores priorities for regular threads");
System.out.println(" • macOS: Limited priority differentiation");
System.out.println("\n2. MANY CORES = LESS EFFECT");
System.out.println(" • If you have 8 cores and 3 threads,");
System.out.println(" all 3 can run simultaneously regardless of priority");
System.out.println("\n3. NO GUARANTEE OF ORDER");
System.out.println(" • High priority doesn't mean 'runs first'");
System.out.println(" • Just means 'gets more CPU time (probably)'");
System.out.println("\n4. STARVATION RISK");
System.out.println(" • Low-priority threads may never run");
System.out.println(" • Most schedulers prevent this with 'aging'");
System.out.println("\n═══════════════════════════════════════════");
System.out.println("RULE: Never depend on priority for correctness!");
System.out.println("Use synchronization, not priority, for ordering.");
System.out.println("═══════════════════════════════════════════");
}
}Output
=== Why Priorities Are Unreliable === 1. PLATFORM DEPENDENT Windows: maps 10 Java levels to 7 OS levels Linux: may ignore priorities entirely 2. Run 1: High finished first Run 2: Low finished first Run 3: High finished first Conclusion: Never rely on priority for correctness!
Best Practices
- Don't rely on priority for correctness — use synchronization
- Use priorities only for performance hints — e.g., background tasks at MIN_PRIORITY
- Avoid MAX_PRIORITY for user threads — can starve other threads
- Set priority before start() — setting after has less predictable effect
- Test on target platform — behavior varies across OS
Interview Questions
Q1: What is the default priority of a thread?
Answer: 5 (Thread.NORM_PRIORITY). New threads inherit the priority of the thread that creates them.
Q2: What is the range of thread priorities?
Answer: 1 to 10. MIN_PRIORITY = 1, NORM_PRIORITY = 5, MAX_PRIORITY = 10. Setting a value outside this range throws IllegalArgumentException.
Q3: Does a higher priority thread always execute before a lower priority thread?
Answer: No! Priority is just a hint to the scheduler. On multi-core systems, all threads may run simultaneously. Even on single-core, the scheduler may not strictly follow priorities. Never rely on priority for program correctness.
Q4: What happens if you set priority to 0 or 11?
Answer: IllegalArgumentException is thrown. The valid range is strictly 1-10.
Q5: How does priority inheritance work?
Answer: A child thread inherits the priority of the parent thread that created it. If main has priority 5 and creates a thread, that thread starts with priority 5. You can change it with setPriority() after creation.
Q6: Can thread priority cause starvation?
Answer: Yes, theoretically. If high-priority threads always compete for CPU, low-priority threads might rarely execute. However, most modern OS schedulers use "aging" — they gradually increase the priority of starved threads to prevent indefinite starvation.
Q8: Is thread priority guaranteed to affect execution order?
A: No! Thread priority is only a HINT to the OS scheduler. The actual behavior is platform-dependent. Some OS may ignore priorities entirely, some map Java's 10 levels to fewer OS levels. Never rely on priority for program correctness — use proper synchronization and coordination instead.
Q9: What is thread starvation and how is it related to priority?
A: Starvation occurs when a thread is never scheduled because higher-priority threads always get CPU time. With preemptive scheduling, a low-priority thread may never run if high-priority threads are always ready. Solutions: avoid extreme priority differences, use fair locks (ReentrantLock(true)), or redesign to avoid depending on scheduling.
Q10: What are MIN_PRIORITY, NORM_PRIORITY, and MAX_PRIORITY values?
A: Thread.MIN_PRIORITY = 1, Thread.NORM_PRIORITY = 5 (default), Thread.MAX_PRIORITY = 10. Setting priority outside 1-10 range throws IllegalArgumentException. New threads inherit their parent's priority by default.
Q11: How does the JVM map Java thread priorities to OS priorities?
A: It's platform-specific. Windows maps Java's 10 levels to 7 OS priority levels (some Java levels map to the same OS level). Linux with standard scheduling may ignore priorities entirely. Solaris has a 1-to-1 mapping. This is why priority behavior varies across platforms.
Q12: Should you use thread priorities in production code?
A: Generally no. Priority behavior is unreliable and platform-dependent. For controlling execution order, use proper concurrency tools: CountDownLatch, CyclicBarrier, Semaphore, PriorityBlockingQueue, or ExecutorService. These provide deterministic behavior regardless of OS scheduler.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Thread Priority in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, multithreading, thread, priority
Related Java Master Course Topics
Continue learning this concept
MultithreadingCreating Threads in JavaComplete guide to creating threads in Java — extending Thread class, implementing Runnable interface, lambda expressions, comparison of approaches, and when to use each method.MultithreadingDaemon Threads in JavaComplete guide to Daemon Threads in Java — what they are, how they differ from user threads, JVM shutdown behavior, practical use cases like GC and auto-save, and common pitfalls.MultithreadingInter-Thread Communication in JavaComplete guide to Inter-Thread Communication in Java — wait(), notify(), notifyAll(), producer-consumer pattern, and how threads coordinate using object monitors.MultithreadingThread Class in JavaComplete guide to the Thread class in Java — constructors, important methods (sleep, join, yield, interrupt), thread naming, thread groups, and practical usage patterns.MultithreadingThread IntroductionComplete introduction to Multithreading in Java — what threads are, processes vs threads, why multithreading matters, concurrency vs parallelism, and how the JVM manages threads.MultithreadingThread Life Cycle in JavaComplete guide to Thread Life Cycle states in Java — NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED, state transitions, and how to observe thread states programmatically.