Executing tasks when a plugin is disabled

Is there a way to get all pending tasks and execute them with no delay before the plugin disables?

My reason for this is that I have a plugin that spawns items, and I have them being removed after 15 ticks, but if the plugin disables, the task that does this is cancelled. Is there any way to remove them after its task has been disabled? (The task is executed in a method, and the method is used in an external class).

As a possible solution to this as well, is there any way to make an item remove itself in 15 ticks other than a task, but perhaps through natural item despawning?

 

Drkmaster83
Use a different plugin instance?

 

I'd rather not remove them at all if it means having to use a separate plugin instance.

 

Use ScheduledExecutorService yourself, forgoing bukkit's scheduler. A copy of the class I use for this is below:

Show Spoiler Hide Spoiler

Code:java

/*
 * Copyright (C) 2013 Spencer Alderman
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <[url]http://www.gnu.org/licenses/>[/url].
 */
package com.rogue.plugintemplate.scheduler;
 
import com.rogue.plugintemplate.PluginTemplate;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
 
/**
 * Handles and schedules tasks for the plugin in a JVM-accurate time-base, as
 * opposed to depending on any other build's time system which will lag with
 * ticks
 *
 * @since 1.0.0
 * @author 1Rogue
 * @version 1.0.0
 */
public class ExecScheduler {
 
    private final PluginTemplate plugin;
    private final ScheduledExecutorService es;
    private final List<ScheduledFuture<?>> executives = new ArrayList();
 
    /**
     * {@link ExecScheduler} constructor
     *
     * @since 1.0.0
     * @version 1.0.0
     *
     * @param plugin Main {@link PluginTemplate} instance
     */
    public ExecScheduler(PluginTemplate plugin) {
        this.plugin = plugin;
        this.es = Executors.newScheduledThreadPool(10);
    }
 
    /**
     * Runs a repeating asynchronous task under {@link PluginTemplate}
     *
     * @since 1.0.0
     * @version 1.0.0
     *
     * @param r The runnable to execute
     * @param startAfter Time (in seconds) to wait before execution
     * @param delay Time (in seconds) between execution to wait
     */
    public void runAsyncTaskRepeat(Runnable r, long startAfter, long delay) {
        this.executives.add(this.es.scheduleWithFixedDelay(r, startAfter, delay, TimeUnit.SECONDS));
    }
 
    /**
     * Runs a single asynchronous task under {@link PluginTemplate}
     *
     * @since 1.0.0
     * @version 1.0.0
     *
     * @param r The runnable to execute
     * @param delay Time (in seconds) to wait before execution
     */
    public void runAsyncTask(Runnable r, long delay) {
        this.executives.add(this.es.schedule(r, delay, TimeUnit.SECONDS));
    }
 
    /**
     * Runs a {@link Callable}
     *
     * @since 1.0.0
     * @version 1.0.0
     *
     * @param c The callable to execute
     * @param delay Time (in seconds) to wait before execution
     */
    public void runCallable(Callable<?> c, long delay) {
        this.es.schedule(c, delay, TimeUnit.SECONDS);
    }
 
    /**
     * Cancels all running tasks/threads under {@link PluginTemplate}
     *
     * @since 1.0.0
     * @version 1.0.0
     */
    public void cancelAllTasks() {
        for (ScheduledFuture<?> s : this.executives) {
            s.cancel(false);
        }
    }
 
}
 

You could potentially edit this to create a wrapper for "cancelable" tasks, and then you would simply make the items non-cancelable.