SSH客户端库中等待Future时异步执行器的关闭处理问题

Great question—handling executor shutdown cleanly for an SSH client (especially with your mix of scheduled tasks, single-threaded readers, and a serial writer queue) is tricky but critical to avoid resource leaks and ensure connections terminate gracefully. Let’s walk through a structured approach tailored to your setup.

Core Principles to Guide Shutdown #

First, remember the golden rule for executor shutdown: stop accepting new tasks first, then let in-flight and queued tasks finish gracefully, and only force termination if necessary after a reasonable timeout. Your three executors have distinct roles, so their shutdown order and handling need to align with their dependencies.

Step 1: Shutdown the Scheduled Thread Pool (ScheduledThreadPoolExecutor) #

This executor handles short-lived tasks and timers, so it’s safe to shut down first since it doesn’t directly depend on the read/write loops:

• Call shutdown() to block new task submissions (including repeating scheduled tasks—they’ll stop after their current run).
• Wait for in-flight tasks to complete with awaitTermination(timeout, unit). Pick a timeout that makes sense for your short tasks (e.g., 10 seconds).
• If the timeout elapses, use shutdownNow() to force termination. This returns a list of unexecuted tasks—log these for debugging if needed.
• Always restore the thread’s interrupt status if awaitTermination throws InterruptedException—don’t swallow the interrupt!

Example snippet:

scheduledExecutor.shutdown();
try {
    if (!scheduledExecutor.awaitTermination(10, TimeUnit.SECONDS)) {
        List<Runnable> pendingTasks = scheduledExecutor.shutdownNow();
        log.warn("Scheduled executor forced shutdown; {} pending tasks discarded", pendingTasks.size());
    }
} catch (InterruptedException e) {
    scheduledExecutor.shutdownNow();
    Thread.currentThread().interrupt(); // Restore interrupt status
}

Step 2: Shutdown the Serial Write Executor #

This single-threaded executor acts as a message queue, so you’ll want to prioritize finishing queued write tasks (unless your business logic allows discarding them):

• First, block new write task submissions at your SSH client level (e.g., set a flag to reject new send requests).
• Call shutdown()—this lets the executor finish all queued tasks before terminating.
• Wait with a longer timeout here (e.g., 30 seconds) to account for network latency and large payloads.
• Use shutdownNow() only as a last resort: interrupting an in-progress write could leave a partial message on the wire, which might cause issues on the server side. Log any discarded queued tasks if this happens.

Example snippet:

// First, stop accepting new write requests in your client code
this.acceptingNewWrites = false;

writeExecutor.shutdown();
try {
    if (!writeExecutor.awaitTermination(30, TimeUnit.SECONDS)) {
        List<Runnable> pendingWrites = writeExecutor.shutdownNow();
        log.error("Write executor timed out; {} pending messages discarded", pendingWrites.size());
    }
} catch (InterruptedException e) {
    writeExecutor.shutdownNow();
    Thread.currentThread().interrupt();
}

Step 3: Shutdown the Single-Threaded Read Executor #

The read executor is likely running an infinite loop blocking on socket reads, so shutdown() alone won’t stop it—you need to break the blocking call:

• First, close the underlying SSH socket. This will cause the read thread’s read() call to throw an IOException, which should trigger your loop to exit gracefully.
• Then call shutdown() on the executor, followed by awaitTermination (a shorter timeout like 10 seconds works here, since closing the socket should terminate the read quickly).
• If the timeout elapses, use shutdownNow() to interrupt the thread as a fallback.

Example snippet:

// Force the read thread to exit by closing the socket
try {
    sshSocket.close();
} catch (IOException e) {
    log.error("Failed to close SSH socket during shutdown", e);
}

readExecutor.shutdown();
try {
    if (!readExecutor.awaitTermination(10, TimeUnit.SECONDS)) {
        readExecutor.shutdownNow();
        log.warn("Read executor forced to shut down");
    }
} catch (InterruptedException e) {
    readExecutor.shutdownNow();
    Thread.currentThread().interrupt();
}

Handling Future Waits During Shutdown #

If your code is waiting on Future objects (e.g., waiting for an SSH command to complete), handle these before initiating executor shutdown:

• Wait for the Future with a reasonable timeout using get(timeout, unit).
• If the timeout expires, cancel the future with cancel(true) to interrupt the underlying task.
• Always handle InterruptedException and ExecutionException properly, restoring the interrupt status if needed.

Example snippet:

try {
    // Wait for the task to complete before shutting down executors
    commandFuture.get(15, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    log.warn("Command timed out; cancelling task");
    commandFuture.cancel(true); // Interrupt the running task
} catch (InterruptedException e) {
    log.warn("Wait for command was interrupted");
    commandFuture.cancel(true);
    Thread.currentThread().interrupt(); // Restore interrupt status
} catch (ExecutionException e) {
    log.error("Command failed during execution", e.getCause());
}

Key Best Practices #

• Preserve Interrupt Status: Never swallow InterruptedException—always call Thread.currentThread().interrupt() after catching it so upstream code can handle the interrupt.
• Task Interruptibility: Ensure your read/write/scheduled tasks check for thread interrupts or handle IO exceptions gracefully. For example, your read loop should exit if Thread.currentThread().isInterrupted() is true.
• Order Matters: Shut down the scheduled pool first, then the write executor (to finish queued messages), then the read executor (after closing the socket). This avoids leaving hanging tasks that depend on terminated executors.

内容的提问来源于stack exchange，提问作者Michał Zegan