Stop a scheduled ScheduledExecutorService

Question

. 。 Answers to this question are eligible for a +50 reputation bounty. coderatcloud9 is looking for an . 。

ScheduledExecutorService is still running after calling its shutdown methos from class's shutdown method below.

I was not expecting to see perioudRun's call after shutdown Running the method shutdown Running the method periodicRun-

What should I do ensure, the schedule run is cancelled ?

class test {

    private final ScheduledExecutorService scheduler =
            Executors.newScheduledThreadPool(1);

test() {
        

        scheduler.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                funcA("periodicRun-");
            }
        }, 15, 15, TimeUnit.SECONDS);
    }

private void funcA(String path) {
LOGGER.info("Running the method " + path)
}
public void shutdown()  {
        long startTimeMs = System.currentTimeMillis();
        scheduler.shutdown(); // Disable new tasks from being submitted

        try {
            // Wait a while for existing tasks to terminate
            if (!scheduler.awaitTermination(initialTerminationSeconds, TimeUnit.SECONDS)) {
                scheduler.shutdownNow(); // Cancel currently executing tasks
                // Wait a while for tasks to respond to being cancelled
                scheduler.awaitTermination(retryTerminationSeconds, 
            }
        } catch (InterruptedException ie) {
            // (Re-)Cancel if current thread also interrupted
            scheduler.shutdownNow();
            // Preserve interrupt status
            Thread.currentThread().interrupt();
        }
        
    }
        funcA("shutdown-");
}

}```

Answer 1

The code you provided does not compile. I made some corrections and some assumptions where it did not compile, and the following code works as expected, ie "periodicRun" is not printed after shutdown() is called:

class Test {
    
    public static void main(String[] args) {
        Test test = new Test();
        test.test(); // CALL TEST METHOD
        
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(2500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            test.shutdown(); // CALL SHUTDOWN METHOD
        });
        t.start();
    }

    private final int initialTerminationSeconds = 1;
    private final int retryTerminationSeconds = 1;
    
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    void test() {
        scheduler.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                funcA("periodicRun-");
            }
        }, 15, 15, TimeUnit.SECONDS);
    }

    private void funcA(String path) {
        System.out.println("Running the method " + path);
    }
    
    public void shutdown()  {
        long startTimeMs = System.currentTimeMillis();
        scheduler.shutdown(); // Disable new tasks from being submitted

        try {
            // Wait a while for existing tasks to terminate
            if (!scheduler.awaitTermination(initialTerminationSeconds, TimeUnit.SECONDS)) {
                scheduler.shutdownNow(); // Cancel currently executing tasks
                // Wait a while for tasks to respond to being cancelled
                scheduler.awaitTermination(retryTerminationSeconds, TimeUnit.SECONDS);
            }
        } catch (InterruptedException ie) {
            // (Re-)Cancel if current thread also interrupted
            scheduler.shutdownNow();
            // Preserve interrupt status
            Thread.currentThread().interrupt();
        }
        funcA("shutdown-");
    }
}

As this code works as expected, the problem in your code is either somewhere else or the assumptions and corrections I made to your code are incorrect.