bukkit
Programmation du planificateur

Syntaxe

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

Remarques

Tâches répétitives du planificateur

L'heure des tâches du planificateur est mesurée en ticks. Dans des conditions normales, il y a 20 ticks par seconde.

Les tâches planifiées avec .scheduleSyncRepeatingTask seront exécutées sur le thread principal

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

Tâche retardée du planificateur

L'heure des tâches du planificateur est mesurée en ticks. Dans des conditions normales, il y a 20 ticks par seconde.

Les tâches planifiées avec .scheduleSyncDelayedTask seront exécutées sur le thread principal

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

Exécuter des tâches de manière asynchrone

Vous pouvez faire exécuter le code de manière asynchrone à partir du thread principal en utilisant runTaskAsynchronously . Ceci est utile pour effectuer des opérations intensives en mathématiques ou en base de données, car elles empêcheront le gel du thread principal (et le retard du serveur).

Peu de méthodes API Bukkit sont sûres pour les threads, donc beaucoup provoqueront un comportement indéfini si elles sont appelées de manière asynchrone à partir du thread principal.

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

Exécuter des tâches sur le sujet principal

Vous pouvez également faire exécuter le code de manière synchrone avec le thread principal à l'aide de runTask . Ceci est utile lorsque vous souhaitez appeler des méthodes API Bukkit après avoir exécuté le code de manière asynchrone à partir du thread principal.

Le code appelé à l'intérieur de ce Runnable sera exécuté sur le thread principal, ce qui permet d'appeler en toute sécurité les méthodes de l'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
    }
});

Lancer un BukkitRunnable

Le BukkitRunnable est un Runnable présent dans Bukkit. Il est possible de planifier une tâche directement à partir d'un BukkitRunnable, et aussi de l'annuler de l'intérieur.

Important: l'heure sur les tâches est mesurée en ticks. Une seconde a 20 ticks.

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.

Tâche répétitive:

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.

Exécution d'un code thread sécurisé à partir d'une tâche asynchrone

Parfois, vous devrez exécuter du code synchrone à partir d'une tâche asynchrone. Pour ce faire, il vous suffit de planifier une tâche synchrone depuis le bloc asynchrone.

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