* is complete. It does so by using daemon threads and adding a shutdown hook to wait for their
   * completion.
   *
   * <p>This is mainly for fixed thread pools. See {@link Executors#newFixedThreadPool(int)}.
   *
   * @param executor the executor to modify to make sure it exits when the application is finished
   * @param terminationTimeout how long to wait for the executor to finish before terminating the
   *     JVM

            final int nThreads) {
        this.indexUpdateCallback = indexUpdateCallback;
        this.crawlerClientFactory = crawlerClientFactory;
        executor = newFixedThreadPool(nThreads < 1 ? 1 : nThreads);
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        maxDeleteDocumentCacheSize = fessConfig.getIndexerDataMaxDeleteCacheSizeAsInteger();

    @Test
    @DisplayName("Test concurrent session handling")
    public void testConcurrentSessionHandling() throws Exception {
        int sessionCount = 10;
        ExecutorService executor = Executors.newFixedThreadPool(5);
        CountDownLatch latch = new CountDownLatch(sessionCount);

        for (int i = 0; i < sessionCount; i++) {
            final int sessionIndex = i;
            executor.submit(() -> {

     */
    @Test
    public void testThreadSafeListenerManagement() throws Exception {
        final int numThreads = 10;
        final ExecutorService executor = Executors.newFixedThreadPool(numThreads);
        final CountDownLatch latch = new CountDownLatch(numThreads);
        final AtomicInteger callbackCount = new AtomicInteger(0);

        // Add listeners concurrently from multiple threads

        final int threadCount = 10;
        final int operationsPerThread = 100;
        final ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        final List<Long> timings = Collections.synchronizedList(new ArrayList<>());

        try {
            for (int t = 0; t < threadCount; t++) {
                executor.submit(() -> {

        int operationsPerThread = 50;
        CountDownLatch latch = new CountDownLatch(threadCount);
        AtomicInteger successCount = new AtomicInteger(0);
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {

                return info;
            }
        };

        // Execute concurrent operations
        ExecutorService executor = Executors.newFixedThreadPool(3);
        try {
            List<Future<List<FileNotifyInformation>>> futures = new ArrayList<>();

            for (int i = 0; i < 3; i++) {

        final CountDownLatch endLatch = new CountDownLatch(threadCount);
        final AtomicInteger successCount = new AtomicInteger(0);

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {

                if (logger.isDebugEnabled()) {
                    logger.debug("Initializing executor service with {} threads", numThreads);
                }
                executorService = Executors.newFixedThreadPool(numThreads);
            }
        }
    }

                    session.getProjects().size());
            // Propagate the parallel flag to the root session
            session.setParallel(threads > 1);
            this.executor = new PhasingExecutor(Executors.newFixedThreadPool(threads, new BuildThreadFactory()));

            // build initial plan
            this.plan = buildInitialPlan(taskSegments);
        }

        BuildContext() {
            this.session = null;