Introduce static ContextManagers.useClassLoader method (#101)

* Introduce static ContextManagers.useClassLoader(cl) method

* Add forgotten `@since` tag

* Add concurrent unit test with fixed classloader

Author: sjoerdtalsma

context-propagation-java5/src/main/java/nl/talsmasoftware/context/ContextManagers.java

@@ -145,6 +145,36 @@ public static void clearActiveContexts() {
         Timing.timed(System.nanoTime() - start, ContextManagers.class, "clearActiveContexts");
     }
 
+    /**
+     * Override the {@linkplain ClassLoader} used to lookup {@linkplain ContextManager contextmanagers}.
+     * <p>
+     * Normally, taking a snapshot uses the {@linkplain Thread#getContextClassLoader() Context ClassLoader} from the
+     * {@linkplain Thread#currentThread() current thread} to look up all {@linkplain ContextManager context managers}.
+     * It is possible to configure a fixed, single classloader in your application for looking up the context managers.
+     * <p>
+     * Using this method to specify a fixed classloader will only impact
+     * new {@linkplain ContextSnapshot context snapshots}. Existing snapshots will not be impacted.
+     * <p>
+     * <strong>Notes:</strong><br>
+     * <ul>
+     * <li>Please be aware that this configuration is global!
+     * <li>This will also impact the lookup of
+     * {@linkplain nl.talsmasoftware.context.observer.ContextObserver context observers}
+     * </ul>
+     *
+     * @param classLoader The single, fixed ClassLoader to use for finding context managers.
+     *                    Specify {@code null} to restore the default behaviour.
+     * @since 1.0.5
+     */
+    public static void useClassLoader(ClassLoader classLoader) {
+        Level loglevel = PriorityServiceLoader.classLoaderOverride == classLoader ? Level.FINEST : Level.FINE;
+        if (LOGGER.isLoggable(loglevel)) {
+            LOGGER.log(loglevel, "Setting override classloader for loading ContextManager and ContextObserver " +
+                    "instances to " + classLoader + " (was: " + PriorityServiceLoader.classLoaderOverride + ").");
+        }
+        PriorityServiceLoader.classLoaderOverride = classLoader;
+    }
+
     private static void clearContext(ContextManager manager, Context context) {
         final long start = System.nanoTime();
         final Class<? extends Context> contextType = context.getClass();

context-propagation-java5/src/main/java/nl/talsmasoftware/context/PriorityServiceLoader.java

@@ -43,6 +43,8 @@ public final class PriorityServiceLoader<SVC> implements Iterable<SVC> {
     private static final String ENVIRONMENT_CACHING_VALUE = System.getenv(
             SYSTEMPROPERTY_CACHING.replace('.', '_').toUpperCase(Locale.ENGLISH));
 
+    // Set from ContextManagers.useClassLoader(); sometimes a single, fixed classloader may be necessary (e.g. #97)
+    static volatile ClassLoader classLoaderOverride = null;
     private final Class<SVC> serviceType;
     private final Map<ClassLoader, List<SVC>> cache = new WeakHashMap<ClassLoader, List<SVC>>();
 
@@ -53,11 +55,12 @@ public PriorityServiceLoader(Class<SVC> serviceType) {
 
     @SuppressWarnings("unchecked")
     public Iterator<SVC> iterator() {
-        final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
-        List<SVC> services = cache.get(contextClassLoader);
+        final ClassLoader classLoader =
+                classLoaderOverride == null ? Thread.currentThread().getContextClassLoader() : classLoaderOverride;
+        List<SVC> services = cache.get(classLoader);
         if (services == null) {
-            services = findServices(contextClassLoader);
-            if (!isCachingDisabled()) cache.put(contextClassLoader, services);
+            services = findServices(classLoader);
+            if (!isCachingDisabled()) cache.put(classLoader, services);
         }
         return services.iterator();
     }

context-propagation-java5/src/test/java/nl/talsmasoftware/context/ContextManagersTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2018 Talsma ICT
+ * Copyright 2016-2019 Talsma ICT
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -75,6 +75,12 @@ public void resetContexts() {
         DummyContext.reset();
     }
 
+    @Before
+    @After
+    public void resetContextClassLoader() {
+        ContextManagers.useClassLoader(null);
+    }
+
     @Test
     public void testUnsupportedConstructor() {
         Constructor<?>[] constructors = ContextManagers.class.getDeclaredConstructors();
@@ -273,4 +279,27 @@ public void testClearManagedContexts_withoutContextManagers() {
             assertThat("Restore service file!", TMP_SERVICE_FILE.renameTo(SERVICE_FILE), is(true));
         }
     }
+
+    @Test
+    public void testConcurrentSnapshots_fixedClassLoader() throws ExecutionException, InterruptedException {
+        ContextManagers.useClassLoader(Thread.currentThread().getContextClassLoader());
+        int threadcount = 25;
+        ExecutorService threadpool = Executors.newFixedThreadPool(threadcount);
+        try {
+            List<Future<ContextSnapshot>> snapshots = new ArrayList<Future<ContextSnapshot>>(threadcount);
+            for (int i = 0; i < threadcount; i++) {
+                snapshots.add(threadpool.submit(new Callable<ContextSnapshot>() {
+                    public ContextSnapshot call() throws Exception {
+                        return ContextManagers.createContextSnapshot();
+                    }
+                }));
+            }
+
+            for (int i = 0; i < threadcount; i++) {
+                assertThat(snapshots.get(i).get(), is(notNullValue()));
+            }
+        } finally {
+            threadpool.shutdown();
+        }
+    }
 }

context-propagation-java8/src/main/java/nl/talsmasoftware/context/futures/ContextAwareCompletableFuture.java

@@ -158,6 +158,7 @@ public static <U> ContextAwareCompletableFuture<U> supplyAsync(Supplier<U> suppl
      * @param <U>             the function's return type
      * @return The new CompletableFuture that propagates the specified context snapshot
      * @see CompletableFuture#supplyAsync(Supplier, Executor)
+     * @since 1.0.4
      */
     public static <U> ContextAwareCompletableFuture<U> supplyAsync(
             Supplier<U> supplier, Executor executor, ContextSnapshot snapshot, boolean takeNewSnapshot) {
@@ -242,6 +243,7 @@ public static ContextAwareCompletableFuture<Void> runAsync(Runnable runnable, Ex
      *                        If {@code true}, a new snapshot is taken after each completion stage to propagate into the next.
      * @return The new CompletableFuture that propagates a snapshot of the current context
      * @see CompletableFuture#runAsync(Runnable, Executor)
+     * @since 1.0.4
      */
     public static ContextAwareCompletableFuture<Void> runAsync(
             Runnable runnable, Executor executor, ContextSnapshot snapshot, boolean takeNewSnapshot) {