Abstract class causes JNI GetByteArrayElements to crash

Question

I'm having a problem with a subclass of an abstract class that is accessing a JNI function. I'm using Java 1.4.2.
I started out with a single class that reads data from a serial port (via a JNI call) and then parses the data. When I test this class, the read/parse works correctly.
Since I have to create multiple parsing protocols, I decided to create an abstract class that contained the reading functionality and a subclass that parses the data. When I did this, the 1st call to GetByteArrayElement never returns (nor do I get a stack dump trace).
I also tried making the super-class non-abstract and over-writing the prase method(s). I got a similar failure.
I can't imagine what the issue might be - why would splitting the original object into two (superclass/subclass) cause such a problem?
I've include relevent snippits of code.
Thanks for the help!
===== JNI Code =====
extern JNIEXPORT jint JNICALL Java_vp_jni_Serial_read (JNIEnv *env,
     jclass class, jint fd, jbyteArray buf, jint cnt, jint offset)
     jboolean     iscopy = JNI_FALSE;
     // FAILS ON CALL; NEVER RETURNS!!!!
     const jbyte *data = GetByteArrayElements (env, buf, &iscopy);
     const uchar     *b;
     int               num,
                    rc;
     b = (uchar *) &data[offset];
     num = cnt;
     do
          rc = read (fd, (char *) b, num);
          if (handleReadException (env, rc) != 0)
               (*env)->ReleaseByteArrayElements (env, buf, (jbyte *) data, 0);
               return rc;
          num -= rc;
          b += rc;
     } while (num > 0);
     (*env)->ReleaseByteArrayElements (env, buf, (jbyte *) data, 0);
     return cnt;
}==== Java Native Calls ====
public class Serial
     public int read (byte[] data, int length, int offset)
          throws IOException
          return read (fd, data, length, offset);
     private static native int read (int fd, byte[] buf, int cnt, int offset)
          throws IOException;
}==== Abstract super-class ====
package vp.parse;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.io.SyncFailedException;
import vp.jni.Serial;
import vp.jni.Exec;
import vp.data.ControlData;
public abstract class Parse extends Thread
     protected static final int     ERROR = -1;
     private static final int     LOC_TIMEOUT = 3000;
     private Serial          link;
     private int               port;
     private boolean          running = false;
     private int               baud = Serial.B9600;
     protected abstract void reset ();
     protected abstract void parse ();
     public Parse (int port, String id, int baud)
          this.port = port;
          this.baud = baud;
          start ();
          synchronized (this)
               try
                    wait (5000);
               } catch (Exception e)
                    System.out.println (id + " Thread failed to synchronize");
          System.out.println ("Done");
     public void run ()
          link = new Serial(port);
          try
               link.open();
               link.setBaud (baud);
               link.setTimeout (LOC_TIMEOUT);
          catch (Exception e )
               link = null;
               return;
          running = true;
          synchronized (this)
               notify ();
          while (running)
               parse ();
     protected int read (byte[] buf, int packetSize, int offset)
          if (offset >= packetSize)
               offset = 0;
          if (offset > 0)
               for (int i=0; i<packetSize - offset; i++)
                    buf[i] = buf[offset+i];
               offset = packetSize - offset;
          try
               int cnt = link.read (buf, packetSize - offset, offset);
               offset = 0;          // all data is good
          // ready to 'close down' executable
          catch (Exception exp)
               running = false;
               return ERROR;
          return offset;
}==== Sub-class to handle parsing ====
package vp.parse;
public class Eis extends Parse
     private static final int     PACKET_SIZE = 3 + 69 + 1;     // hdr, data, csum
     private byte[]          buffer = new byte[PACKET_SIZE];
     private int               offset = 0;
     public Eis (int port)
          super (port, "GR EIS", Serial.B9600);
     protected void reset ()
          offset = 0;
     protected void parse ()
          do
               offset = read (buffer, PACKET_SIZE, offset);
               if (offset == ERROR)
                    offset = 0;
                    return;
               // parse code here
          } while (parse failed);
     public static void main (String[] argv)
          Eis e = new Eis (3);
          try { Thread.sleep (10000); } catch (Exception x) {}
}

Answer 1

The issue was the following:
I had declared a buffer in the sub-class;
private byte[] buffer = new byte[PACKET_SIZE];
And the assumption would be that by the time it got used, it would be initialized. But that's not the case. Why?
The sub-class called the super class constructor. At this point in time, buffer[] is not valid.
The super class constructor spawns the child thread and waits for the spawned thread to finish initialization.
The spawned thread creates the serial port, informs the constructor it's 'done' and starts to parse incoming data.
The parse() code is the sub-class passes the uninitialized buffer to the JNI code and GetByteArrayElements crashes because id doesn't like a null pointer.
Since the parent thread doesn't regain control to finish the construction, buffer[] never gets initialized.
So much for synchronized thread spawning in a constructor...