From c0523fc5e816556ea3b05421a3ee67375a6b83d4 Mon Sep 17 00:00:00 2001
From: Lyor Goldstein <lgoldstein@vmware.com>
Date: Wed, 8 Oct 2014 10:23:14 +0300
Subject: [PATCH] 446023 patch

---
 .../tools/cache/AsynchronousFileCacheBacking.java  | 58 +++++++++++++---------
 1 file changed, 34 insertions(+), 24 deletions(-)

diff --git a/weaver/src/org/aspectj/weaver/tools/cache/AsynchronousFileCacheBacking.java b/weaver/src/org/aspectj/weaver/tools/cache/AsynchronousFileCacheBacking.java
index 636a82a..e0c6e88 100644
--- a/weaver/src/org/aspectj/weaver/tools/cache/AsynchronousFileCacheBacking.java
+++ b/weaver/src/org/aspectj/weaver/tools/cache/AsynchronousFileCacheBacking.java
@@ -51,8 +51,7 @@ import org.aspectj.weaver.tools.TraceFactory;
  */
 public abstract class AsynchronousFileCacheBacking extends AbstractIndexedFileCacheBacking {
     private static final BlockingQueue<AsyncCommand>   commandsQ=new LinkedBlockingQueue<AsyncCommand>();
-    private static final ExecutorService    execService=Executors.newSingleThreadExecutor();
-    private static Future<?> commandsRunner;
+    private static final AtomicReference<Thread>    updateHolder=new AtomicReference<Thread>(null);
 
     protected final Map<String, IndexEntry> index, exposedIndex;
     protected final Map<String, byte[]>   bytesMap, exposedBytes;
@@ -286,34 +285,45 @@ public abstract class AsynchronousFileCacheBacking extends AbstractIndexedFileCa
         }
 
         // start the service (if needed) only if successfully create the backing instance
-        T    backing=creator.create(cacheDir);
-        synchronized(execService) {
-            if (commandsRunner == null) {
-                commandsRunner = execService.submit(new Runnable() {
-                    @SuppressWarnings("synthetic-access")
-                    public void run() {
-                        for ( ; ; ) {
-                            try {
-                                AsyncCommand    cmd=commandsQ.take();
+        T        backing=creator.create(cacheDir);
+        Thread   runner=null, prev=null;
+        // use 1st call to spawn the async. thread
+        synchronized(updateHolder) {
+            if ((prev=updateHolder.get()) == null) {
+                runner = new Thread(new Runnable() {
+                        @SuppressWarnings("synthetic-access")
+                        public void run() {
+                            for ( ; ; ) {
                                 try {
-                                    AsynchronousFileCacheBacking    cache=cmd.getCache();
-                                    cache.executeCommand(cmd);
-                                } catch(Exception e) {
+                                    AsyncCommand    cmd=commandsQ.take();
+                                    try {
+                                        AsynchronousFileCacheBacking    cache=cmd.getCache();
+                                        cache.executeCommand(cmd);
+                                    } catch(Exception e) {
+                                        if ((trace != null) && trace.isTraceEnabled()) {
+                                            trace.error("Failed (" + e.getClass().getSimpleName() + ")"
+                                                      + " to execute " + cmd + ": " + e.getMessage(), e);
+                                        }
+                                    }
+                                } catch(InterruptedException e) {
                                     if ((trace != null) && trace.isTraceEnabled()) {
-                                        trace.error("Failed (" + e.getClass().getSimpleName() + ")"
-                                                  + " to execute " + cmd + ": " + e.getMessage(), e);
+                                        trace.warn("Interrupted");
                                     }
+                                    Thread.currentThread().interrupt();
+                                    break;
                                 }
-                            } catch(InterruptedException e) {
-                                if ((trace != null) && trace.isTraceEnabled()) {
-                                    trace.warn("Interrupted");
-                                }
-                                Thread.currentThread().interrupt();
-                                break;
                             }
                         }
-                    }
-                });
+                    });
+                runner.setDaemon(true);
+                updateHolder.set(runner);
+                runner.start();
+            }
+        }
+        
+        if ((prev == null) && (runner != null)) {
+            if ((trace != null) && trace.isTraceEnabled()) {
+                trace.info("Started asynchronous update thread");
             }
         }
 
-- 
1.9.4.msysgit.2