Multithreading and passing values

 
p.start();
c.start();
c.sleep( 1000 );

// import packages
import java.io.*;
import javax.swing.*;
import java.util.*;
import java.text.*;

public class multithread {
   public static void main( String args[] )
   {
      HoldIntegerSynchronized h = new HoldIntegerSynchronized();
	  // get values
      String intString = JOptionPane.showInputDialog("Enter number of integers to be used in calculation:");
      h.setIntegers(Integer.parseInt(intString));
      String procString = JOptionPane.showInputDialog("Enter number of processors to be used in calculation:");
      h.setProcessors(Integer.parseInt(procString));
      ProduceInteger p = new ProduceInteger( h );
      ConsumeInteger c = new ConsumeInteger( h );

      p.start();
      c.start();
   }
}
class ProduceInteger extends Thread {
   private HoldIntegerSynchronized pHold;

   public ProduceInteger( HoldIntegerSynchronized h )
   {
      super( "ProduceInteger" );
      pHold = h;
   }

   public void run()
   {
    // get start time
      Date start = new Date();
      int processors = pHold.getProccesors(); // number of processors to be used

      pHold.setStart();
      do {
         // sleep thread
         try {
            Thread.sleep( (int) ( Math.random() * 3000 ) );
         }
         catch( InterruptedException e ) {
            System.err.println( e.toString() );
         }

         pHold.setSharedInt(1 + (int) (Math.random() * 1000));
      } while (pHold.getStatus() == 1); // when the set number of integers are reached this returns 1
   }
}
class ConsumeInteger extends Thread {
   private HoldIntegerSynchronized cHold;

   public ConsumeInteger( HoldIntegerSynchronized h )
   {
      super( "ConsumeInteger" );
      cHold = h;
   }

   public void run()
   {
      int val, sum = 0, currentInt = 1, x[];
      int numInts = cHold.getIntegers(); // number of integers to be used
      x = new int[numInts];
      do {
         // sleep thread
         try {
            Thread.sleep( (int) ( Math.random() * 3000 ) );
         }
         catch( InterruptedException e ) {
            System.err.println( e.toString() );
         }

         val = cHold.getSharedInt();
		 // calculate using returned integer
        sum += val;
        x[currentInt - 1] = sum;
         currentInt ++;
      } while ( currentInt != numInts + 1);// return set number of integers then stop
      cHold.setEnd();
      cHold.setStatus();
      Arrays.sort(x);

      // create a save dialog box
      JFileChooser fileChooser = new JFileChooser();
      fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
      int result = fileChooser.showSaveDialog(null);
      if (result == JFileChooser.CANCEL_OPTION) {
        System.exit(0);
      } else {
        File filename = fileChooser.getSelectedFile();
        if (filename == null || filename.getName().equals("")) {
          JOptionPane.showMessageDialog(null, "Ivalid File Name","Invalid File Name", JOptionPane.ERROR_MESSAGE);
        } else {
          try {
            // output the data
            DataOutputStream output;
            output = new DataOutputStream( new FileOutputStream(filename));
            for (int i = 0; i < x.length; i++) {
                output.writeBytes(String.valueOf(x[i]) + "\n");
            }
            output.writeBytes("\nTime taken: " + String.valueOf(cHold.getTaken()) + " milliseconds");
            output.flush();
            output.close();
            JOptionPane.showMessageDialog(null, "File written.");
          } catch (IOException e) {
            JOptionPane.showMessageDialog(null, e);
          }
        }
      }
      System.exit(0);
   }
}
class HoldIntegerSynchronized {
   private int sharedInt = -1, mayContinue = 1, processors = 1, integers = 0;
   private boolean writeable = true;  // condition variable
   private Date end, start;
   private long timeTaken;

   public synchronized void setSharedInt(int val)
   {
      while ( !writeable ) {  // not the producer's turn
         try {
            wait();  
         }
         catch ( InterruptedException e ) {
            e.printStackTrace();
         }
      }
      sharedInt = val;

      writeable = false;
      notify();  // tell a waiting thread to become ready
   }

   public synchronized int getSharedInt()
   {
      while ( writeable ) {   // not the consumer's turn
         try {
            wait();
         }
         catch ( InterruptedException e ) {
            e.printStackTrace();
         }
      }

      writeable = true;
      notify();  // tell a waiting thread to become ready
      return sharedInt;
   }
   public int getStatus() {
   // return whether current position in integerCount is valid
     return mayContinue;
   }
   public void setStatus() {
   // set end of integers required has been reached
     mayContinue = 0;
   }
   public void setStart() {
    start = new Date();
   }
  public void setEnd() {
    end = new Date();
  }
  public long getTaken() {
    timeTaken = end.getTime() - start.getTime();
    return timeTaken;
   }
  public void setProcessors(int i) {
    processors = i;
  }
  public int getProccesors() {
   return processors;
  }
  public void setIntegers(int i) {
    integers = i;
  }
  public int getIntegers() {
   return integers;
  }
}