Makefile.in: New #defines and friends for Thread.h.

* Makefile.in: New #defines and friends for Thread.h.
        * posix-threads.cc: (struct starter): Remove `object'.
        (_Jv_CondWait): Use interruptable condition variables and new
        recursive mutexes. New return codes on interrupt or non-ownership
        of mutex.
        (_Jv_CondNotify): Ditto.
        (_Jv_CondNotifyAll): Ditto.
        (_Jv_ThreadInterrupt): Set thread interrupt flag directly. Interrupt
        the target thread by signaling its wait condition.
        (_Jv_ThreadInitData): Set `thread_obj' in the thread data struct,
        not the starter struct. Initialize wait_mutex and wait_cond.
        (_Jv_MutexLock): New recursive mutex implementation. Moved from
        posix-threads.h.
        (_Jv_MutexUnlock): Ditto.
        (really_start): Set info->data->thread from pthread_self() to work
        around a race condition. Destroy wait_mutex and wait_cond when run()
        returns.
        * java/lang/Thread.java: (isInterrupted_): Renamed to overloaded
        `isInterrupted(boolean)'. Clear interrupted flag if clear_flag is
        set.
        startable_flag: New private field.
        (Thread): Initialize `startable_flag'.
        (toString): Check for null thread group.
        * java/lang/natThread.cc: (struct natThread): New fields
        `join_mutex', `join_cond'. Removed fields `joiner', `next'.
        (class locker): Removed.
        (initialize_native): Initialize `join_cond' and `join_mutex'.
        (interrupt): Now just calls _Jv_ThreadInterrupt().
        (join): Simplified. Just wait on the target thread's join condition.
        (finish_): Remove join list code. Unset thread group. Signal
        potential joiners by notifying the dying threads join_cond.
        (start): Check for illegal restarts.
        * java/lang/natObject.cc: Check for return value of _Jv_CondWait and
        act appropriatly.
        * include/posix-threads.h: Remove all HAVE_RECURSIVE_MUTEX related
        #defines and #ifdefs.
        (struct _Jv_Thread_t): New fields `thread_obj', `wait_cond',
        `wait_mutex', `next'.
        (struct _Jv_ConditionVariable_t): Define as a struct instead of
        directly mapping to pthread_cond_t.
        (struct _Jv_Mutex_t): New recursive implementation.
        (_Jv_PthreadCheckMonitor): Reimplemented. Simple `owner' check.
        _Jv_HaveCondDestroy: Never define this for posix-threads.
        (_Jv_CondNotify): Remove inline implementation(s), prototype instead.
        (_Jv_CondNotifyAll): Ditto.
        (_Jv_MutexLock): Ditto.
        (_Jv_MutexUnlock): Ditto.
        (_Jv_MutexInit): Changed to reflect new mutex implementation.
        (_Jv_MutexDestroy): Ditto.
        (_Jv_CondDestroy): Removed.
        (_Jv_PthreadGetMutex): Removed.
        * include/win32-threads.h: (_Jv_CondNotify): Guess _JV_NOT_OWNER on an
        error. Add a FIXME about this.
        (_Jv_CondNotifyAll): Ditto.
        * win32-threads.cc: (_Jv_CondWait): Return 0 on a timeout. Guess
        _JV_NOT_OWNER on other errors. Add FIXME.

From-SVN: r32773

libjava/java/lang/Thread.java

@@ -79,12 +79,11 @@ public class Thread implements Runnable
 
   public static boolean interrupted ()
   {
-    return currentThread().isInterrupted_();
+    return currentThread().isInterrupted (true);
   }
 
-  // FIXME: it seems to me that this should be synchronized.
   // Check the threads interrupted status. Note that this does not clear the
-  // threads interrupted status (per JDK 1.2 online API documentation).
+  // thread's interrupted status (per JDK 1.2 online API documentation).
   public boolean isInterrupted ()
   {
     return interrupt_flag;
@@ -119,11 +118,18 @@ public class Thread implements Runnable
   private static final native void run_ (Object obj);
   private final native void finish_ ();
 
-  // Convenience method to check and clear the thread's interrupted status.  
-  private boolean isInterrupted_ ()
+  // Check the thread's interrupted status. If clear_flag is true, the 
+  // thread's interrupted status is also cleared.
+  private boolean isInterrupted (boolean clear_flag)
   {
     boolean r = interrupt_flag;
-    interrupt_flag = false;
+    if (clear_flag && r)
+      {
+	// Only clear the flag if we saw it as set. Otherwise this could 
+	// potentially cause us to miss an interrupt in a race condition, 
+	// because this method is not synchronized.
+	interrupt_flag = false;
+      }
     return r;
   }
   
@@ -221,6 +227,8 @@ public class Thread implements Runnable
     data = null;
     interrupt_flag = false;
     alive_flag = false;
+    startable_flag = true;
+    
     if (current != null)
       {
 	daemon_flag = current.isDaemon();
@@ -267,7 +275,8 @@ public class Thread implements Runnable
 
   public String toString ()
   {
-    return "Thread[" + name + "," + priority + "," + group.getName() + "]";
+    return "Thread[" + name + "," + priority + "," + 
+	   (group == null ? "" : group.getName()) + "]";
   }
 
   public static native void yield ();
@@ -280,6 +289,7 @@ public class Thread implements Runnable
   private boolean daemon_flag;
   private boolean interrupt_flag;
   private boolean alive_flag;
+  private boolean startable_flag;
 
   // Our native data.
   private RawData data;

libjava/java/lang/natObject.cc

@@ -198,11 +198,15 @@ java::lang::Object::wait (jlong timeout, jint nanos)
   if (timeout < 0 || nanos < 0 || nanos > 999999)
     JvThrow (new IllegalArgumentException);
   _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info;
-  if (_Jv_CondWait (&si->condition, &si->mutex, timeout, nanos))
-    JvThrow (new IllegalMonitorStateException(JvNewStringLatin1 
-                                              ("current thread not owner")));
-  if (Thread::interrupted())
-    JvThrow (new InterruptedException);
+  switch (_Jv_CondWait (&si->condition, &si->mutex, timeout, nanos))
+    {
+      case _JV_NOT_OWNER:
+	JvThrow (new IllegalMonitorStateException (JvNewStringLatin1 
+                          ("current thread not owner")));        
+      case _JV_INTERRUPTED:
+	if (Thread::interrupted ())
+	  JvThrow (new InterruptedException);        
+    }
 }
 
 //

libjava/java/lang/natThread.cc

@@ -35,47 +35,16 @@ details.  */
 struct natThread
 {
   // These are used to interrupt sleep and join calls.  We can share a
-  // condition variable here since this thread can either be sleeping
-  // or waiting for a thread exit, but not both.
-  _Jv_Mutex_t interrupt_mutex;
-  _Jv_ConditionVariable_t interrupt_cond;
+  // condition variable here since it only ever gets notified when the thread
+  // exits.
+  _Jv_Mutex_t join_mutex;
+  _Jv_ConditionVariable_t join_cond;
 
   // This is private data for the thread system layer.
   _Jv_Thread_t *thread;
 
   // Each thread has its own JNI object.
   JNIEnv *jni_env;
-
-  // All threads waiting to join this thread are linked together and
-  // waiting on their respective `interrupt' condition variables.
-  // When this thread exits, it notifies each such thread by
-  // signalling the condition.  In this case the `interrupt_flag' is
-  // not set; this is how the waiting thread knows whether the join
-  // has failed or whether it should throw an exception.
-  struct natThread *joiner;
-
-  // Chain for waiters.
-  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
@@ -90,14 +59,12 @@ java::lang::Thread::initialize_native (void)
   // any "interesting" point.
   natThread *nt = (natThread *) _Jv_AllocBytes (sizeof (natThread));
   data = reinterpret_cast<gnu::gcj::RawData *> (nt);
-  _Jv_MutexInit (&nt->interrupt_mutex);
-  _Jv_CondInit (&nt->interrupt_cond);
+  _Jv_MutexInit (&nt->join_mutex);
+  _Jv_CondInit (&nt->join_cond);
   _Jv_ThreadInitData (&nt->thread, this);
   // FIXME: if JNI_ENV is set we will want to free it.  It is
   // malloc()d.
   nt->jni_env = NULL;
-  nt->joiner = 0;
-  nt->next = 0;
 }
 
 jint
@@ -125,90 +92,33 @@ java::lang::Thread::destroy (void)
 void
 java::lang::Thread::interrupt (void)
 {
-  interrupt_flag = true;
-
-  // Wake up this thread, whether it is sleeping or waiting for
-  // another thread to exit.
   natThread *nt = (natThread *) data;
-  _Jv_MutexLock (&nt->interrupt_mutex);
-  // Notify the interrupt condition to interrupt sleep() and join() calls.
-  _Jv_CondNotify (&nt->interrupt_cond, &nt->interrupt_mutex);
-  // Send a signal to the target thread to interrupt system calls. On Linux,
-  // this will also interrupt the target thread from *any* _Jv_CondWait call,
-  // ie wait(). This behaviour is not portable, however.
   _Jv_ThreadInterrupt (nt->thread);
-  _Jv_MutexUnlock (&nt->interrupt_mutex);
 }
 
 void
 java::lang::Thread::join (jlong millis, jint nanos)
 {
-  // FIXME: what if we are trying to join ourselves with no timeout?
-
   if (millis < 0 || nanos < 0 || nanos > 999999)
     _Jv_Throw (new IllegalArgumentException);
 
   Thread *current = currentThread ();
-  if (current->isInterrupted_ ())
-    _Jv_Throw (new InterruptedException);
 
-  // Update the list of all threads waiting for this thread to exit.
-  // We grab a mutex when doing this in order to ensure that the
-  // required state changes are atomic.
-  _Jv_MonitorEnter (this);
-  if (! isAlive ())
-    {
-      _Jv_MonitorExit (this);
-      return;
-    }
-
-  // Here `CURR_NT' is the native structure for the currently
-  // executing thread, while `NT' is the native structure for the
-  // thread we are trying to join.
-  natThread *curr_nt = (natThread *) current->data;
+  // Here `NT' is the native structure for the thread we are trying to join.
   natThread *nt = (natThread *) data;
 
-  JvAssert (curr_nt->next == NULL);
-  // Put thread CURR_NT onto NT's list.  When NT exits, it will
-  // traverse its list and notify all joiners.
-  curr_nt->next = nt->joiner;
-  nt->joiner = curr_nt;
-  _Jv_MonitorExit (this);
-
-
   // Now wait for: (1) an interrupt, (2) the thread to exit, or (3)
-  // 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);
-  }
-
-  // Now the join has completed, one way or another.  Update the
-  // joiners list to account for this.
-  _Jv_MonitorEnter (this);
-  JvAssert (nt->joiner != NULL);
-  natThread *prev = 0;
-  natThread *t;
-  for (t = nt->joiner; t != NULL; t = t->next)
+  // the timeout to occur. 
+  _Jv_MutexLock (&nt->join_mutex);
+  if (! isAlive ())
     {
-      if (t == curr_nt)
-	{
-	  if (prev)
-	    prev->next = t->next;
-	  else
-	    nt->joiner = t->next;
-	  t->next = 0;
-	  break;
-	}
-      prev = t;
+      _Jv_MutexUnlock (&nt->join_mutex);
+      return;
     }
-  JvAssert (t != NULL);
-  _Jv_MonitorExit (this);
+  _Jv_CondWait (&nt->join_cond, &nt->join_mutex, millis, nanos);
+  _Jv_MutexUnlock (&nt->join_mutex);
 
-  if (current->isInterrupted_ ())
+  if (current->isInterrupted (true))
     _Jv_Throw (new InterruptedException);
 }
 
@@ -245,43 +155,31 @@ java::lang::Thread::sleep (jlong millis, jint nanos)
     ++nanos;
 
   Thread *current = currentThread ();
-  if (current->isInterrupted_ ())
-    _Jv_Throw (new InterruptedException);
 
   // We use a condition variable to implement sleeping so that an
-  // interrupt can wake us up.
+  // interrupt can wake us up. 
   natThread *nt = (natThread *) current->data;
-  {
-    // 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_MutexLock (&nt->join_mutex);
+  _Jv_CondWait (&nt->join_cond, &nt->join_mutex, millis, nanos);
+  _Jv_MutexUnlock (&nt->join_mutex);
 
-  if (current->isInterrupted_ ())
+  if (current->isInterrupted (true))
     _Jv_Throw (new InterruptedException);
 }
 
 void
 java::lang::Thread::finish_ ()
 {
-  // Notify all threads waiting to join this this.
-  _Jv_MonitorEnter (this);
-  alive_flag = false;
-
-  // Note that we don't bother cleaning up the joiner list here.  That
-  // is taken care of when each thread wakes up again.
   natThread *nt = (natThread *) data;
-  for (natThread *t = nt->joiner; t != NULL; t = t->next)
-    {
-      _Jv_MutexLock (&t->interrupt_mutex);
-      _Jv_CondNotify (&t->interrupt_cond, &t->interrupt_mutex);
-      _Jv_MutexUnlock (&t->interrupt_mutex);
-    }
-
+  
   group->remove (this);
-
-  _Jv_MonitorExit (this);
+  group = NULL;
+  
+  // Signal any threads that are waiting to join() us.
+  _Jv_MutexLock (&nt->join_mutex);
+  alive_flag = false;
+  _Jv_CondNotifyAll (&nt->join_cond, &nt->join_mutex);
+  _Jv_MutexUnlock (&nt->join_mutex);  
 }
 
 void
@@ -314,10 +212,12 @@ java::lang::Thread::start (void)
 {
   JvSynchronize sync (this);
 
-  if (alive_flag)
+  // Its illegal to re-start() a thread, even if its dead.
+  if (!startable_flag)
     _Jv_Throw (new IllegalThreadStateException);
 
   alive_flag = true;
+  startable_flag = false;
   natThread *nt = (natThread *) data;
   _Jv_ThreadStart (this, nt->thread, (_Jv_ThreadStartFunc *) &run_);
 }