bukkit
Scheduler-Programmierung

Syntax

• Bukkit.getScheduler().scheduleSyncRepeatingTask(Plugin plugin, Runnable task, int initialDelay, int repeatingDelay)
• Bukkit.getScheduler().scheduleSyncDelayedTask(Plugin plugin, Runnable task, int initialDelay)
• Bukkit.getScheduler().runTaskAsynchronously(Plugin plugin, Runnable task)
• Bukkit.getScheduler().runTask(Plugin plugin, Runnable task)
• new BukkitRunnable() { @Override public void run() { /* CODE */ } }.runTaskLater(Plugin plugin, long delay);
• new BukkitRunnable() { @Override public void run() { /* CODE */ } }.runTaskTimer(Plugin plugin, long initialDelay, long repeatingDelay);

Bemerkungen

Scheduler Wiederholte Aufgabe

Die Zeit für Scheduler-Aufgaben wird in Ticks gemessen. Unter normalen Bedingungen gibt es 20 Ticks pro Sekunde.

Mit .scheduleSyncRepeatingTask geplante Aufgaben werden im .scheduleSyncRepeatingTask ausgeführt

Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, new Runnable() {
    @Override
    public void run() {
        Bukkit.broadcastMessage("This message is shown immediately and then repeated every second");
    }
}, 0L, 20L); //0 Tick initial delay, 20 Tick (1 Second) between repeats

Scheduler verzögerte Aufgabe

Die Zeit für Scheduler-Aufgaben wird in Ticks gemessen. Unter normalen Bedingungen gibt es 20 Ticks pro Sekunde.

Mit .scheduleSyncDelayedTask geplante Aufgaben werden im .scheduleSyncDelayedTask ausgeführt

Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
    @Override
    public void run() {
        Bukkit.broadcastMessage("This message is shown after one second");
    }
}, 20L); //20 Tick (1 Second) delay before run() is called

Aufgaben asynchron ausführen

Sie können Code asynchron aus dem Hauptthread mithilfe von runTaskAsynchronously . Dies ist nützlich für intensive mathematische oder Datenbankoperationen, da sie verhindern, dass der Haupt-Thread einfriert (und der Server verzögert).

Nur wenige Bukkit-API-Methoden sind Thread-sicher. Daher führen viele zu undefiniertem Verhalten, wenn sie asynchron vom Haupt-Thread aufgerufen werden.

Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
    @Override
    public void run() {
        Bukkit.getLogger().info("This message was printed to the console asynchronously");
        //Bukkit.broadcastMessage is not thread-safe
    }
});

Ausführen von Aufgaben im Hauptthread

Sie können Code auch mithilfe von runTask synchron mit dem Haupt-Thread runTask . Dies ist nützlich, wenn Sie Bukkit-API-Methoden aufrufen möchten, nachdem der Code asynchron vom Hauptthread ausgeführt wurde.

Code, der in diesem Runable aufgerufen wird, wird auf dem Hauptthread ausgeführt, sodass der Aufruf von Bukkit-API-Methoden sicher ist.

Bukkit.getScheduler().runTask(plugin, new Runnable() {
    @Override
    public void run() {
        Bukkit.broadcastMessage("This message is displayed to the server on the main thread");
        //Bukkit.broadcastMessage is thread-safe
    }
});

Ausführen eines BukkitRunnable

Das BukkitRunnable ist ein Runable in Bukkit. Es ist möglich, eine Aufgabe direkt von einem BukkitRunnable aus zu planen und auch von selbst abzubrechen.

Wichtig: Die Zeit für die Aufgaben wird in Ticks gemessen. Eine Sekunde hat 20 Ticks.

Nicht wiederholender Task:

JavaPlugin plugin;    //Your plugin instance    
Long timeInSeconds = 10;
Long timeInTicks = 20 * timeInSeconds;
new BukkitRunnable() {
        
    @Override
    public void run() {
        //The code inside will be executed in {timeInTicks} ticks.
        
    }
}.runTaskLater(plugin, timeInTicks);   // Your plugin instance, the time to be delayed.

Wiederholungsaufgabe:

JavaPlugin plugin;    //Your plugin instance    
Long timeInSeconds = 10;
Long timeInTicks = 20 * timeInSeconds;
new BukkitRunnable() {
        
    @Override
    public void run() {
        //The code inside will be executed in {timeInTicks} ticks.
       //After that, it'll be re-executed every {timeInTicks} ticks;
      //Task can also cancel itself from running, if you want to.

       if (boolean) {
           this.cancel();
       }
        
    }
}.runTaskTimer(plugin, timeInTicks, timeInTicks);   //Your plugin instance, 
                                                   //the time to wait until first execution,
                                                  //the time inbetween executions.

Thread-Sicherheitscode von einer asynchronen Task ausführen

Manchmal müssen Sie synchronen Code innerhalb einer asynchronen Task ausführen. Planen Sie dazu einfach eine synchrone Task innerhalb des asynchronen Blocks ein.

Bukkit.getScheduler().runTaskTimerAsynchronously(VoidFlame.getPlugin(), () -> {

    Bukkit.getScheduler().runTask(VoidFlame.getPlugin(), () -> {
        World world = Bukkit.getWorld("world");
        world.spawnEntity(new Location(world, 0, 100, 0), EntityType.PRIMED_TNT);
    });

}, 0L, 20L);