CS 4773 Object Oriented Systems
Threads and Synchronization

Thread Priorities and Scheduling

• The priority is an integer between MIN_PRIORITY and MAX_PRIORITY.
• You can set (maybe) a thread's priority with set_priority().
• You can get a thread's priority with get_priority().

The scheduling algorithm is not specified by Java and is left up to the implementation.

• The only thing that is guaranteed, is that the highest priority runnable thread will be able to get some CPU time.
• On some systems low priority threads may be starved out while on others they will get some of the CPU time.
• On some systems when there are two equally highest priority threads one can starve out the other while on other systems they will each get part of the CPU time.

Importance of Understanding Scheduling

• MD runs infrequently for a short time with a low priority. It writes to a shared memory buffer as follows:
  lock buffer
  write to buffer
  unlock buffer
  
• IB runs frequently for a short time at a high priority. It removes items from the shared buffer as follows:
  lock buffer
  read from buffer
  unlock buffer
  
• CT runs at a medium priority, is long running and does not used the shared buffer.
• WD runs at the highest priority infrequently and checks to see if any I/O has been done. If not it performs a system reset.

Suppose that MD has the shared buffer locked and IB preempts it and is blocked.
Before MD can get in, CT gets the CPU and prevents MD from running, thus blocking IB.
The effect is that a medium priority process, CT has blocked a high priority process, MD.
This is called priority inversion.
Now WD gets the CPU and sees that no I/O has occurred for a long time (which is an error condition because IB should be doing I/O frequently).
WD thinks an error has occurred and resets the system.

Remember the Pathfinder Mars mission? This is exactly what was causing the system resets on the Pathfinder.

MD was a meteorological data gathering task.
IB was the information bus task.
CT was a communication task.
WD was the watchdog timer

The problem was fixed by changing the system (from earth) to use what is called priority inheritance.
When a higher priority process blocks because a lower priority process holds a lock, the process holding the lock inherits the priority of the other process.

This may hold the record for longest distance remote programming.

You can read more about this here.

Synchronization in Java

Each instance of a class has its own monitor with one (anonymous) condition variable.

Recall that a monitor is a compiler construct which allows only one process to be active (own the monitor) within the protected methods of the monitor.

In Java, by default, no methods of the object are protected. You can protect methods by using the synchronized key word.

How to own a monitor of an object

• Execute code in a synchronized method of the object. This is the usual way.
• Execute code which is contained in a synchronized block as follows:

        synchronized (obj) {
           code goes here
        }

• public static native void sleep(long millis) throws InterruptedException
  This method causes the calling thread to sleep for the given number of milliseconds (more or less, according to the specification) or until the thread's interrupt method is called.
• public final void join() throws InterruptedException
  Waits until the given thread dies or the current thread is interrupted.
• public final void wait() throws InterruptedException
  Waits to be notified by another thread or interrupted.
  The current thread must own the object's monitor, that is be executing from inside a synchronized method.
  The thread releases ownership of the monitor.
  When it is notified, it must regain ownership of the monitor before it continues executing.
• public final native void notify()
  Wakes up a single thread that is waiting on this object's monitor.
  The current thread must own the object's monitor, that is be executing from inside a synchronized method.
  The current thread does not lose ownership of the monitor.
• public final native void notifyAll()
  Wakes up all threads that are waiting on this object's monitor.
  The current thread must own the object's monitor, that is be executing from inside a synchronized method.
  The current thread does not lose ownership of the monitor.
• public void interrupt()
  Interrupts a thread.
  This sets a flag in the thread which can be tested.
  If the thread was block on sleep, wait or join, an InterruptedException is thrown by that thread.
  Note: this was not implemented in Java 1.0.

This thread sleeps for about 100 milliseconds:

   try {
      sleep(100)
   }
   catch (InterruptedException e) {}

   try {
      Thread.sleep(100);
   }
   catch (InterruptedException e) {}

   try { 
      T.join();
   }
   catch (InterruptedException e) {} 

   public synchronized void test1() {
      while (count == 0)
         try {
            wait();
         catch (InterruptedException e) {}
      ...
   }

   public synchronized void test2() {
      ...
      count++;
      if (count == 1)
         notify();
   }

A Bounded Buffer Example

The bounded buffer might be implemented as a circular queue using and array, buffer with integer variables putIm, takeOut, and count:

putIn: index of the entry to next receive an item (next empty entry)
takeOut: index of the entry that will be tken out next (oldest entry)
count: number of filled entries in the buffer

The following code does not work even if there are no exceptions:

Producer code:

   public synchronized void deposit(double value) { 
      if (count == numSlots)
         try {
            wait(); 
         } catch (InterruptedException e) {}
      buffer[putIn] = value;
      putIn = (putIn + 1) % numSlots;
      count++;
      if (count == 1)
          notify();
   }

Consumer code:

   public synchronized double fetch() {
      double value;
      if (count == 0)
         try {
            wait();
         } catch (InterruptedException e) {}
      value = buffer[takeOut];
      takeOut = (takeOut + 1) % numSlots;
      count--;
      if (count == numSlots-1) 
         notify();
      return value;
   }
}

Suppose the buffer is empty and there are three threads in the ready queue:

C2 P C1

One way to fix this problem is to put the wait in a while loop:

   public synchronized void deposit(double value) {  
      while (count == numSlots) 
         try {
            wait();  
         } catch (InterruptedException e) {} 
      buffer[putIn] = value; 
      putIn = (putIn + 1) % numSlots; 
      count++;
      if (count == 1)
          notify();
   } 
  
   public synchronized double fetch() { 
      double value; 
      while (count == 0)
         try { 
            wait(); 
         } catch (InterruptedException e) {} 
      value = buffer[takeOut]; 
      takeOut = (takeOut + 1) % numSlots;
      count--;
      if (count == numSlots-1) 
         notify();
      return value; 
   }  
} 

P2 P1 C2 C1

We can fix this problem by waking up all waiting processes.

 
   public synchronized void deposit(double value) {   
      while (count == numSlots)  
         try { 
            wait();   
         } catch (InterruptedException e) {}  
      buffer[putIn] = value;  
      putIn = (putIn + 1) % numSlots;  
      count++; 
      if (count == 1) 
          notifyAll(); 
   }  
  
   public synchronized double fetch() {  
      double value;  
      while (count == 0) 
         try {  
            wait();  
         } catch (InterruptedException e) {}  
      value = buffer[takeOut]; 
      takeOut = (takeOut + 1) % numSlots; 
      count--; 
      if (count == numSlots-1)  
         notifyAll(); 
      return value;  
   }   
}  

CRC Cards

A CRC card is a 3 by 5 index card for a given class. The first line contains the name of the class.
Next is a list of responsibilities of the class, that is the public methods of that class. Finally, the collaborations are listed. These are the classes that this class needs to know about in order to implement its public methods.

Design steps:

• List the classes
• List the responsibilities for each class
• List the collaborations for each class
• Simulate a part of the program
• Iterate the design

Chutes and Ladders Example

CRC Cards Designed in Class, Wednesday, February 24, 2000

Next topic: Vectors and Synchronization