Win32 only: a program with multiple threads crashes after running for a while

Steps to reproduce:
Compile and run the attached code
// Note: this program will crash after no more than 20 minutes
// the program should run for no less than one hour before any problems are
// encountered.

/* stress testing
 reqgen is a subtype of Thread which generates
 request to allocate small objects ( 8 ~ 32k), short live time ( 5 ~ 10 ms)
 reqdisp is a subtype of Thread which dispatches request
 and create a livethread object to allocate the requested memory
 and simulate its life time.
*/
import java.io.*;

class bufreq {
  int bufsz; // memory size
  int life; // live time of the object
  bufreq next;
  
  bufreq(int bufsz, int t)
       {
this.bufsz = bufsz;
this.life = t;
this.next = null;
       }

  public void setnext(bufreq b)
  {
    next = b;
  }

  public bufreq getnext()
  {
    return next;
  }

  public int getsize()
  {
    return bufsz;
  }

  public int livetime()
  {
    return life;
  }
}

class queue {
  bufreq head;
  bufreq tail;

  queue()
  {
    head = null;
    tail = null;
  }
  
  public synchronized void append(bufreq b)
  {
    if ( tail == null ) // head must be null too
      {
head = tail = b;
return;
      }
    tail.setnext(b);
    tail = b;
  }

  public synchronized bufreq remove()
  {
    if ( head == null ) return null;
    bufreq buf = head;
    head = head.getnext();
    if ( head == null ) // only one element in the queue
      {
tail = head = null;
      }
    return buf;
  }
}
    
class reqgen extends Thread {
  queue req;
  int maxsz;
  int minsz;
  int maxlive;
  int minlive;
  int amda;
// static int gen_ome = 0;
  
  reqgen(queue req, int t)
  {
    this.req = req;
    amda = t;
  }

  public void setsize(int s1, int s2)
  {
       maxsz = s2;
       minsz = s1;
  }

  public void setlive(int t1, int t2)
  {
    maxlive = t2;
    minlive = t1;
  }
  
  public void run()
  {
    bufreq buf;
    int sz;
    int t;
    
    sz = minsz;
    t = minlive;
    while ( true )
      //while ( sz < 1024*32)
      {
try
          {
buf = new bufreq(sz, t);
          }
          catch ( OutOfMemoryError e )
{
             memAgent.oom();
             memAgent.GC();
continue;
}
sz = ( 2*sz);
if ( sz > maxsz)
             sz = minsz;


t = ( 2 * t );
if ( t > maxlive)
             t = minlive;

req.append(buf);
          
          try
          {
sleep(amda);
          }
          catch(InterruptedException e) {}
      }
  }

  public bufreq nextreq()
  {
    return req.remove();
  }

}

// buffer request dispatcher and allocator
class reqdisp extends Thread {
  queue req;
// static long disp_ome = 0;
  
  reqdisp(queue q )
  {
    req = q;
  }
  
  public void run()
  {
    bufreq r;
    livethread lt;
    
    while ( true )
       {
r = req.remove();
if ( r != null )
{
try {
lt = new livethread(r);
} catch (OutOfMemoryError e )
{
               memAgent.oom();
               memAgent.GC();
continue;
}
lt.start();
}

// simulate the interarrival time
          try
          {
sleep((int)(Math.random() * 20));
          }
          catch (InterruptedException e) {}
       }
   }

}

class livethread extends Thread {
  bufreq req;
  // counter of outmemoryexceptions occurred
 // static long countome = 0;

  
  livethread(bufreq r)
  {
    req = r;
  }

  public void run()
  {
    int buf[];
    
    try
    {
       System.out.println("allocated " + req.getsize());
       buf = new int[req.getsize()];
    }
    catch ( OutOfMemoryError e )
    {
       memAgent.oom();
       memAgent.GC();
    }

    // simulate the life time of the created object
    // if live time is 0, that means forever
    if ( req.livetime() == 0 )
    {
       while ( true )
       {
          try
          {
             sleep(10000);
          }
          catch (InterruptedException e) {}
       }
    }
    else
    {
       try
       {
          sleep(req.livetime());
       }
       catch (InterruptedException e) {}

    }
    // live object is outdated, should be GC'ed
  }
}
    
// small objects ( 8 ~ 32k), short live time ( 5 ~ 10 ms)
class gctest04 {
  public static void main(String args[] )
  {
    memAgent memmaster = new memAgent(true);

    queue requestque = new queue();

    reqgen gen = new reqgen(requestque, 5);

    gen.setsize(8, 32*1024);

    gen.setlive(5, 10);

 
    reqdisp disp = new reqdisp(requestque);
    
    gen.start();

    disp.start();

  }
}

The description field as copied from bug report 1258275 follows:

The Thread.stop() method is flawed in JDK 1.0.2 for Windows 95. If a
thread calls stop() on itself, that thread is hung without being
properly cleaned up, and when the application (not applet) attempts to
exit, the application hangs forever (probably waiting for the hung
thread to terminate or something).

It does work when run using jdb however.

Here is the test program:

class StopSelf implements Runnable {

public
void run() {
Thread.currentThread().stop();
System.out.println("After stop?");
}

static public
void main(String vSt[]) {
new Thread(new StopSelf(), "StopSelf").start();
}
}