How to elegantly close ExecutorService in Asynchronous

void shutdown()

ExecutorService executor = (4);
// Submit multiple tasks...();

try {
    if (!(60, )) {
        ("There are still tasks that have not been completed within the time limit");
    }
} catch (InterruptedException e) {
    ().interrupt();
}

List<Runnable> shutdownNow()

();
// Typical return value processingList<Runnable> unprocessed = ();
if (!()) {
    ("throw away{}Unexecuted tasks", ());
}

class InterruptibleTask implements Runnable {
    public void run() {
        while (!().isInterrupted()) {
            // Perform interruptible operations            try {
                (1000);
            } catch (InterruptedException e) {
                ().interrupt(); // Reset interrupt status                break;
            }
        }
    }
}

public class GracefulShutdownExample {
    // Define timeout and time units (30 seconds)    private static final int TIMEOUT = 30;
    private static final TimeUnit UNIT = ;

    // Method to execute tasks, receive a task list and submit it to the thread pool for execution    public void executeTasks(List<Runnable> tasks) {
        // Create a fixed-size thread pool with the size of the number of processor cores available in the system        ExecutorService executor = (().availableProcessors());
        
        try {
            // Submit each task in the task list to the thread pool            (executor::submit);
        } finally {
            // After all tasks are submitted, disable the thread pool to receive new tasks and start elegantly closing the thread pool            (); // No new tasks are submitted            try {
                // Wait for the task in the thread pool to complete within the specified timeout. If the timeout does not complete, force the thread pool to be closed                if (!(TIMEOUT, UNIT)) {
                    // If it fails to complete within the timeout, call shutdownNow() to force terminate all active tasks                    List<Runnable> unfinished = ();
                    // Handle unfinished tasks such as logging or resubmitting                    handleUnfinishedTasks(unfinished);
                }
            } catch (InterruptedException e) {
                // If it is interrupted while waiting for termination, restore the interrupt state and force the thread pool to be closed                ().interrupt();
                ();
            }
        }
    }
    
    // Methods to deal with unfinished tasks, here we print the number of unfinished tasks    private void handleUnfinishedTasks(List<Runnable> tasks) {
        // If there are unfinished tasks, print the number of tasks and perform additional processing        if (!()) {
            ("Number of tasks not completed: " + ());
            // You can record logs here, requeuing unfinished tasks, etc.        }
    }

}

public class EnhancedExecutorManager {
    // Define thread pool object    private final ExecutorService executor;
    // Define timeout and unit    private final long timeout;
    private final TimeUnit unit;

    // Constructor, initialize the thread pool and set the timeout and unit    public EnhancedExecutorManager(int corePoolSize, long timeout, TimeUnit unit) {
        // Create a thread pool with corePoolSize and maximum pool size corePoolSize * 2, maximum idle time 60 seconds         = new ThreadPoolExecutor(
            corePoolSize,                             // Core thread pool size            corePoolSize * 2,                         // Maximum thread pool size            60L, ,                    // Living time of idle thread            new LinkedBlockingQueue<>(1000),          // Use a queue with capacity of 1000 to cache tasks            new CustomThreadFactory(),                // Custom thread factory            new () // When the task cannot be submitted, the caller thread executes the task        );
         = timeout;                     // Set the timeout time         = unit;                           // Set timeout unit    }
    
    // How to close thread pool elegantly    public void shutdown() {
        (); // First try to close the thread pool normally and no longer receive new tasks        
        try {
            // Forced shutdown if the thread pool fails to terminate within the specified timeout            if (!(timeout, unit)) {
                ("Forced termination of thread pool...");
                // Force stop all executing tasks and return to the discarded task list                List<Runnable> droppedTasks = ();
                ("Number of discarded tasks: " + ());
            }
        } catch (InterruptedException e) {
            // If the thread pool shutdown operation is interrupted during waiting, force shutdown and restore the interrupt state immediately            ();
            ().interrupt();
        }
    }
    
    // Custom thread factory class for creating threads    private static class CustomThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1); // Thread pool number, used to generate thread name        private final ThreadGroup group; // Thread group        private final AtomicInteger threadNumber = new AtomicInteger(1); // Thread number        private final String namePrefix; // Thread name prefix    
        CustomThreadFactory() {
            // Get the security manager of the current system. If not, use the thread group of the current thread            SecurityManager s = ();
            group = (s != null) ? () :
                                  ().getThreadGroup();
            // Set the prefix of the thread pool name            namePrefix = "pool-" +
                          () + // increment the thread pool number                         "-thread-";
        }
    
        // Method to create a new thread        public Thread newThread(Runnable r) {
            // Create a new thread, the thread group, name and priority are all set            Thread t = new Thread(group, r,
                                  namePrefix + (),
                                  0); // Default priority and daemon settings            // If the thread is a daemon thread, set it to a non-daemon thread            if (())
                (false);
            // Set thread priority to default            if (() != Thread.NORM_PRIORITY)
                (Thread.NORM_PRIORITY);
            return t; // Return to the newly created thread        }
    }
}

public class TieredShutdownManager { 
    // Define a list of thread pools with three priority levels: high priority, medium priority, low priority    private final List<ExecutorService> highPriority; 
    private final List<ExecutorService> normalPriority; 
    private final List<ExecutorService> lowPriority; 
  
    // Public method is used to elegantly close all thread pools    public void gracefulShutdown() { 
        // Close high, medium and low priority thread pools in turn        shutdownTier(highPriority, 10, ); 
        shutdownTier(normalPriority, 30, ); 
        shutdownTier(lowPriority, 60, ); 
    } 
  
    // Private method for elegantly closing thread pools with specified priority    private void shutdownTier(List<ExecutorService> tier, long timeout, TimeUnit unit) { 
        // Perform a shutdown operation on the specified thread pool list        (ExecutorService::shutdown); 
  
        // Perform an operation waiting for termination on each thread pool, specifying the timeout        (executor -> { 
            try { 
                // If the thread pool does not terminate within the timeout time, shutdownNow is called to force close                if (!(timeout, unit)) { 
                    (); 
                } 
            } catch (InterruptedException e) { 
                // If the thread is interrupted while waiting for termination, restore the interrupt state and force the thread pool to be closed                ().interrupt(); 
                (); 
            } 
        }); 
    } 
}

ThreadPoolExecutor executor = (ThreadPoolExecutor) service;
("Number of active threads: " + ());
("Number of tasks completed: " + ());
("Quote Size: " + ().size());

(newSize);
(newMaxSize);