Thread Priorities Example in Java

Thread priorities are used by the thread scheduler to decide when each thread should be allowed to run. Higher priority threads get more CPU time than lower priority threads. A higher-priority thread can also preempt a lower-priority one. For instance, when a lower-priority thread is running and a higher-priority thread resumes (from sleeping or waiting on I/O, for example), it will preempt the lower priority thread.

Thread priorities are integers that specify the relative priority of one thread to another. A thread’s priority is used to decide when to switch from one running thread to the next. This is called a context switch. The rules that determine when a context switch takes place are;

1. A thread can voluntarily relinquish control. This is done by explicitly yielding, sleeping, or blocking on pending I/O. In this scenario, all other threads are examined, and the highest-priority thread that is ready to run is given the CPU time.

2. A thread can be preempted by a higher-priority thread. In this case, a lower priority thread that does not yield the processor is simply preempted by a higher-priority thread. This is called preemptive multitasking.

In cases where two threads with the same priority are competing for CPU cycles, both threads are given CPU time slice.

To set a thread’s priority, use the setPriority() method:

Syntax:

final void setPriority(int level)

level specifies the new priority setting for the calling thread. The value of level must be within the range MIN_PRIORITY and MAX_PRIORITY. These values are 1 and 10, respectively. To return a thread to default priority, specify NORM_PRIORITY, which is currently 5. These priorities are defined as final variables within Thread.

final int getPriority()

This method is for finding the priority of the given thread.

Time-slicing

Some Java platforms Support a concept called time-slicing and some do not. Without time-slicing, each thread in a set of equal-priority threads runs to completion (unless the thread leaves the running state and enters the waiting, sleeping or blocked state) before that thread’s peers get a chance to be executed. For more than two threads having equal priority the thread will be selected on round robin scheme. With time-slicing, each thread receives a brief amount of processor time, called a quantum, during which that thread can execute. At the end of the quantum, even if that thread has not been executed fully, the processor is taken away from that thread and given to the next thread of equal priority if such a thread is available. Note that, in this context, ‘the thread’s peers’ refers to the active threads (which are alive). The ‘next thread’ means the next thread that is ready for execution. The scheduler decides which one is the next thread for obtaining processor time.

The scheduler

When many threads are ready for execution, the Java run-time system selects the highest priority runnable thread (fixed priority scheduling). The job of the Java scheduler is to keep a highest priority thread running at all points in time. If time-slicing is available, the scheduler ensures that several threads of equal priority each get executed for a quantum in a round robin fashion. That is, if there is more than one thread with the same priority, each thread gets a turn in round robin order. Lower priority threads are not run as long as there is a runnable higher priority thread. Java scheduling is also preemptive, that is, a higher priority thread preempts the lower priority one. Thus, a thread will run until one of the following conditions occurs:

• A higher priority thread becomes runnable.

• It yields, or its run method exits.

• Its time slice has expired (only on systems that support time-slicing).

                class ThreadPrioritiesExample extends Thread
                    {
                      ThreadPrioritiesExample(String n)
                         {
                        super(n);
                        System.out.println("Thread is:"+getName());
                     }
                            public void run()
                         {
                           try
                           {
                              for(int i=1;i<=3;i++)
                                 {
                                    System.out.println(getName()+":"+i);
                                    sleep(200);
                                 }
                                    }
                                   catch(InterruptedException e)
                                        { 
                                       System.out.println(getName()+" is Interrupted");
                                    }
                            }
                    }
                            class ThreadPriorities 
                              {
                                  public static void main(String args[])
                                    {
                                        ThreadPrioritiesExample t1=new ThreadPrioritiesExample("First Thread");
                                ThreadPrioritiesExample t2=new ThreadPrioritiesExample("Second Thread");
                                ThreadPrioritiesExample t3=new ThreadPrioritiesExample("Third Thread");
                                ThreadPrioritiesExample t4=new ThreadPrioritiesExample("Fourth Thread");
                                t1.setPriority(Thread.MIN_PRIORITY);
                                t2.setPriority(Thread.MAX_PRIORITY);
                                t3.setPriority(Thread.NORM_PRIORITY);
                                t4.setPriority(8);
                                t1.start();
                                t2.start();
                                t3.start();
                                t4.start();
                                }
                             }