public void shutdown() {
        scheduler.shutdown();
        try {
            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }
        } catch (InterruptedException e) {
            scheduler.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Stop all change watchers
        for (String path : directoryCache.keySet()) {

        cleanupExecutor.shutdown();
        try {
            if (!cleanupExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                cleanupExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            cleanupExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Log final statistics

    public void shutdown() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    private void redistributePendingOperations(ChannelInfo failedChannel) {

            try {
                if (!cleanupExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                    cleanupExecutor.shutdownNow();
                }
            } catch (InterruptedException e) {
                cleanupExecutor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }

        // Clean up expired weak references

        healthCheckExecutor.shutdown();
        try {
            if (!healthCheckExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                healthCheckExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            healthCheckExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Close all connections without synchronization - concurrent collections are thread-safe

        log.info("Rate limiter state reset");
    }

    @Override
    public void close() {
        if (!closed.compareAndSet(false, true)) {
            return;
        }

        cleanupScheduler.shutdownNow();
        try {
            cleanupScheduler.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();

          response: Response,
        ) {
        }
      },
    )

    // This should fail the Call, but not cause an unhandled Exception bubbling up
    client.dispatcher.executorService.shutdownNow()

    val exception = callFailure.get(5, TimeUnit.SECONDS)
    assertThat(exception.message).isEqualTo("canceled due to java.lang.InterruptedException")
    assertThat(exception).isInstanceOf<IOException>()

        try {
            if (!healthCheckExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                healthCheckExecutor.shutdownNow();
            }
            if (!channelExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                channelExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

        shutdown = true;
        logExecutor.shutdown();
        try {
            if (!logExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                logExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            logExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    /**
     * Log a security event with performance optimizations
     *

            if (rotationTask != null) {
                rotationTask.cancel(false);
                rotationTask = null;
            }

            // Shutdown rotation scheduler
            rotationScheduler.shutdownNow();

            clearAllKeys();
        } finally {
            // Wipe KeyStore password
            if (keyStorePassword != null) {
                Arrays.fill(keyStorePassword, '\0');