Thread Scheduling in Java

Features :


  • The JVM schedules using a preemptive , priority based scheduling algorithm.
  • All Java threads have a priority and the thread with he highest priority is scheduled to run by the JVM.
  • In case two threads have the same priority a FIFO ordering is followed.

A different thread is invoked to run in case one of the following events occur:

1.The currently running thread exits the Runnable state ie either blocks or terminates.
2. A thread with a higher priority than the thread currently running enters the Runnable state. The lower priority thread is preempted and the higher priority thread is scheduled to run.

Time Slicing is dependent on the implementation.

A thread can voluntarily yield control through the yield() method. Whenever a thread yields control of the CPU another thread of the same priority is scheduled to run. A thread voluntarily yielding control of the CPU is called Cooperative Multitasking.

Thread Priorities
JVM selects to run a Runnable thread with the highest priority.


  • All Java threads have a priority in the range 1-10.
  • Top priority is 10, lowest priority is 1.Normal
  • priority ie. priority by default is 5.
  • Thread.MIN_PRIORITY - minimum thread priority
  • Thread.MAX_PRIORITY - maximum thread priority
  • Thread.NORM_PRIORITY - maximum thread priority

Whenever a new Java thread is created it has the same priority as the thread which created it.
Thread priority can be changed by the setpriority() method.

Java Based Round-Robin Scheduler
(An example)
public class Scheduler extends Thread

{
public Scheduler(){
timeSlice = DEFAULT_TIME_SLICE;
queue = new Circularlist();
}

public Scheduler(int quantum){
timeSlice = quantum;
queue = new Circularlist();
}

public addThread(Thread t) {
t.setPriority(2);
queue.additem(t);
}

private void schedulerSleep() {
try{
Thread.sleep(timeSlice );
} catch (InterruptedException e){};
}
public void run(){
Thread current;

This.setpriority(6);
While (true) {
// get the next thread
current = (Thread)qeue.getnext();
if ( (current != null) && (current.isAlive()) ){
current.setPriority(4);
schedulerSleep();
current.setPriority(2)
}
}
}

private CircularList queue;
private int timeSlice;
private static final int DEFAULT_TIME_SLICE = 1000;
}
public class TesScheduler
{
public static void main()String args[]) {
Thread.currentThread().setpriority(Thread.Max_Priority);
Schedular CPUSchedular = new Scheduler ();
CPUSchedular.start()
TestThread t1 = new TestThread("Thread 1");
t1.start()
CpuSchedular.addThread(t1);
TestThread t2 = new TestThread("Thread 2");
t2.start()
CpuSchedular.addThread(t2);
TestThread t3 = new TestThread("Thread 1");
t3.start()
CpuSchedular.addThread(t3);
}
}



<<Previous <<   || Index ||   >>Next >>

1 comment:

  1. Can you please complete a explain a little bit this example. Sounds very interesting.

    ReplyDelete