Java 1.2 How-To/JavaHowTo.iso/javafile/ch04/WaitDemo.java

Java Source | 1998-12-14 | 6.1 KB | 330 lines

import java.awt.*;
import java.applet.Applet;

/*
 * a class for handling first in, first out data structure
 */
class FIFO {

/*
 * the maximum depth of the FIFO
 */
final int MaxDepth = 200;

/*
 * the real depth of this FIFO
 */
int depth;

/*
 * write and read indexes into the data array
 */
int writeIndex;
int readIndex;

/*
 * the number of data items currently in the FIFO
 */
int nItems;

/*
 * the data proper
 */
int data[] = new int[MaxDepth];

/*
 * width and height of the FIFO graphical display
 */
int width;
int height;

/*
 * x and y position of the upper-left corner of the FIFO
 * graphical display
 */
int xpos;
int ypos;

/**
 * the constructor
 * @param d - depth of the FIFO
 */
public FIFO (int d) {

       depth = d;
       writeIndex = 0;
       readIndex = 0;
       nItems = 0;

       width = depth + 4;
       height = 50;
       xpos = 50;
       ypos = 75;
}

/**
 * write one integer value into the FIFO
 * invoke wait() if the FIFO is full
 * @param value - the value to write
 */
synchronized void write (int value) {

       if (nItems >= depth) {
              try {
                     wait ();
              } catch (InterruptedException e) {
              }
       }

       data[writeIndex] = value;
       writeIndex += 1;
       writeIndex %= depth;
       nItems += 1;
       notify ();
}

/**
 * read one integer value from the FIFO
 * invoke wait() if the FIFO is empty
 */
synchronized int read () {

       if (nItems < 1) {
              try {
                     wait ();
              } catch (InterruptedException e) {
              }
       }

       int value = data[readIndex];
       readIndex += 1;
       readIndex %= depth;
       nItems -= 1;
       notify ();

       return value;
}

/**
 * returns true if the FIFO is empty
 */
synchronized boolean empty () {

       return nItems > 0 ? false : true;
}

/**
 * returns true if the FIFO is half full
 */
synchronized boolean halfFull () {

       return nItems > (depth >> 1) ? true : false;
}

/**
 * returns true if the FIFO is full
 */
synchronized boolean full () {

       return nItems >= (depth) ? true : false;
}

/**
 * draws the FIFO graphical display
 * @param g - destination graphics context
 */
synchronized void paint (Graphics g) {

       int x, y, w, h;

       g.setColor (Color.white);
       g.fillRect (xpos, ypos, width, height);
       g.setColor (Color.black);
       g.drawRect (xpos, ypos, width, height);

       x = writeIndex + xpos + 2;
       y = ypos - 22;
       g.drawLine (x, y, x, y + 20);
       g.drawString ("Write index "+writeIndex, x+2, y+10);

       x = readIndex + xpos + 2;
       y = ypos + height + 22;
       g.drawLine (x, y-20, x, y);
       g.drawString ("Read index "+readIndex, x+2, y);

       if (nItems < 1) return;

       if (nItems > (depth>>1)) g.setColor (Color.red);
       else g.setColor (Color.green);

       x = xpos + 2 + readIndex;
       y = ypos + 2;
       if (writeIndex > readIndex) w = nItems;
       else w = width - readIndex - 4;
       h = height - 4;
       g.fillRect (x, y, w, h);

       if (writeIndex > readIndex) return;

       x = xpos + 2;
       w = writeIndex;
       g.fillRect (x, y, w, h);
}
}

/*
 * a class that generates data continuously
 */
class Source extends Thread {

/*
 * the FIFO to write into
 */
FIFO fifo;
int value;

/**
 * constructor
 * saves the FIFO instance and starts the thread
 * @param f - an instance of FIFO
 */
public Source (FIFO f) {

       fifo = f;
       value = 0;

       start ();
}

/*
 * the thread that writes one word every 50ms on average
 */
public void run () {

       while (true) {
              if (fifo.full() == false)
                     fifo.write (value++);

              try {
                     Thread.sleep ((int) (100 * Math.random ()));
              } catch (InterruptedException e) {
              }
       }
}
}

/*
 * a class that reads data from the FIFO
 */
class Sink extends Thread {

/*
 * the FIFO to read from
 */
FIFO fifo;
int value;

/**
 * constructor
 * saves the FIFO instance and starts the thread
 * @param f - an instance of FIFO
 */
public Sink (FIFO f) {

       fifo = f;

       start ();
}

/*
 * the thread that tries to read one word every 50ms on average
 */
public void run () {

       while (true) {
              value = fifo.read ();

              try {
                     Thread.sleep ((int) (100 * Math.random ()));
              } catch (InterruptedException e) {
              }
       }
}
}

/*
 * the applet/application class
 */
public class WaitDemo extends Applet implements Runnable {

Source source;
Sink sink;
FIFO fifo;
Thread thread;

/*
 * called when the applet is loaded
 * create instances of FIFO, Source, Sink, and Thread
 */
public void init () {

       fifo = new FIFO (200);
       source = new Source (fifo);
       sink = new Sink (fifo);

       thread = new Thread (this);
}

/*
 * start the graphics update thread
 */
public void start () {

       thread.start ();
}


/*
 * the graphics update thread
 * call repaint every 100ms
 */
public void run () {

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

/**
 * called from update() in response to repaint()
 * @param g - destination graphics context
 */
public void paint (Graphics g) {

       fifo.paint (g);
}

/**
 * main() is the application entry point
 * main() is unused when run as an applet
 * create a window frame and add the applet inside
 * @param args[] - command-line arguments
 */
public static void main (String args[]) {

       Frame f = new Frame ("FIFO Demo");

       WaitDemo waitDemo = new WaitDemo ();
       f.add ("Center", waitDemo);
       f.setSize (400, 200);
       f.show ();

       waitDemo.init ();
       waitDemo.start ();
}
}