Teachnique
      CourseRoadmaps
      Login

      OverviewHistoryFeaturesJava 8 - New Featuresvs C++Virtual Machine(JVM)JDK vs JRE vs JVMHello World ProgramEnvironment SetupBasic SyntaxVariable TypesData TypesType CastingUnicode SystemBasic OperatorsCommentsStreamsNew Date-Time API

      Loop ControlDecision Makingif-else Statementswitch statementfor loopfor each Loopwhile Loopdo...while Loopbreak Statementcontinue Statement

      OOPs (Object-Oriented Programming) ConceptsObject and ClassesClass AttributesClass MethodsMethodsVariable ScopesConstructorsAccess ModifiersInheritanceAggregationPolymorphismOverridingMethod OverloadingDynamic BindingStatic BindingInstance Initializer BlockAbstractionEncapsulationInterfacesPackagesInner classesStatic ClassesAnonymous ClassesSingleton ClassWrapper ClassesEnum Class

      Number ClassBoolean classCharacter ClassArraysMath Class

      File ClassCreating FilesWrite To FilesReading FileDelete FilesDirectory OperationsFiles and I/O

      ExceptionsTry Catch BlockTry with ResourcesMultiple Catch BlocksNested Try BlockFinally BlockThrows and Throw | Throw an ExceptionException PropagationBuilt-in ExceptionsCustom Exception

      MultithreadingThread Life CycleCreating a ThreadStarting a ThreadJoining ThreadsNaming a Thread with ExamplesScheduling Threads with ExamplesThread PoolsMain ThreadThread PriorityDaemon ThreadThreadGroup ClassJVM Shutdown Hook

      Thread SynchronizationBlock SynchronizationStatic SynchronizationInter Thread CommunicationThread DeadlockInterrupting ThreadThread ControlReentrant Monitor

      NetworkingSocket ProgrammingURL ProcessingURL ClassURLConnection ClassHttpURLConnection ClassSocket Class with ExamplesGenerics

      Collections FrameworkCollection Interface

      List InterfaceArrayList Class

      Queue InterfaceArrayDeque Class

      Map InterfaceSortedMap Interface

      Set InterfaceSortedSet Interface

      Data Structures Enumeration Interface BitSet Class

      How to Use Iterator?How to Use Comparator?How to Use Comparable?

      RecursionRegular ExpressionsSerializationString ClassJava Arrays - Class

      Feedback

      Submit request if you have any questions.

      Course
      Thread Priority

      Java Tutorial

      This Java tutorial is tailored for newcomers, offering a journey from basic principles to complex Java programming techniques. Completing this tutorial equips you with a solid understanding of Java, preparing you for advanced learning. You'll emerge ready to tackle the challenges of becoming a top-tier software engineer, with the skills to innovate and excel in the vast world of software development.

      Thread Priority

      Priority of a Thread in Java

      Every Java thread has a priority that helps the operating system determine the order in which threads are scheduled. You can get and set the priority of a Thread. Thread class provides methods and constants for working with the priorities of a Thread.
      Threads with higher priority are more important to a program and should be allocated processor time before lower-priority threads. However, thread priorities cannot guarantee the order in which threads execute and are very much platform dependent.

      Built-in Property Constants of Thread Class

      Java thread priorities are in the range between MIN_PRIORITY (a constant of 1) and MAX_PRIORITY (a constant of 10). By default, every thread is given priority NORM_PRIORITY (a constant of 5).
      • MIN_PRIORITY: Specifies the minimum priority that a thread can have.
      • NORM_PRIORITY: Specifies the default priority that a thread is assigned.
      • MAX_PRIORITY: Specifies the maximum priority that a thread can have.

      Thread Priority Setter and Getter Methods

      • Thread.getPriority() Method: This method is used to get the priority of a thread.
      • Thread.setPriority() Method: This method is used to set the priority of a thread, it accepts the priority value and updates an existing priority with the given priority.

      Example of Thread Priority in Java

      In this example, we're showing a simple one thread program where we're not declaring any thread and checking the thread name and priority in the program execution.
      package com.tutorialspoint;
      public class TestThread {
         public void printName() {
            System.out.println("Thread Name: " + Thread.currentThread().getName());
            System.out.println("Thread Priority: " +Thread.currentThread().getPriority());
         }	
         public static void main(String args[]) {
            TestThread thread = new TestThread();
            thread.printName();	   
         }
      }

      Output

      Thread Name: main
      Thread Priority: 5

      More Examples of Thread Priority

      Example 1

      In this example, we've created a ThreadDemo class which extends Thread class. We've created three threads. Each thread is assigned a priority. In run() method, we're printing the priorities and in output, it is reflecting in threads execution.
      package com.tutorialspoint;
      class ThreadDemo extends Thread {
         ThreadDemo( ) {
         }
         public void run() {
            System.out.println("Thread Name: " + Thread.currentThread().getName() 
               + ", Thread Priority: " +Thread.currentThread().getPriority());
            for(int i = 4; i > 0; i--) {
               System.out.println("Thread: " + Thread.currentThread().getName() + ", " + i); 
            }
            try {
               Thread.sleep(50);
            } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
            }
         }
         public void start () {
            super.start();
         }
      }
      public class TestThread {
         public static void main(String args[]) {
            ThreadDemo thread1 = new ThreadDemo();
            ThreadDemo thread2 = new ThreadDemo();
            ThreadDemo thread3 = new ThreadDemo();
            thread1.setPriority(Thread.MAX_PRIORITY);
            thread2.setPriority(Thread.MIN_PRIORITY);
            thread3.setPriority(Thread.NORM_PRIORITY);
            thread1.start();	  
            thread2.start();
            thread3.start();
         }
      }

      Output

      Thread Name: Thread-2, Thread Priority: 5
      Thread Name: Thread-1, Thread Priority: 1
      Thread Name: Thread-0, Thread Priority: 10
      Thread: Thread-1, 4
      Thread: Thread-2, 4
      Thread: Thread-1, 3
      Thread: Thread-0, 4
      Thread: Thread-1, 2
      Thread: Thread-2, 3
      Thread: Thread-0, 3
      Thread: Thread-0, 2
      Thread: Thread-0, 1
      Thread: Thread-2, 2
      Thread: Thread-2, 1
      Thread: Thread-1, 1

      Example 2

      In this example, we've created a ThreadDemo class which extends Thread class. We've created three threads. As we're not setting any priority, each thread has a normal priority. In run() method, we're printing the priorities and in output, threads are executing in any order.
      package com.tutorialspoint;
      class ThreadDemo extends Thread {
         ThreadDemo( ) {
         }
         public void run() {
            System.out.println("Thread Name: " + Thread.currentThread().getName() 
               + ", Thread Priority: " +Thread.currentThread().getPriority());
            for(int i = 4; i > 0; i--) {
               System.out.println("Thread: " + Thread.currentThread().getName() + ", " + i); 
            }
            try {
               Thread.sleep(50);
            } catch (InterruptedException e) {
               
               // TODO Auto-generated catch block
               e.printStackTrace();
            }
         }
         public void start () {
            super.start();
         }
      }
      public class TestThread {
         public static void main(String args[]) {
            ThreadDemo thread1 = new ThreadDemo();
            ThreadDemo thread2 = new ThreadDemo();
            ThreadDemo thread3 = new ThreadDemo();
            thread1.start();	  
            thread2.start();
            thread3.start();
         }
      }

      Output

      Thread Name: Thread-1, Thread Priority: 5
      Thread Name: Thread-2, Thread Priority: 5
      Thread Name: Thread-0, Thread Priority: 5
      Thread: Thread-2, 4
      Thread: Thread-1, 4
      Thread: Thread-1, 3
      Thread: Thread-2, 3
      Thread: Thread-0, 4
      Thread: Thread-2, 2
      Thread: Thread-1, 2
      Thread: Thread-2, 1
      Thread: Thread-0, 3
      Thread: Thread-1, 1
      Thread: Thread-0, 2
      Thread: Thread-0, 1