Patch: thread bug fix

[Tom Tromey]

I'm checking in this fix, which fixes a bug in natThread.cc.  The code
in question failed to unlock a mutex corresponding to a condition
variable when _Jv_CondWait threw an exception.  (This is only an issue
for very low-level code.)

1999-08-19  Tom Tromey  <tromey@cygnus.com>

	* java/lang/natThread.cc (class locker): New class.
	(join): Use a locker around _Jv_CondWait.
	(sleep): Likewise.

Tom

Index: java/lang/natThread.cc
===================================================================
RCS file: /cvs/cvsfiles/devo/libjava/java/lang/natThread.cc,v
retrieving revision 1.17.2.4
diff -u -r1.17.2.4 natThread.cc
--- natThread.cc	1999/08/18 19:52:24	1.17.2.4
+++ natThread.cc	1999/08/19 22:43:23
@@ -49,6 +49,26 @@
   struct natThread *next;
 };
 
+// We use this for its side effects: it lets us lock a mutex directly
+// and not lose if an exception is thrown.
+class locker
+{
+private:
+  _Jv_Mutex_t *mutex;
+
+public:
+  locker (_Jv_Mutex_t *m)
+    : mutex (m)
+  {
+    _Jv_MutexLock (mutex);
+  }
+
+  ~locker ()
+  {
+    _Jv_MutexUnlock (mutex);
+  }
+};
+
 // This is called from the constructor to initialize the native side
 // of the Thread.
 void
@@ -153,12 +173,14 @@
 
 
   // Now wait for: (1) an interrupt, (2) the thread to exit, or (3)
-  // the timeout to occur.
-  _Jv_MutexLock (&curr_nt->interrupt_mutex);
-  _Jv_CondWait (&curr_nt->interrupt_cond,
+  // the timeout to occur.  Use a `locker' object because _Jv_CondWait
+  // can throw an exception.
+  {
+    locker l (&curr_nt->interrupt_mutex);
+    _Jv_CondWait (&curr_nt->interrupt_cond,
 		  &curr_nt->interrupt_mutex,
 		  millis, nanos);
-  _Jv_MutexUnlock (&curr_nt->interrupt_mutex);
+  }
 
   // Now the join has completed, one way or another.  Update the
   // joiners list to account for this.
@@ -224,10 +246,12 @@
   // We use a condition variable to implement sleeping so that an
   // interrupt can wake us up.
   natThread *nt = (natThread *) current->data;
-  _Jv_MutexLock (&nt->interrupt_mutex);
-  _Jv_CondWait (&nt->interrupt_cond, &nt->interrupt_mutex,
+  {
+    // Use a locker because _Jv_CondWait can throw an exception.
+    locker l (&nt->interrupt_mutex);
+    _Jv_CondWait (&nt->interrupt_cond, &nt->interrupt_mutex,
 		  millis, nanos);
-  _Jv_MutexUnlock (&nt->interrupt_mutex);
+  }
 
   if (current->isInterrupted ())
     _Jv_Throw (new InterruptedException);