for (Thread thread : threads) {
                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);

        try {
            thread.interrupt();
        } catch (final SecurityException e) {
            log.error("Security exception interrupting thread", e);
        }
    }

    private static void joinThread(final Thread thread) {
        try {
            thread.join();
        } catch (final InterruptedException e) {
            log.warn("Thread join interrupted", e);
            // Restore interrupted status

        Thread customThread = new Thread(() -> {
            try {
                latch.await();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "CustomTestThread");

        customThread.start();

        try {
            Consumer<String> searchConsumer = line -> {

    // Racy causing flaky tests
    // assertThat(taskRunner.activeQueues()).isNotEmpty()
    assertThat(taskRunnerThreads).isNotEmpty()
    Thread.sleep(100)
    for (t in taskRunnerThreads) {
      t.interrupt()
    }
    Thread.sleep(100)
    assertThat(taskRunner.activeQueues()).isEmpty()
  }

  @Test fun connectionPreWarmingHttp1() {
    taskFaker.advanceUntil(System.nanoTime())

        cleanupScheduler.shutdownNow();
        try {
            cleanupScheduler.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.warn("Interrupted while shutting down cleanup scheduler", e);
        }

        log.info("Authentication rate limiter closed");
    }

    /**
     * Per-account attempt tracking
     */

            try {
                Thread.sleep(100);
                helper.setCrawlerRunning(true);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        thread.start();

        start = System.currentTimeMillis();
        helper.checkCrawlerStatus();
        end = System.currentTimeMillis();

          withLock {
            afterRun(task, -1L, false)
          }
          if (thrown is InterruptedException) {
            Thread.currentThread().interrupt()
          } else {
            throw thrown
          }
        } finally {
          currentThread.name = oldName
        }
      }
    }

  internal fun kickCoordinator(taskQueue: TaskQueue) {

                        processLogEntry(entry);
                        returnAuditEntry(entry);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {
                    log.error("Error processing audit log entry", e);
                }
            }
        });
    }

    /**

                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    private void redistributePendingOperations(ChannelInfo failedChannel) {
        // Get pending operations from failed channel

                cleanupExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            cleanupExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Log final statistics
        log.info("ResourceManager shutdown complete. Total allocated: {}, released: {}, leaks: {}, force cleaned: {}", totalAllocated.get(),