// Wait for all threads to complete
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                fail("Thread interrupted: " + e.getMessage());
            }
        }

        // Verify all threads got the same instances
        for (int i = 0; i < threadCount; i++) {
            assertSame(invertibleCryptographer, invertibles[i]);

            }
        } catch (final InterruptedException e) {
            logger.warn("[LLM] Request interrupted while waiting for concurrency permit. name={}", getName());
            Thread.currentThread().interrupt();
            throw new LlmException("Request interrupted", LlmException.ERROR_TIMEOUT);
        }
    }

    /**

            });

            try {
                latch.await();
            } catch (final InterruptedException ignore) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", ignore);
                }
                exitCode.set(1);
            }
        }

        if (ComponentUtil.getFessConfig().isSuggestSearchLog()) {

        }
    }

    // Test executeSuggestCreator with interrupted exception
    @Test
    public void test_executeSuggestCreator_withInterruptedException() {
        createRequiredDirectories();
        mockProcessHelper.setThrowException(new InterruptedException("Interrupted"));

        try {
            suggestJob.executeSuggestCreator();

                if (!task.isExecuted()) {
                    task.run();
                }
            }
        } catch (final InterruptedException e) {
            logger.warn("Interrupted generating thumbnail: id={}, command={}", thumbnailId, cmdList, e);
            Thread.currentThread().interrupt();
        } catch (final Exception e) {

            executorService.awaitTermination(60, TimeUnit.SECONDS);
        } catch (final InterruptedException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Interrupted.", e);
            }
        } finally {
            executorService.shutdownNow();
        }
        return totalCount;
    }

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            fail("Thread interrupted");
        }
    }

    @Test
    public void test_genericTypeSafety_withSubclass() {
        // Test that the exception accepts RootAction subclasses

     *
     * @param crawlerThread the thread to wait for; null threads are ignored
     */
    private void joinCrawlerThread(final Thread crawlerThread) {
        if (crawlerThread != null) {
            try {
                crawlerThread.join();
            } catch (final Exception e) {
                logger.info("Interrupted crawling process: name={}", crawlerThread.getName());

        // Wait for all threads to complete
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                fail("Thread interrupted");
            }
        }

        // Verify all stores were counted
        assertEquals(1000L, callback.getDocumentSize());

        // Test commit after concurrent operations

                try {
                    thread.join();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    fail("Thread interrupted");
                }
            }

            // Verify all results are consistent
            for (String result : results) {
                assertEquals("thread-test", result);
            }