Распространение ThreadLocal на Новый Поток, полученный из ExecutorService

Как я понимаю вашу проблему, вы можете взглянуть на InheritableThreadLocal , который предназначен для передачи переменных ThreadLocal из контекста родительского потока в контекст дочернего потока

Основываясь на ответе @erickson, я написал этот код. Он работает для inheritableThreadLocals. Он строит список inheritableThreadLocals, используя тот же метод, что и в Thread contructor. Конечно, я использую для этого рефлексию. Также я переопределяю класс executor.

public class MyThreadPoolExecutor extends ThreadPoolExecutor
{
   @Override
   public void execute(Runnable command)
   {
      super.execute(new Wrapped(command, Thread.currentThread()));
   }
}

Обертка:

   private class Wrapped implements Runnable
   {
      private final Runnable task;

      private final Thread caller;

      public Wrapped(Runnable task, Thread caller)
      {
         this.task = task;
         this.caller = caller;
      }

      public void run()
      {
         Iterable<ThreadLocal<?>> vars = null;
         try
         {
            vars = copy(caller);
         }
         catch (Exception e)
         {
            throw new RuntimeException("error when coping Threads", e);
         }
         try {
            task.run();
         }
         finally {
            for (ThreadLocal<?> var : vars)
               var.remove();
         }
      }
   }

Метод копирования:

public static Iterable<ThreadLocal<?>> copy(Thread caller) throws Exception
   {
      List<ThreadLocal<?>> threadLocals = new ArrayList<>();
      Field field = Thread.class.getDeclaredField("inheritableThreadLocals");
      field.setAccessible(true);
      Object map = field.get(caller);
      Field table = Class.forName("java.lang.ThreadLocal$ThreadLocalMap").getDeclaredField("table");
      table.setAccessible(true);

      Method method = ThreadLocal.class
              .getDeclaredMethod("createInheritedMap", Class.forName("java.lang.ThreadLocal$ThreadLocalMap"));
      method.setAccessible(true);
      Object o = method.invoke(null, map);

      Field field2 = Thread.class.getDeclaredField("inheritableThreadLocals");
      field2.setAccessible(true);
      field2.set(Thread.currentThread(), o);

      Object tbl = table.get(o);
      int length = Array.getLength(tbl);
      for (int i = 0; i < length; i++)
      {
         Object entry = Array.get(tbl, i);
         Object value = null;
         if (entry != null)
         {
            Method referentField = Class.forName("java.lang.ThreadLocal$ThreadLocalMap$Entry").getMethod(
                    "get");
            referentField.setAccessible(true);
            value = referentField.invoke(entry);
            threadLocals.add((ThreadLocal<?>) value);
         }
      }
      return threadLocals;
   }

Вот пример передачи текущего LocaleContext в Родительском потоке в дочерний поток, охватываемый CompletableFuture[по умолчанию используется ForkJoinPool].

Просто определите все, что вы хотите сделать в дочернем потоке внутри управляемого блока. Поэтому, когда CompletableFuture выполняет запускаемый блок, его дочерний поток, который контролирует, и вуаля, у вас есть родительский ThreadLocal материал, установленный в дочернем ThreadLocal.

Проблема здесь не в том, что весь ThreadLocal является переписано заново. Копируется только локальный текст. Поскольку ThreadLocal имеет частный доступ только к тому потоку, к которому он принадлежит, слишком использовать отражение и пытаться получить и установить в дочернем устройстве слишком много дурацких вещей, которые могут привести к утечкам памяти или снижению производительности.

Так что если вы знаете параметры, которые вас интересуют из ThreadLocal, то это решение работает намного чище.

 public void parentClassMethod(Request request) {
        LocaleContext currentLocale = LocaleContextHolder.getLocaleContext();
        executeInChildThread(() -> {
                LocaleContextHolder.setLocaleContext(currentLocale);
                //Do whatever else you wanna do
            }));

        //Continue stuff you want to do with parent thread
}


private void executeInChildThread(Runnable runnable) {
    try {
        CompletableFuture.runAsync(runnable)
            .get();
    } catch (Exception e) {
        LOGGER.error("something is wrong");
    }
}

Мне не нравится рефлексивный подход. Альтернативным решением было бы реализовать executor wrapper и передать объект непосредственно в виде контекста ThreadLocal всем дочерним потокам, распространяющим Родительский контекст.

public class PropagatedObject {

    private ThreadLocal<ConcurrentHashMap<AbsorbedObjectType, Object>> data = new ThreadLocal<>();

   //put, set, merge methods, etc

}

==>

public class ObjectAwareExecutor extends AbstractExecutorService {

    private final ExecutorService delegate;
    private final PropagatedObject objectAbsorber;

    public ObjectAwareExecutor(ExecutorService delegate, PropagatedObject objectAbsorber){
        this.delegate = delegate;
        this.objectAbsorber = objectAbsorber;
    }
    @Override
    public void execute(final Runnable command) {

        final ConcurrentHashMap<String, Object> parentContext = objectAbsorber.get();
        delegate.execute(() -> {
            try{
                objectAbsorber.set(parentContext);
                command.run();
            }finally {
                parentContext.putAll(objectAbsorber.get());
                objectAbsorber.clean();
            }
        });
        objectAbsorber.merge(parentContext);
    }

Если вы посмотрите на код ThreadLocal, то увидите:

    public T get() {
        Thread t = Thread.currentThread();
        ...
    }

Текущий поток не может быть перезаписан.

Возможные решения:

1. Посмотрите на java 7 fork/join механизм (но я думаю, что это плохой способ)

2. Посмотрите наодобренный механизм перезаписи класса ThreadLocal в вашем JVM.

3. Попробуйте переписать RESTEasy (вы можете использовать инструменты рефакторинга в вашей IDE, чтобы заменить все Использование ThreadLocal, это выглядит просто)