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 <T> Return type.
+ */
+@SuppressWarnings("unused")
+public class EcoAsync<T> extends Async<T> {
 
     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<T> 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<T> c){ this(runOnConstruction, c, (Object[]) null); }
+
+    /**
+     * Asynchronously constructs a new object using the given constructor.
+     * @param c Constructor to call.
+     */
+    public EcoAsync(Constructor<T> 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<T> 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;