CS 4773 Object Oriented Systems: Topic 11

CS 4773 Object Oriented Systems

I have been asked to talk about the following:

implements Runnable
Converting from C to Java
New JOTSA availability
New JOTSA features

implements Runnable just means that the class has a run method and the class can be passed to a Thread constructor.
The Thread executes the run method of this class rather than its own run method.

We had an example of this in class on January 30 with the AnimationApplet class.

Converting from C to Java

A possible exam question might involve taking a C function and writing a corresponding Java method.
Here are some of the differences you would have to worry about:

No struct in Java
No malloc in Java
Java String data type
Dynamic allocation of arrays in Java

Luckily we have not yet covered disk I/O.

JOTSA availability

The new version of Jotsa is available in
/usr/local/courses/java/jotsanewbeta
This is a symbolic link to version 0.817.
Soon the symbolic link jotsabeta will point to this instead of to 0.707 which still uses the old interface.
You should be using this one now.

Some of the new features in 0.817 which were not discussed earlier

The following are in JotsaAnimationApplet

public void JotsaSetBackground(Color c):
which sets the background color.
public JotsaAnimationObject JotsaGetObject(int key);
which returns an object, given its key.
public void JotsaPaintLocal(long ldt);
which is called by the default paint after the background is drawn but before any other objects are drawn.
This allows you to do some customization of paint without overiding it.

The following are in JotsaAnimationObject

public void set_display_linear_path(Color c) public void clear_display_linear_path()
The first will display a line from the start to the end of the path of an object. The second will inhibit this path (the default).
public void reset_color_s(Color C)
which changes the color of the string part of 2-part objects such as rectangles with strings inside.

public void set_draw_centered_strings(String str, Color C);
public void set_draw_centered_strings(String str, int fsize, Color C);
public void set_draw_centered_strings(String str, int fsize, 
                                Color C1, Color C2,
                                int high_start, int high_num);
public void set_draw_centered_strings(String str, String fname, int fstyle, 
                                int fsize, Color C1, Color C2,
                                int high_start, int high_num);

which draw one string per line left justified but with the position giving the center of the group.

public void path_arc_set(int x1, int y1, int rx, int ry,
                         int start_angle, int arc_angle);

public void path_poly_set(int x1[], int y1[], long t[], Color C[]);
public void path_poly_set(int x1[], int y1[], long t[], long td[],
                          Color C[]);

which allow for changing the color of an object as it moves along a polynomial path.

public void reset_strings(String str);
which changes a multi-line string.
public String get_type_string();
which returns a string describing the type of object to be displayed. This is useful for debugging.

Synchronization in Java nad JOTSA.

Java supports synchronization through monitors.

Each class is potentially a monitor.

Methods are protected using the key word synchronized. The following methods are used:

public final void notify()
This wakes up a single thread that is waiting on this object's monitor. This should be executed by a thread that is the owner of the object's monitor. This is normally done by executing a synchronized instance method of the object.
public final notifyAll()
This wakes up all threads that are waiting on this object's monitor.
public final void wait() throws InterruptedException
This waits to be notified by another thread of a change in this object.
- The current thread must own the object's monitor
- The thread releases ownership of this monitor and waits until another thread notifies threads waiting on the object's monitor.
- The thread then waits until it can regain ownership of the monitor.
public final void wait(long timeout) throws InterruptedException
public final void wait(long timeout int nanos) throws InterruptedException

Here is an applet that illustrates the use of these concepts.

Recall the classical producer/consumer or bounded buffer problem.

Several producers and consumers share a buffer for holding items.
producers put items in the buffer
consumer remove items from the buffer
a producer must wait for a free buffer
a consumer must wait until there is something in a buffer
One one process can access the buffers at a time.

Click Here to run this applet.

This applet illustrates both Java synchronization and several features of JOTSA. Here are the idea of the implementation:

Each Producer and Consumer is a thread.
The buffers are in a class which has the monitor.

The basic Producer code looks like this:

package bb_reduced;

public class Producer extends Thread {
   private int nextval = 0;
   private Buffer buffers;

   public Producer(Buffer buffers) {
      this.buffers = buffers;
      start();
   }

   public void run() {
      nextval++;
      buffers.insert_object_in_buffer(nextval);
   }
}

The basic Consumer code is similar:

package bb_reduced;

public class Consumer extends Thread {
   private Buffer buffers;

   public Consumer(Buffer buffers) {
      this.buffers = buffers;
      start();
   }

   public void run() {
      int val;
      val = buffers.remove_object_from_buffer();
   }
}

The Buffer class is essentially this:

package bb_reduced;

public class Buffer {
   private int buffer_size;
   private int[] buffers;
   private int counter;
   private int in;
   private int out;

   public Buffer(int n) {
      buffer_size = n;
      buffers = new int[buffer_size];
      in = 0;
      out = 0;
      counter = 0;
   }

   public synchronized void insert_object_in_buffer(int val) {
      while (counter == buffer_size)
         try {wait();} catch (InterruptedException e) {}
      buffers[in] = val;
      in = (in + 1)%buffer_size;
      counter++;
      notifyAll();
   }

   public synchronized int remove_object_from_buffer() {
      int val;
      while (counter == 0)
         try {wait();} catch (InterruptedException e) {}
      val = buffers[out];
      out = (out + 1)%buffer_size;
      counter--;
      notifyAll();
      return val;
   }
}