bukkit => Planner programmeren

Syntaxis

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

Opmerkingen

Weinig Bukkit API-methoden zijn thread-safe en kunnen asynchroon worden aangeroepen. Om deze reden moeten Bukkit API-methoden alleen , op enkele uitzonderingen na, op de hoofdthread worden uitgevoerd.

Code run binnenkant van scheduleSync werkwijzen, alsmede de runTask methode wordt uitgevoerd op de draad.

Code die binnen runTaskAsynchronously wordt uitgevoerd, wordt asynchroon uitgevoerd vanaf de runTaskAsynchronously . Asynchrone methoden zijn erg handig voor het uitvoeren van grote wiskunde- of databasebewerkingen zonder de server te vertragen, maar zullen ongedefinieerd gedrag veroorzaken als ze worden gebruikt om Bukkit API-methoden aan te roepen. Om deze reden moeten Bukkit API-methoden die na de asynchrone code moeten worden uitgevoerd, altijd in een runTask methode worden geplaatst.

Planner Herhalende taak

De tijd voor Scheduler-taken wordt gemeten in teken. Onder normale omstandigheden zijn er 20 teken per seconde.

Taken die zijn gepland met .scheduleSyncRepeatingTask worden uitgevoerd op de .scheduleSyncRepeatingTask

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

Planner Vertraagde taak

De tijd voor Scheduler-taken wordt gemeten in teken. Onder normale omstandigheden zijn er 20 teken per seconde.

Taken die zijn gepland met .scheduleSyncDelayedTask worden uitgevoerd op de .scheduleSyncDelayedTask

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

Taken asynchroon uitvoeren

U kunt code asynchroon uitvoeren vanaf de runTaskAsynchronously met behulp van runTaskAsynchronously . Dit is handig voor het uitvoeren van intensieve wis- of databasebewerkingen, omdat hierdoor wordt voorkomen dat de hoofdthread bevriest (en de server achterblijft).

Weinig Bukkit API-methoden zijn thread-safe, dus veel zullen ongedefinieerd gedrag veroorzaken als ze asynchroon vanuit de hoofdthread worden aangeroepen.

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

Taken uitvoeren op de hoofdthread

U kunt ook code synchroon laten lopen met de runTask met behulp van runTask . Dit is handig als u Bukkit API-methoden wilt aanroepen nadat u asynchroon code vanaf de hoofdthread hebt uitgevoerd.

Code die in deze Runnable wordt genoemd, wordt op de hoofdthread uitgevoerd, waardoor het veilig is om Bukkit API-methoden aan te roepen.

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

Een BukkitRunnable uitvoeren

De BukkitRunnable is een Runnable gevonden in Bukkit. Het is mogelijk om een taak rechtstreeks vanuit een BukkitRunnable te plannen en deze ook vanuit zichzelf te annuleren.

Belangrijk: de tijd op de taken wordt gemeten in teken. Een seconde heeft 20 teken.

Niet-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.

Taak herhalen:

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 Safe Code van een asynchrone taak uitvoeren

Soms moet u synchrone code uitvoeren vanuit een asynchrone taak. Om dit te doen, plant u eenvoudig een synchrone taak vanuit het asynchrone blok.

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

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

bukkit
Planner programmeren

Zoeken…