Bug 1211: Hardening Condition-Wait from Spurious-Wakeups and unintended InterruptedException(s)

Below is an updated list of Condition-Wait classifications
as described in Bug 1211.

This list includes recent changes on GlueGen
regarding this Bug 1211.

A followup commit will address the unit tests.

  - Noncancelable + Persistent-Wait
    - GLMediaPlayerImpl.StreamWorker thread (changed)
        - pauses thread in case of intr

  - Cancelable + Persistent-Wait:
    - LFRingbuffer.getImpl(..)
    - LFRingbuffer.waitForFreeSlots(int)
    - SyncedRingbuffer.getImpl(..)
    - SyncedRingbuffer.waitForFreeSlots(int)
    - FunctionTask.invokeOnNewThread(..) (changed)
    - RunnableTask.invokeOnNewThread(..) (changed)
    - SharedResourceRunner.run()
    - SharedResourceRunner.doAndWait() (changed)
    - SharedResourceRunner.start() (changed)
    - SharedResourceRunner.stop() (changed)
    - GLMediaPlayerImpl.StreamWorker ctor  (changed)
    - GLMediaPlayerImpl caller thread actions do*() (changed)
    - AndroidGLMediaPlayerAPI14.getNextTextureImpl(..) (changed)
    - DisplayImpl.enqueueEvent(..) (changed)
        -> Persistent-Wait
        -> Cancels wait and NEWTEvent
        -> dispatchMessage(NEWTEventTask): always notifyCaller!
    - GLDrawableHelper.invoke(..) (changed)
    - DefaultEDTUtil.waitUntilIdle() (changed)
    - DefaultEDTUtil.waitUntilStopped() (changed)
    - DefaultEDTUtil.invokeImpl(..)  (changed)
    - DefaultEDTUtil.NEDT.run(..)  (changed)
    - AWTEDTUtil.waitUntilStopped(..)  (changed)
    - AWTEDTUtil.invokeImpl(..)  (changed)
    - AWTEDTUtil.NEDT.run(..)  (changed)
    - SWTEDTUtil.invokeImpl(..)  (changed)
    - SWTEDTUtil.waitUntilStopped(..)  (changed)
    - SWTEDTUtil.NEDT.run(..)  (changed)
    - GLWorkerThread.invokeAndWait(..)
    - GLWorkerThread.start() (changed)
    - GLWorkerThread.WorkerRunnable.run() (changed)
    - Animator.run() (changed)
    - AnimatorBase.finishLifecycleAction() (changed)
    - OSXUtil.RunOnMainThread(..) (changed)
    - SingletonInstanceServerSocket.Server.shutdown() (changed)
    - SingletonInstanceServerSocket.Server.start() (changed)
    - com.jogamp.audio.windows.waveout.Mixer.shutdown() (changed)

  - Extending/Using InterruptSource.Thread (changed)
      - DefaultEDTUtil.NEDT
      - AWTEDTUtil.NEDT
      - SWTEDTUtil.NEDT
      - GLWorkerThread.thread
      - Mixer.FillerThread
      - Mixer.MixerThread

  - Using InterruptSource.Thread (changed)
      - TempFileCache
      - LauncherTempFileCache
      - Animator.thread
      - SingletonInstanceServerSocket.Server.serverThread

Deprecated:
    - FunctionTask.invoke(..)  (changed)
        -> on current thread, no wait -> deprecated
    - RunnableTask.invoke(..) (changed)
        -> on current thread, no wait -> deprecated

1 files changed, 28 insertions, 14 deletions

diff --git a/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java b/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
index e9ee46a51..6bc93bf36 100644
--- a/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
+++ b/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
@@ -61,6 +61,7 @@ import com.jogamp.opengl.GLFBODrawable;
 import com.jogamp.opengl.GLRunnable;
 
 import com.jogamp.common.ExceptionUtils;
+import com.jogamp.common.util.InterruptedRuntimeException;
 import com.jogamp.common.util.PropertyAccess;
 
 /** Encapsulates the implementation of most of the GLAutoDrawable's
@@ -874,9 +875,8 @@ public class GLDrawableHelper {
         return false;
     }
 
-    GLRunnableTask rTask = null;
+    final GLRunnableTask rTask;
     final Object rTaskLock = new Object();
-    Throwable throwable = null;
     synchronized(rTaskLock) {
         boolean deferredHere;
         synchronized(glRunnablesLock) {
@@ -910,13 +910,13 @@ public class GLDrawableHelper {
             drawable.display();
         } else if( wait ) {
             try {
-                rTaskLock.wait(); // free lock, allow execution of rTask
+                while( rTask.isInQueue() ) {
+                    rTaskLock.wait(); // free lock, allow execution of rTask
+                }
             } catch (final InterruptedException ie) {
-                throwable = ie;
-            }
-            if(null==throwable) {
-                throwable = rTask.getThrowable();
+                throw new InterruptedRuntimeException(ie);
             }
+            final Throwable throwable = rTask.getThrowable();
             if(null!=throwable) {
                 throw new RuntimeException(throwable);
             }
@@ -941,9 +941,8 @@ public class GLDrawableHelper {
     }
 
     final int count = newGLRunnables.size();
-    GLRunnableTask rTask = null;
+    final GLRunnableTask rTask;
     final Object rTaskLock = new Object();
-    Throwable throwable = null;
     synchronized(rTaskLock) {
         boolean deferredHere;
         synchronized(glRunnablesLock) {
@@ -981,13 +980,13 @@ public class GLDrawableHelper {
             drawable.display();
         } else if( wait ) {
             try {
-                rTaskLock.wait(); // free lock, allow execution of rTask
+                while( rTask.isInQueue() ) {
+                    rTaskLock.wait(); // free lock, allow execution of rTask
+                }
             } catch (final InterruptedException ie) {
-                throwable = ie;
-            }
-            if(null==throwable) {
-                throwable = rTask.getThrowable();
+                throw new InterruptedRuntimeException(ie);
             }
+            final Throwable throwable = rTask.getThrowable();
             if(null!=throwable) {
                 throw new RuntimeException(throwable);
             }
@@ -1082,6 +1081,21 @@ public class GLDrawableHelper {
     return exclusiveContextThread;
   }
 
+  /**
+   * Runs given {@code runnable} outside of a probable claimed exclusive thread,
+   * i.e. releases the exclusive thread, executes the runnable and reclaims it.
+   * @see #setExclusiveContextThread(Thread, GLContext)
+   * @since 2.3.2
+   */
+  public final void runOutsideOfExclusiveContextThread(final GLContext context, final Runnable runnable) {
+      final Thread t = setExclusiveContextThread(null, context);
+      try {
+          runnable.run();
+      } finally {
+          setExclusiveContextThread(t, context);
+      }
+  }
+
   private static final ThreadLocal<WeakReference<Runnable>> perThreadInitAction = new ThreadLocal<WeakReference<Runnable>>();
   private static final Runnable getLastInitAction() {
       final WeakReference<Runnable> lastInitActionWR = perThreadInitAction.get();