win32-threads.cc: (ensure_interrupt_event_initialized) New function for lazy initialization of an...

* win32-threads.cc: (ensure_interrupt_event_initialized) New
	function for lazy initialization of an auto-reset event.
	(_Jv_CondWait) Added thread interrupt support.
	(_Jv_ThreadInitData) Added initialization of interrupt support
	members.
	(_Jv_ThreadDestroyData) Added cleanup of interrupt support members.
	(_Jv_ThreadStart) Removed unused code.
	(_Jv_Win32GetInterruptEvent) New method for returning interrupt event
	to an external caller.
	(_Jv_ThreadInterrupt) Implemented.
	* include/win32-threads.h: (_Jv_Thread_t) Added a Win32 auto-reset
	event for interrupt support as well as a mutex which regulates
	access to this.
	(_Jv_Win32GetInterruptEvent) Declared new method for returning interrupt
	event to an external caller.
	* java/lang/natWin32Process.cc: (cleanup) Close handle to spawned
	process.
	(waitFor) Added interrupt support.

From-SVN: r71562

libjava/ChangeLog

@@ -1,3 +1,24 @@
+2003-09-19  Mohan Embar  <gnustuff@thisiscool.com>
+
+	* win32-threads.cc: (ensure_interrupt_event_initialized) New
+	function for lazy initialization of an auto-reset event.
+	(_Jv_CondWait) Added thread interrupt support.
+	(_Jv_ThreadInitData) Added initialization of interrupt support
+	members.
+	(_Jv_ThreadDestroyData) Added cleanup of interrupt support members.
+	(_Jv_ThreadStart) Removed unused code.
+	(_Jv_Win32GetInterruptEvent) New method for returning interrupt event
+	to an external caller.
+	(_Jv_ThreadInterrupt) Implemented.
+	* include/win32-threads.h: (_Jv_Thread_t) Added a Win32 auto-reset
+	event for interrupt support as well as a mutex which regulates
+	access to this.
+	(_Jv_Win32GetInterruptEvent) Declared new method for returning interrupt
+	event to an external caller.
+	* java/lang/natWin32Process.cc: (cleanup) Close handle to spawned
+	process.
+	(waitFor) Added interrupt support.
+
 2003-09-19  Michael Koch  <konqueror@gmx.de>
 
 	* java/net/DatagramSocket.java (getLocalAddress):

libjava/include/win32-threads.h

@@ -50,6 +50,14 @@ typedef struct
 {
   int flags;            // Flags are defined in implementation.
   HANDLE handle;        // Actual handle to the thread
+
+  // Protects access to the thread's interrupt_flag and
+  // interrupt_event variables within this module.
+  CRITICAL_SECTION interrupt_mutex;
+  
+  // A Win32 auto-reset event for thread interruption
+  HANDLE interrupt_event;
+
   java::lang::Thread *thread_obj;
 } _Jv_Thread_t;
 
@@ -150,6 +158,24 @@ void _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
 void _Jv_ThreadWait (void);
 void _Jv_ThreadInterrupt (_Jv_Thread_t *data);
 
+//
+// Thread interruption support
+//
+
+// Gets the auto-reset event for the current thread which is
+// signalled by _Jv_ThreadInterrupt. The caller can wait on this
+// event in addition to other waitable objects.
+//
+// NOTE: After waiting on this event with WaitForMultipleObjects,
+// you should ALWAYS use the return value of WaitForMultipleObjects
+// to test whether this event was signalled and whether thread
+// interruption has occurred. You should do this instead of checking
+// the thread's interrupted_flag, because someone could have reset
+// this flag in the interval of time between the return of
+// WaitForMultipleObjects and the time you query interrupted_flag.
+// See java/lang/natWin32Process.cc (waitFor) for an example.
+HANDLE _Jv_Win32GetInterruptEvent (void);
+
 // Remove defines from <windows.h> that conflict with various things in libgcj code
 
 #undef TRUE

libjava/java/lang/natWin32Process.cc

@@ -46,6 +46,11 @@ java::lang::ConcreteProcess::cleanup (void)
       errorStream->close ();
       errorStream = NULL;
     }
+  if (procHandle)
+    {
+      CloseHandle((HANDLE) procHandle);
+      procHandle = (jint) INVALID_HANDLE_VALUE;
+    }
 }
 
 void
@@ -92,8 +97,28 @@ java::lang::ConcreteProcess::waitFor (void)
     {
       DWORD exitStatus = 0UL;
 
-      // FIXME: The wait should be interruptible.
-      WaitForSingleObject ((HANDLE) procHandle, INFINITE);
+      // Set up our waitable objects array
+      // - 0: the handle to the process we just launched
+      // - 1: our thread's interrupt event
+      HANDLE arh[2];
+      arh[0] = (HANDLE) procHandle;
+      arh[1] = _Jv_Win32GetInterruptEvent ();
+      DWORD rval = WaitForMultipleObjects (2, arh, 0, INFINITE);
+
+      // Use the returned value from WaitForMultipleObjects
+      // instead of our thread's interrupt_flag to test for
+      // thread interruption. See the comment for
+      // _Jv_Win32GetInterruptEvent().
+      bool bInterrupted = rval == (WAIT_OBJECT_0 + 1);
+      
+      if (bInterrupted)
+        {
+          // Querying this forces a reset our thread's interrupt flag.
+          Thread::interrupted();
+          
+          cleanup ();
+          throw new InterruptedException ();
+        }
 
       GetExitCodeProcess ((HANDLE) procHandle, &exitStatus);
       exitCode = exitStatus;

libjava/win32-threads.cc

@@ -81,6 +81,16 @@ ensure_condvar_initialized(_Jv_ConditionVariable_t *cv)
     }
 }
 
+inline void
+ensure_interrupt_event_initialized(HANDLE& rhEvent)
+{
+  if (!rhEvent)
+    {
+      rhEvent = CreateEvent (NULL, 0, 0, NULL);
+      if (!rhEvent) JvFail("CreateEvent() failed");
+    }
+}
+
 // Reimplementation of the general algorithm described at
 // http://www.cs.wustl.edu/~schmidt/win32-cv-1.html (isomorphic to
 // 3.2, not a cut-and-paste).
@@ -91,6 +101,21 @@ _Jv_CondWait(_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint na
   if (mu->owner != GetCurrentThreadId ( ))
     return _JV_NOT_OWNER;
 
+  _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
+  java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
+
+  // Now that we hold the interrupt mutex, check if this thread has been 
+  // interrupted already.
+  EnterCriticalSection (&current->interrupt_mutex);
+  ensure_interrupt_event_initialized (current->interrupt_event);
+  jboolean interrupted = current_obj->interrupt_flag;
+  LeaveCriticalSection (&current->interrupt_mutex);
+
+  if (interrupted)
+    {
+      return _JV_INTERRUPTED;
+    }
+
   EnterCriticalSection (&cv->count_mutex);
   ensure_condvar_initialized (cv);
   cv->blocked_count++;
@@ -103,7 +128,31 @@ _Jv_CondWait(_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint na
 
   _Jv_MutexUnlock (mu);
 
-  DWORD rval = WaitForMultipleObjects (2, &(cv->ev[0]), 0, time);
+  // Set up our array of three events:
+  // - the auto-reset event (for notify())
+  // - the manual-reset event (for notifyAll())
+  // - the interrupt event (for interrupt())
+  // We wait for any one of these to be signaled.
+  HANDLE arh[3];
+  arh[0] = cv->ev[0];
+  arh[1] = cv->ev[1];
+  arh[2] = current->interrupt_event;
+  DWORD rval = WaitForMultipleObjects (3, arh, 0, time);
+
+  EnterCriticalSection (&current->interrupt_mutex);
+
+  // If we were unblocked by the third event (our thread's interrupt
+  // event), set the thread's interrupt flag. I think this sanity
+  // check guards against someone resetting our interrupt flag
+  // in the time between when interrupt_mutex is released in
+  // _Jv_ThreadInterrupt and the interval of time between the
+  // WaitForMultipleObjects call we just made and our acquisition
+  // of interrupt_mutex.
+  if (rval == (WAIT_OBJECT_0 + 2))
+    current_obj->interrupt_flag = true;
+    
+  interrupted = current_obj->interrupt_flag;
+  LeaveCriticalSection (&current->interrupt_mutex);
 
   EnterCriticalSection(&cv->count_mutex);
   cv->blocked_count--;
@@ -116,8 +165,8 @@ _Jv_CondWait(_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint na
     ResetEvent (cv->ev[1]);
 
   _Jv_MutexLock (mu);
-
-  return 0;
+  
+  return interrupted ? _JV_INTERRUPTED : 0;
 }
 
 void
@@ -197,6 +246,8 @@ _Jv_ThreadInitData (java::lang::Thread* obj)
   _Jv_Thread_t *data = (_Jv_Thread_t*)_Jv_Malloc(sizeof(_Jv_Thread_t));
   data->flags = 0;
   data->thread_obj = obj;
+  data->interrupt_event = 0;
+  InitializeCriticalSection (&data->interrupt_mutex);
 
   return data;
 }
@@ -204,6 +255,9 @@ _Jv_ThreadInitData (java::lang::Thread* obj)
 void
 _Jv_ThreadDestroyData (_Jv_Thread_t *data)
 {
+  DeleteCriticalSection (&data->interrupt_mutex);
+  if (data->interrupt_event)
+    CloseHandle(data->interrupt_event);
   _Jv_Free(data);
 }
 
@@ -308,11 +362,8 @@ _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data, _Jv_ThreadStart
   else
     data->flags |= FLAG_DAEMON;
 
-  HANDLE h = GC_CreateThread(NULL, 0, really_start, info, 0, &id);
+  GC_CreateThread(NULL, 0, really_start, info, 0, &id);
   _Jv_ThreadSetPriority(data, thread->getPriority());
-
-  //if (!h)
-    //JvThrow ();
 }
 
 void
@@ -326,9 +377,27 @@ _Jv_ThreadWait (void)
     }
 }
 
+//
+// Interrupt support
+//
+
+HANDLE
+_Jv_Win32GetInterruptEvent (void)
+{
+  _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
+  EnterCriticalSection (&current->interrupt_mutex);
+  ensure_interrupt_event_initialized (current->interrupt_event);
+  HANDLE hEvent = current->interrupt_event;
+  LeaveCriticalSection (&current->interrupt_mutex);
+  return hEvent;
+}
+
 void
 _Jv_ThreadInterrupt (_Jv_Thread_t *data)
 {
-  MessageBox(NULL, "Unimplemented", "win32-threads.cc:_Jv_ThreadInterrupt", MB_OK);
-  // FIXME:
+  EnterCriticalSection (&data->interrupt_mutex);
+  ensure_interrupt_event_initialized (data->interrupt_event);
+  data->thread_obj->interrupt_flag = true;
+  SetEvent (data->interrupt_event);
+  LeaveCriticalSection (&data->interrupt_mutex);
 }