* <p>Note: If a parameter is set to {@code null}, the corresponding ThreadLocal variable is removed.</p>
 */
public final class CrawlingParameterUtil {
    private static final ThreadLocal<UrlQueue<?>> URL_QUEUE_THREAD_LOCAL = new ThreadLocal<>();

    private static final ThreadLocal<CrawlerContext> CRAWLER_CONTEXT_THREAD_LOCAL = new ThreadLocal<>();

    private final MavenExecutionResult result;

    private final RepositorySystemSession repositorySystemSession;

    private final Properties executionProperties;

    private ThreadLocal<MavenProject> currentProject = new ThreadLocal<>();

    /**
     * These projects have already been topologically sorted in the {@link org.apache.maven.Maven} component before

    return requireNonNull(DEST_TL.get());
  }

  /**
   * A thread-local destination buffer to keep us from creating new buffers. The starting size is
   * 1024 characters. If we grow past this we don't put it back in the threadlocal, we just keep
   * going and grow as needed.
   */
  private static final ThreadLocal<char[]> DEST_TL =
      new ThreadLocal<char[]>() {

    /** Per-thread queue of events to dispatch. */
    @SuppressWarnings("ThreadLocalUsage") // Each Dispatcher needs its own state.
    private final ThreadLocal<Queue<Event>> queue =
        new ThreadLocal<Queue<Event>>() {
          @Override
          protected Queue<Event> initialValue() {
            return new ArrayDeque<>();
          }
        };

    /** Constant for Kryo serializer type. */
    protected static final String KRYO = "kryo";

    /** ThreadLocal container for Kryo instances to ensure thread safety. */
    protected final ThreadLocal<Kryo> kryoThreadLocal;

    /**
     * Constructs a new DataSerializer.
     * <p>
     * Initializes the ThreadLocal Kryo instances with appropriate configuration.

   *
   * <p>This class would certainly be simpler and easier to reason about if it were built with
   * ThreadLocal; however, ThreadLocal is not well optimized for the case where the ThreadLocal is
   * non-static, and is initialized/removed frequently - this causes churn in the Thread specific
   * hashmaps. Using a static ThreadLocal to avoid that overhead would mean that different

 */
public class ProjectBuildLogAppender implements AutoCloseable {

    private static final String KEY_PROJECT_ID = "maven.project.id";
    private static final ThreadLocal<String> PROJECT_ID = new InheritableThreadLocal<>();
    private static final ThreadLocal<String> FORKING_PROJECT_ID = new InheritableThreadLocal<>();

    public static String getProjectId() {
        return PROJECT_ID.get();
    }

  }

  private abstract static class FileFactory {

    private static final Logger logger = Logger.getLogger(FileFactory.class.getName());

    private final ThreadLocal<File> fileThreadLocal = new ThreadLocal<>();

    File createFile() throws IOException {
      File file = File.createTempFile("SinkSourceFile", "txt");
      fileThreadLocal.set(file);
      return file;
    }

   *
   * <p>This class would certainly be simpler and easier to reason about if it were built with
   * ThreadLocal; however, ThreadLocal is not well optimized for the case where the ThreadLocal is
   * non-static, and is initialized/removed frequently - this causes churn in the Thread specific
   * hashmaps. Using a static ThreadLocal to avoid that overhead would mean that different

        public void run() {}
      };

  public void testDirectExecutorServiceServiceInThreadExecution() throws Exception {
    ListeningExecutorService executor = newDirectExecutorService();
    ThreadLocal<Integer> threadLocalCount =
        new ThreadLocal<Integer>() {
          @Override
          protected Integer initialValue() {
            return 0;
          }
        };
    Runnable incrementTask =
        new Runnable() {