1 files changed, 46 insertions, 52 deletions
diff --git a/src/java/com/jogamp/common/util/RunnableTask.java b/src/java/com/jogamp/common/util/RunnableTask.java
index 6fb98de..2689de1 100644
--- a/src/java/com/jogamp/common/util/RunnableTask.java
+++ b/src/java/com/jogamp/common/util/RunnableTask.java
@@ -30,6 +30,8 @@ package com.jogamp.common.util;
 
 import java.io.PrintStream;
 
+import com.jogamp.common.JogampRuntimeException;
+
 /**
  * Helper class to provide a Runnable queue implementation with a Runnable wrapper
  * which notifies after execution for the <code>invokeAndWait()</code> semantics.
@@ -38,70 +40,58 @@ public class RunnableTask extends TaskBase {
     protected final Runnable runnable;
 
     /**
-     * Invokes <code>runnable</code> on the current thread.
-     * @param waitUntilDone if <code>true</code>, waits until <code>runnable</code> execution is completed, otherwise returns immediately.
-     * @param runnable the {@link Runnable} to execute.
+     * Invokes <code>runnable</code> on the current {@link Thread}.
+     * @param runnable the {@link Runnable} to execute on the current thread.
+     *                 The runnable <b>must exit</b>, i.e. not loop forever.
+     * @return the newly created and invoked {@link RunnableTask}
+     * @since 2.4.0
      */
-    public static void invoke(final boolean waitUntilDone, final Runnable runnable) {
-        Throwable throwable = null;
-        final Object sync = new Object();
-        final RunnableTask rt = new RunnableTask( runnable, waitUntilDone ? sync : null, true, waitUntilDone ? null : System.err );
-        synchronized(sync) {
-            rt.run();
-            if( waitUntilDone ) {
-                try {
-                    sync.wait();
-                } catch (final InterruptedException ie) {
-                    throwable = ie;
-                }
-                if(null==throwable) {
-                    throwable = rt.getThrowable();
-                }
-                if(null!=throwable) {
-                    throw new RuntimeException(throwable);
-                }
-            }
-        }
+    public static RunnableTask invokeOnCurrentThread(final Runnable runnable) {
+        final RunnableTask rt = new RunnableTask( runnable, null, false, null );
+        rt.run();
+        return rt;
     }
 
     /**
-     * Invokes <code>runnable</code> on a new thread belonging to the given {@link ThreadGroup}.
+     * Invokes <code>runnable</code> on a new {@link InterruptSource.Thread},
+     * see {@link InterruptSource.Thread#Thread(ThreadGroup, Runnable, String)} for details.
      * @param tg the {@link ThreadGroup} for the new thread, maybe <code>null</code>
+     * @param threadName the name for the new thread, maybe <code>null</code>
      * @param waitUntilDone if <code>true</code>, waits until <code>runnable</code> execution is completed, otherwise returns immediately.
      * @param runnable the {@link Runnable} to execute on the new thread. If <code>waitUntilDone</code> is <code>true</code>,
-     *                 the runnable <b>must exist</b>, i.e. not loop forever.
-     * @param threadName the name for the new thread
-     * @return the newly created {@link Thread}
+     *                 the runnable <b>must exit</b>, i.e. not loop forever.
+     * @return the newly created and invoked {@link RunnableTask}
+     * @since 2.3.2
      */
-    public static Thread invokeOnNewThread(final ThreadGroup tg, final boolean waitUntilDone, final Runnable runnable, final String threadName) {
-        final Thread t = new Thread(tg, threadName) {
-            @Override
-            public void run() {
-                Throwable throwable = null;
-                final Object sync = new Object();
-                final RunnableTask rt = new RunnableTask( runnable, waitUntilDone ? sync : null, true, waitUntilDone ? null : System.err );
-                synchronized(sync) {
-                    rt.run();
-                    if( waitUntilDone ) {
-                        try {
-                            sync.wait();
-                        } catch (final InterruptedException ie) {
-                            throwable = ie;
-                        }
-                        if(null==throwable) {
-                            throwable = rt.getThrowable();
-                        }
-                        if(null!=throwable) {
-                            throw new RuntimeException(throwable);
-                        }
+    public static RunnableTask invokeOnNewThread(final ThreadGroup tg, final String threadName,
+                                                 final boolean waitUntilDone, final Runnable runnable) {
+        final RunnableTask rt;
+        if( !waitUntilDone ) {
+            rt = new RunnableTask( runnable, null, true, System.err );
+            final InterruptSource.Thread t = InterruptSource.Thread.create(tg, rt, threadName);
+            t.start();
+        } else {
+            final Object sync = new Object();
+            rt = new RunnableTask( runnable, sync, true, null );
+            final InterruptSource.Thread t = InterruptSource.Thread.create(tg, rt, threadName);
+            synchronized(sync) {
+                t.start();
+                while( rt.isInQueue() ) {
+                    try {
+                        sync.wait();
+                    } catch (final InterruptedException ie) {
+                        throw new InterruptedRuntimeException(ie);
+                    }
+                    final Throwable throwable = rt.getThrowable();
+                    if(null!=throwable) {
+                        throw new JogampRuntimeException(throwable);
                     }
                 }
-            } };
-        t.start();
-        return t;
+            }
+        }
+        return rt;
     }
 
-
     /**
      * Create a RunnableTask object w/ synchronization,
      * ie. suitable for <code>invokeAndWait()</code>, i.e. {@link #invoke(boolean, Runnable) invoke(true, runnable)}.
@@ -126,6 +116,8 @@ public class RunnableTask extends TaskBase {
 
     @Override
     public final void run() {
+        execThread = Thread.currentThread();
+
         runnableException = null;
         tStarted = System.currentTimeMillis();
         if(null == syncObject) {
@@ -143,6 +135,7 @@ public class RunnableTask extends TaskBase {
                 }
             } finally {
                 tExecuted = System.currentTimeMillis();
+                isExecuted = true;
             }
         } else {
             synchronized (syncObject) {
@@ -160,6 +153,7 @@ public class RunnableTask extends TaskBase {
                     }
                 } finally {
                     tExecuted = System.currentTimeMillis();
+                    isExecuted = true;
                     syncObject.notifyAll();
                 }
             }