bukkit
Programmazione dello Scheduler

Sintassi

• 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);

Osservazioni

Scheduler Attività ricorrente

Il tempo per le attività dell'Utilità di pianificazione viene misurato in zecche. In condizioni normali, ci sono 20 tick al secondo.

Le attività pianificate con .scheduleSyncRepeatingTask verranno eseguite nella discussione principale

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

Pianificazione attività ritardata

Il tempo per le attività dell'Utilità di pianificazione viene misurato in zecche. In condizioni normali, ci sono 20 tick al secondo.

Le attività pianificate con .scheduleSyncDelayedTask verranno eseguite nella discussione principale

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

Esecuzione di attività in modo asincrono

È possibile eseguire il codice in modo asincrono dal thread principale utilizzando runTaskAsynchronously . Ciò è utile per eseguire operazioni matematiche o di database intensive, in quanto impediscono il blocco del thread principale (e il server in ritardo).

Pochi metodi API Bukkit sono sicuri per i thread, quindi molti causeranno un comportamento indefinito se chiamati in modo asincrono dal thread principale.

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
    }
});

Esecuzione di attività sul thread principale

È inoltre possibile eseguire il codice in modo sincrono con il thread principale utilizzando runTask . Ciò è utile quando si desidera chiamare i metodi API Bukkit dopo aver eseguito il codice in modo asincrono dal thread principale.

Il codice richiamato all'interno di questo Runnable verrà eseguito sul thread principale, rendendo più sicuro chiamare i metodi API Bukkit.

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
    }
});

Esecuzione di un BukkitRunnable

BukkitRunnable è un Runnable trovato in Bukkit. È possibile pianificare un'attività direttamente da un BukkitRunnable e anche cancellarla dal suo interno.

Importante: il tempo delle attività è misurato in zecche. Un secondo ha 20 tick.

Non-RepeatingTask:

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.

Ripetizione attività:

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.

Esecuzione del codice sicuro del thread da un'attività asincrona

A volte è necessario eseguire il codice sincrono da un'attività asincrona. Per fare ciò, è sufficiente pianificare un'attività sincrona all'interno del blocco asincrono.

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);