Update ExecutionList copy and fix copyright

Author: slandelle

client/src/main/java/org/asynchttpclient/future/AbstractListenableFuture.java

@@ -78,7 +78,7 @@ public ListenableFuture<V> addListener(Runnable listener, Executor exec) {
     protected void runListeners() {
         hasRun = true;
         if (executionListInitialized) {
-            executionList().run();
+            executionList().execute();
         }
     }
 }

client/src/main/java/org/asynchttpclient/future/ExecutionList.java

@@ -1,17 +1,5 @@
 /*
- * Copyright (c) 2010-2012 Sonatype, Inc. All rights reserved.
- *
- * This program is licensed to you under the Apache License Version 2.0,
- * and you may not use this file except in compliance with the Apache License Version 2.0.
- * You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the Apache License Version 2.0 is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
- */
-/*
- * Copyright (C) 2007 Google Inc.
+ * Copyright (C) 2007 The Guava Authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,106 +18,132 @@
 
 import static org.asynchttpclient.util.Assertions.*;
 
-import java.util.Queue;
 import java.util.concurrent.Executor;
-import java.util.concurrent.LinkedBlockingQueue;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 /**
- * A list of ({@code Runnable}, {@code Executor}) pairs that guarantees
- * that every {@code Runnable} that is added using the add method will be
- * executed in its associated {@code Executor} after {@link #run()} is called.
- * {@code Runnable}s added after {@code run} is called are still guaranteed to
- * execute.
+ * A support class for {@code ListenableFuture} implementations to manage their listeners. An instance contains a list of listeners, each with an associated {@code Executor}, and
+ * guarantees that every {@code Runnable} that is {@linkplain #add added} will be executed after {@link #execute()} is called. Any {@code Runnable} added after the call to
+ * {@code execute} is still guaranteed to execute. There is no guarantee, however, that listeners will be executed in the order that they are added.
+ *
+ * <p>
+ * Exceptions thrown by a listener will be propagated up to the executor. Any exception thrown during {@code Executor.execute} (e.g., a {@code RejectedExecutionException} or an
+ * exception thrown by {@linkplain MoreExecutors#directExecutor direct execution}) will be caught and logged.
  *
  * @author Nishant Thakkar
  * @author Sven Mawson
- * @since 1
+ * @since 1.0
  */
-public final class ExecutionList implements Runnable {
-
+public final class ExecutionList {
     // Logger to log exceptions caught when running runnables.
-    private static final Logger log = Logger.getLogger(ExecutionList.class.getName());
+    static final Logger log = Logger.getLogger(ExecutionList.class.getName());
 
-    // The runnable,executor pairs to execute.
-    private final Queue<RunnableExecutorPair> runnables = new LinkedBlockingQueue<>();
+    /**
+     * The runnable, executor pairs to execute. This acts as a stack threaded through the {@link RunnableExecutorPair#next} field.
+     */
+    private RunnableExecutorPair runnables;
+    private boolean executed;
 
-    // Boolean we use mark when execution has started.  Only accessed from within
-    // synchronized blocks.
-    private boolean executed = false;
+    /** Creates a new, empty {@link ExecutionList}. */
+    public ExecutionList() {
+    }
 
     /**
-     * Add the runnable/executor pair to the list of pairs to execute.  Executes
-     * the pair immediately if we've already started execution.
-     * 
-     * @param runnable the runnable to be executed on complete
-     * @param executor teh executor to run the runnable
+     * Adds the {@code Runnable} and accompanying {@code Executor} to the list of listeners to execute. If execution has already begun, the listener is executed immediately.
+     *
+     * <p>
+     * When selecting an executor, note that {@code directExecutor} is dangerous in some cases. See the discussion in the {@link ListenableFuture#addListener
+     * ListenableFuture.addListener} documentation.
      */
     public void add(Runnable runnable, Executor executor) {
-
+        // Fail fast on a null. We throw NPE here because the contract of Executor states that it
+        // throws NPE on null listener, so we propagate that contract up into the add method as well.
         assertNotNull(runnable, "runnable");
         assertNotNull(executor, "executor");
-        boolean executeImmediate = false;
 
-        // Lock while we check state.  We must maintain the lock while adding the
-        // new pair so that another thread can't run the list out from under us.
-        // We only add to the list if we have not yet started execution.
-        synchronized (runnables) {
+        // Lock while we check state. We must maintain the lock while adding the new pair so that
+        // another thread can't run the list out from under us. We only add to the list if we have not
+        // yet started execution.
+        synchronized (this) {
             if (!executed) {
-                runnables.add(new RunnableExecutorPair(runnable, executor));
-            } else {
-                executeImmediate = true;
+                runnables = new RunnableExecutorPair(runnable, executor, runnables);
+                return;
             }
         }
-
-        // Execute the runnable immediately.  Because of scheduling this may end up
-        // getting called before some of the previously added runnables, but we're
-        // ok with that.  If we want to change the contract to guarantee ordering
-        // among runnables we'd have to modify the logic here to allow it.
-        if (executeImmediate) {
-            executor.execute(runnable);
-        }
+        // Execute the runnable immediately. Because of scheduling this may end up getting called before
+        // some of the previously added runnables, but we're OK with that. If we want to change the
+        // contract to guarantee ordering among runnables we'd have to modify the logic here to allow
+        // it.
+        executeListener(runnable, executor);
     }
 
     /**
-     * Runs this execution list, executing all pairs in the order they were
-     * added.  Pairs added after this method has started executing the list will
-     * be executed immediately.
+     * Runs this execution list, executing all existing pairs in the order they were added. However, note that listeners added after this point may be executed before those
+     * previously added, and note that the execution order of all listeners is ultimately chosen by the implementations of the supplied executors.
+     *
+     * <p>
+     * This method is idempotent. Calling it several times in parallel is semantically equivalent to calling it exactly once.
+     *
+     * @since 10.0 (present in 1.0 as {@code run})
      */
-    public void run() {
-
-        // Lock while we update our state so the add method above will finish adding
-        // any listeners before we start to run them.
-        synchronized (runnables) {
+    public void execute() {
+        // Lock while we update our state so the add method above will finish adding any listeners
+        // before we start to run them.
+        RunnableExecutorPair list;
+        synchronized (this) {
+            if (executed) {
+                return;
+            }
             executed = true;
+            list = runnables;
+            runnables = null; // allow GC to free listeners even if this stays around for a while.
         }
+        // If we succeeded then list holds all the runnables we to execute. The pairs in the stack are
+        // in the opposite order from how they were added so we need to reverse the list to fulfill our
+        // contract.
+        // This is somewhat annoying, but turns out to be very fast in practice. Alternatively, we
+        // could drop the contract on the method that enforces this queue like behavior since depending
+        // on it is likely to be a bug anyway.
+
+        // N.B. All writes to the list and the next pointers must have happened before the above
+        // synchronized block, so we can iterate the list without the lock held here.
+        RunnableExecutorPair reversedList = null;
+        while (list != null) {
+            RunnableExecutorPair tmp = list;
+            list = list.next;
+            tmp.next = reversedList;
+            reversedList = tmp;
+        }
+        while (reversedList != null) {
+            executeListener(reversedList.runnable, reversedList.executor);
+            reversedList = reversedList.next;
+        }
+    }
 
-        // At this point the runnables will never be modified by another
-        // thread, so we are safe using it outside of the synchronized block.
-        while (!runnables.isEmpty()) {
-            runnables.poll().execute();
+    /**
+     * Submits the given runnable to the given {@link Executor} catching and logging all {@linkplain RuntimeException runtime exceptions} thrown by the executor.
+     */
+    private static void executeListener(Runnable runnable, Executor executor) {
+        try {
+            executor.execute(runnable);
+        } catch (RuntimeException e) {
+            // Log it and keep going, bad runnable and/or executor. Don't punish the other runnables if
+            // we're given a bad one. We only catch RuntimeException because we want Errors to propagate
+            // up.
+            log.log(Level.SEVERE, "RuntimeException while executing runnable " + runnable + " with executor " + executor, e);
         }
     }
 
-    private static class RunnableExecutorPair {
+    private static final class RunnableExecutorPair {
         final Runnable runnable;
         final Executor executor;
+        RunnableExecutorPair next;
 
-        RunnableExecutorPair(Runnable runnable, Executor executor) {
+        RunnableExecutorPair(Runnable runnable, Executor executor, RunnableExecutorPair next) {
             this.runnable = runnable;
             this.executor = executor;
-        }
-
-        void execute() {
-            try {
-                executor.execute(runnable);
-            } catch (RuntimeException e) {
-                // Log it and keep going, bad runnable and/or executor.  Don't
-                // punish the other runnables if we're given a bad one.  We only
-                // catch RuntimeException because we want Errors to propagate up.
-                log.log(Level.SEVERE, "RuntimeException while executing runnable " + runnable + " with executor " + executor, e);
-            }
+            this.next = next;
         }
     }
 }