exceptionSet.add(e);
                } finally {
                    done.set(true);
                }
            }, Thread.currentThread().getName() + "-pdf");
            task.setDaemon(isDaemonThread);
            task.start();
            task.join(timeout);
            if (!done.get()) {
                for (int i = 0; i < 100 && !done.get(); i++) {
                    task.interrupt();

        // Start cleanup executor for expired leases
        this.cleanupExecutor = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread t = new Thread(r, "LeaseManager-Cleanup");
            t.setDaemon(true);
            return t;
        });

        // Schedule periodic cleanup
        long cleanupInterval = context.getConfig().getLeaseTimeout();
        if (cleanupInterval <= 0) {

                log.debug("Connecting " + this.name);
            }

            this.state = 1;
            this.te = null;

            final Thread t = new Thread(this, this.name);
            t.setDaemon(true);
            this.thread = t;

            synchronized (this.thread) {
                t.start();
                t.wait(timeout); /* wait for doConnect */

                st = this.state;

        this.remoteInterfaces = new ArrayList<>();
        this.scheduler = Executors.newScheduledThreadPool(2, r -> {
            Thread t = new Thread(r, "MultiChannelScheduler");
            t.setDaemon(true);
            return t;
        });
        this.loadBalancer = new ChannelLoadBalancer(this);
        this.failover = new ChannelFailover(this);

        Configuration config = context.getConfig();

            dataCrawlingThread.setPriority(crawlerPriority);
            dataCrawlingThread.setName(sid);
            dataCrawlingThread.setDaemon(true);

            dataCrawlingThreadList.add(dataCrawlingThread);
            dataCrawlingThreadStatusList.add(Constants.READY);

        }

        int startedCrawlerNum = 0;

        indexUpdater.setName("IndexUpdater");
        indexUpdater.setPriority(indexUpdaterPriority);
        indexUpdater.setSessionIdList(sessionIdList);
        indexUpdater.setDaemon(true);
        indexUpdater.setCrawlerList(crawlerList);
        getAvailableBoostDocumentRuleList().forEach(rule -> {
            indexUpdater.addDocBoostMatcher(new org.codelibs.fess.indexer.DocBoostMatcher(rule));

        @Override
        public Thread newThread(Runnable r) {
            Thread newThread = new Thread(GROUP, r, "resolver-" + THREAD_NUMBER.getAndIncrement());
            newThread.setDaemon(true);
            newThread.setContextClassLoader(null);
            return newThread;
        }
    }

    private class ResolveTask implements Runnable {

        private final ClassLoader classLoader;

            java.util.concurrent.Executors.newSingleThreadScheduledExecutor(r -> {
                Thread t = new Thread(r, "SecureKeyManager-Rotation");
                t.setDaemon(true);
                return t;
            });
    private java.util.concurrent.ScheduledFuture<?> rotationTask;

    /**
     * Configure key rotation interval
     *

    private final ExecutorService logExecutor = Executors.newSingleThreadExecutor(r -> {
        Thread t = new Thread(r, "SecurityAuditLogger");
        t.setDaemon(true);
        return t;
    });
    private volatile boolean asyncLogging = true;
    private volatile boolean shutdown = false;

    // Event statistics

    // Advanced health monitoring
    private final ScheduledExecutorService healthCheckExecutor = Executors.newSingleThreadScheduledExecutor(r -> {
        Thread t = new Thread(r, "SmbTransportPool-HealthCheck");
        t.setDaemon(true);
        return t;
    });
    private ScheduledFuture<?> healthCheckTask;
    private volatile boolean healthCheckingEnabled = true;

    // Health check metrics