From 67e71d2d9afa0e40024a5fff62a640257229c147 Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Thu, 3 Nov 2016 23:16:23 +0100 Subject: [PATCH] Major patch Fixed major bug in Eco Async class causing infinite loop when await() is called Added multiple variants of EcoAsync constructor to simplify and untangle code of future developers EcoAsync is now generic and so is it's return type! Added comments to every constructor so as not to confuse developers --- src/com/tofvesson/async/EcoAsync$1.java | 1 + src/com/tofvesson/async/EcoAsync.java | 82 +++++++++++++++++++++++-- 2 files changed, 78 insertions(+), 5 deletions(-) diff --git a/src/com/tofvesson/async/EcoAsync$1.java b/src/com/tofvesson/async/EcoAsync$1.java index e9cbbb0..08ad492 100644 --- a/src/com/tofvesson/async/EcoAsync$1.java +++ b/src/com/tofvesson/async/EcoAsync$1.java @@ -25,6 +25,7 @@ class EcoAsync$1 implements Runnable{ synchronized (this) { try { this$0.ret = val$method.invoke(val$o, val$params); + this$0.complete = true; } catch (Throwable t1) { if(!this$0.failed) { diff --git a/src/com/tofvesson/async/EcoAsync.java b/src/com/tofvesson/async/EcoAsync.java index 97c354e..45df92d 100644 --- a/src/com/tofvesson/async/EcoAsync.java +++ b/src/com/tofvesson/async/EcoAsync.java @@ -6,7 +6,12 @@ import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -public class EcoAsync extends Async { +/** + * Economic asynchronous calls. After a result has been returned to the caller, the object resets and is ready to dispatch another operation. + * @param Return type. + */ +@SuppressWarnings("unused") +public class EcoAsync extends Async { private static final Field threadTarget, runnableObjToCall, runnableMethod, runnableParams; private Thread previousThread; @@ -49,6 +54,70 @@ public class EcoAsync extends Async { if(runOnConstruction) try{ task.start(); }catch(Exception ignored){} } + /** + * Initiates an economic, asynchronous call to the supplied method on the supplied object or if runOnConstruction == false, just prepares for it. + * @param runOnConstruction Whether or not to dispatch asynchronous call after construction. + * @param o Object to call method on. + * @param m Method to invoke. + */ + public EcoAsync(boolean runOnConstruction, Object o, Method m){ this(runOnConstruction, o, m, (Object[]) null); } + + /** + * Initiates an economic, asynchronous call to the supplied method on the supplied object. + * @param params Parameters to supply to method. + * @param o Object to call method on. + * @param m Method to invoke. + */ + public EcoAsync(Object o, Method m, Object... params){ this(true, o, m, params); } + + /** + * Prepares to invoke the passed static method with given parameters and invokes if runOnConstruction == true; + * @param runOnConstruction Whether or not to invoke the given method after EcoAsync object is constructed. + * @param m Static method to invoke. + * @param params Parameters to pass to method. + */ + public EcoAsync(boolean runOnConstruction, Method m, Object... params){ this(runOnConstruction, null, m, params); } + + /** + * Invokes the passed static method with given parameters. + * @param m Static method to invoke. + * @param params Parameters to pass to method. + */ + public EcoAsync(Method m, Object... params){ this(true, null, m, params); } + + /** + * Invokes the passed static method if runOnConstruction == true, otherwise it just prepares to invoke. + * @param m Static method to invoke. + * @param runOnConstruction Whether or not to invoke the given method after EcoAsync object is constructed. + */ + public EcoAsync(boolean runOnConstruction, Method m){ this(runOnConstruction, null, m, (Object[]) null); } + + /** + * Invokes the passed static method asynchronously. + * @param m Static method to invoke. + */ + public EcoAsync(Method m){ this(true, null, m, (Object[]) null); } + + /** + * Asynchronously constructs a new object with the given parameters. + * @param c Constructor ti call. + * @param params Parameters to pass. + */ + public EcoAsync(Constructor c, Object... params){ this(true, c, params); } + + /** + * Prepares for asynchronous invocation of given constructor. + * @param runOnConstruction Whether or not to construct object after EcoAsync object is constructed. + * @param c Constructor to invoke. + */ + public EcoAsync(boolean runOnConstruction, Constructor c){ this(runOnConstruction, c, (Object[]) null); } + + /** + * Asynchronously constructs a new object using the given constructor. + * @param c Constructor to call. + */ + public EcoAsync(Constructor c){ this(true, c); } + /** * Initiates an economic version of async task that constructs an object using the supplied constructor. * Note that though this is optimized for larger tasks id est tasks that take more than 5 milliseconds to process, this class was designed with @@ -60,18 +129,19 @@ public class EcoAsync extends Async { * @param c Constructor to use when constructing. * @param params Parameter to use when constructing. */ - public EcoAsync(boolean runOnConstruction, Constructor c, Object... params){ + public EcoAsync(boolean runOnConstruction, Constructor c, Object... params){ super(); c.setAccessible(true); try { - Method m = EcoAsync.class.getMethod("constructObject", Constructor.class, Object[].class); + Method m = EcoAsync.class.getDeclaredMethod("constructObject", Constructor.class, Object[].class); + m.setAccessible(true); newThread(null, m, c, params); - } catch (NoSuchMethodException e) { } + } catch (NoSuchMethodException e) { e.printStackTrace(); } if(runOnConstruction) try{ task.start(); }catch(Exception ignored){} } @Override - public Object await() { + public T await() { //noinspection StatementWithEmptyBody while(!failed && !complete); if(ret==null && t!=null){ @@ -79,6 +149,7 @@ public class EcoAsync extends Async { super.t = null; // Added for re-usability throw new RuntimeException(t); } + complete = false; return ret; } @@ -91,6 +162,7 @@ public class EcoAsync extends Async { public void cancel() { previousThread = task;// Store a reference to the previous thread super.cancel(); + //noinspection StatementWithEmptyBody while(previousThread.isAlive()) ; complete = false; failed = false;