+ rework the cleanup process.

related to the AsyncHttpClient#1133

Author: oleksiys

src/main/java/com/ning/http/client/providers/grizzly/HttpTransactionContext.java

@@ -21,8 +21,6 @@
 import com.ning.http.util.AsyncHttpProviderUtils;
 import com.ning.http.util.ProxyUtils;
 import java.io.IOException;
-import java.util.HashSet;
-import java.util.Set;
 import org.glassfish.grizzly.CloseListener;
 import org.glassfish.grizzly.CloseType;
 import org.glassfish.grizzly.Closeable;
@@ -86,8 +84,8 @@ public final class HttpTransactionContext {
     /**
      * <tt>true</tt> if the request is fully sent, or <tt>false</tt>otherwise.
      */
-    volatile boolean isRequestFullySent;
-    Set<CompletionHandler<HttpTransactionContext>> reqFullySentHandlers;
+    private boolean isRequestFullySent;
+    private CleanupTask cleanupTask;
 
     private final CloseListener listener = new CloseListener<Closeable, CloseType>() {
         @Override
@@ -125,24 +123,9 @@ static void cleanupTransaction(final HttpContext httpCtx,
 
         assert httpTxContext != null;
 
-        if (httpTxContext.isRequestFullySent) {
-            cleanupTransaction(httpCtx, httpTxContext);
-            completionHandler.completed(httpTxContext);
-        } else {
-            httpTxContext.addRequestSentCompletionHandler(completionHandler);
-            if (httpTxContext.isRequestFullySent &&
-                    httpTxContext.removeRequestSentCompletionHandler(completionHandler)) {
-                completionHandler.completed(httpTxContext);
-            }
-        }
+        httpTxContext.scheduleCleanup(httpCtx, completionHandler);
     }
 
-    static void cleanupTransaction(final HttpContext httpCtx,
-            final HttpTransactionContext httpTxContext) {
-        httpCtx.getCloseable().removeCloseListener(httpTxContext.listener);
-        REQUEST_STATE_ATTR.remove(httpCtx);
-    }
-    
     static HttpTransactionContext currentTransaction(
             final HttpHeader httpHeader) {
         return currentTransaction(httpHeader.getProcessingState().getHttpContext());
@@ -269,44 +252,56 @@ void closeConnection() {
         connection.closeSilently();
     }
 
-    private synchronized void addRequestSentCompletionHandler(
+    private void scheduleCleanup(final HttpContext httpCtx,
             final CompletionHandler<HttpTransactionContext> completionHandler) {
-        if (reqFullySentHandlers == null) {
-            reqFullySentHandlers = new HashSet<>();
+        synchronized (this) {
+            if (!isRequestFullySent) {
+                assert cleanupTask == null; // scheduleCleanup should be called only once
+                cleanupTask = new CleanupTask(httpCtx, completionHandler);
+                return;
+            }
         }
-        reqFullySentHandlers.add(completionHandler);
-    }
 
-    private synchronized boolean removeRequestSentCompletionHandler(
-            final CompletionHandler<HttpTransactionContext> completionHandler) {
-        return reqFullySentHandlers != null
-                ? reqFullySentHandlers.remove(completionHandler)
-                : false;
+        assert isRequestFullySent;
+        cleanup(httpCtx);
+        completionHandler.completed(this);
     }
 
-    boolean isRequestFullySent() {
-        return isRequestFullySent;
+    private void cleanup(final HttpContext httpCtx) {
+        httpCtx.getCloseable().removeCloseListener(listener);
+        REQUEST_STATE_ATTR.remove(httpCtx);
     }
 
     @SuppressWarnings("unchecked")
     void onRequestFullySent() {
-        this.isRequestFullySent = true;
-        
-        Object[] handlers = null;
         synchronized (this) {
-            if (reqFullySentHandlers != null) {
-                handlers = reqFullySentHandlers.toArray();
-                reqFullySentHandlers = null;
+            if (isRequestFullySent) {
+                return;
             }
+            
+            isRequestFullySent = true;
         }
 
-        if (handlers != null) {
-            for (Object o : handlers) {
-                try {
-                    ((CompletionHandler<HttpTransactionContext>) o).completed(this);
-                } catch (Exception e) {
-                }
-            }
+        if (cleanupTask != null) {
+            cleanupTask.run();
+        }
+    }
+    
+    private class CleanupTask implements Runnable {
+        private final HttpContext httpCtx;
+        private final CompletionHandler<HttpTransactionContext> completionHandler;
+        
+        private CleanupTask(final HttpContext httpCtx,
+                final CompletionHandler<HttpTransactionContext> completionHandler) {
+            this.httpCtx = httpCtx;
+            this.completionHandler = completionHandler;
+        }
+
+        @Override
+        public void run() {
+            cleanup(httpCtx);
+            completionHandler.completed(HttpTransactionContext.this);
         }
+        
     }
 } // END HttpTransactionContext