/** * <b>Asynchronous tasks should never access any API in Bukkit. Great care * should be taken to assure the thread-safety of asynchronous tasks.</b> * <p> * Schedules this to repeatedly run asynchronously until cancelled, * starting after the specified number of server ticks. * * @param plugin the reference to the plugin scheduling task * @param delay the ticks to wait before running the task for the first * time * @param period the ticks to wait between runs * @return a BukkitTask that contains the id number * @throws IllegalArgumentException if plugin is null * @throws IllegalStateException if this was already scheduled * @see BukkitScheduler#runTaskTimerAsynchronously(Plugin, Runnable, long, * long) */ public synchronized BukkitTask runTaskTimerAsynchronously(Plugin plugin, long delay, long period) throws IllegalArgumentException, IllegalStateException { checkState(); return setupId(Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, (Runnable) this, delay, period)); }
public void start() { if (this.repeater != null) { return; } this.repeater = Bukkit.getScheduler().runTaskTimerAsynchronously(FunnyGuilds.getInstance(), this, 100, 20); }
@Override public void scheduleAsyncRep(Runnable rn, long l1, long l2) { Bukkit.getScheduler().runTaskTimerAsynchronously((JavaPlugin) getPlugin(), rn, l1, l2); }
CustomLogger() { //ensure log folder exists File logFolder = new File(this.logFolderPath); logFolder.mkdirs(); //delete any outdated log files immediately this.DeleteExpiredLogs(); //unless disabled, schedule recurring tasks int daysToKeepLogs = GriefPrevention.instance.config_logs_daysToKeep; if(daysToKeepLogs > 0) { BukkitScheduler scheduler = GriefPrevention.instance.getServer().getScheduler(); final long ticksPerSecond = 20L; final long ticksPerDay = ticksPerSecond * 60 * 60 * 24; scheduler.runTaskTimerAsynchronously(GriefPrevention.instance, new EntryWriter(), this.secondsBetweenWrites * ticksPerSecond, this.secondsBetweenWrites * ticksPerSecond); scheduler.runTaskTimerAsynchronously(GriefPrevention.instance, new ExpiredLogRemover(), ticksPerDay, ticksPerDay); } }
@SuppressWarnings("deprecation") private void runPlayerHeadGetter() { plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, () -> { synchronized(names) { Iterator<Entry<String, PanelItem>> it = names.entrySet().iterator(); if (it.hasNext()) { Entry<String, PanelItem> en = it.next(); ItemStack playerSkull = new ItemStack(Material.PLAYER_HEAD, 1); SkullMeta meta = (SkullMeta) playerSkull.getItemMeta(); meta.setOwner(en.getKey()); playerSkull.setItemMeta(meta); // Save in cache cachedHeads.put(en.getKey(), playerSkull); // Tell requesters the head came in if (headRequesters.containsKey(en.getKey())) { for (HeadRequester req : headRequesters.get(en.getKey())) { en.getValue().setHead(playerSkull.clone()); plugin.getServer().getScheduler().runTask(plugin, () -> req.setHead(en.getValue())); } } it.remove(); } } }, 0L, 20L); }
/** * Schedules the pending queue on save frequency * * @return */ public BukkitTask saverScheduler() { return Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, () -> processQueue(), 0, 20L * plugin.getSettingsManager().getSaveFrequency()); }
/** * <b>Asynchronous tasks should never access any API in Bukkit. Great care * should be taken to assure the thread-safety of asynchronous tasks.</b> * <p> * Schedules this to repeatedly run asynchronously until cancelled, * starting after the specified number of server ticks. * * @param plugin the reference to the plugin scheduling task * @param delay the ticks to wait before running the task for the first * time * @param period the ticks to wait between runs * @return a BukkitTask that contains the id number * @throws IllegalArgumentException if plugin is null * @throws IllegalStateException if this was already scheduled * @see BukkitScheduler#runTaskTimerAsynchronously(Plugin, Runnable, long, * long) */ public synchronized BukkitTask runTaskTimerAsynchronously(Plugin plugin, long delay, long period) throws IllegalArgumentException, IllegalStateException { checkState(); return setupId(Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, (Runnable) this, delay, period)); }
public static void init() { if (TabooLibSettings.load()) { connect(); Bukkit.getScheduler().runTaskTimerAsynchronously(TabooLib.instance(), TabooLibClient::reconnect, 0, 100); } else { TLocale.sendToConsole("COMMUNICATION.FAILED-LOAD-SETTINGS", TabooLibSettings.getThrowable().toString()); } }
asyncCachedRequestsSenderTask = Bukkit.getScheduler().runTaskTimerAsynchronously(advancedAchievements, asyncCachedRequestsSender, configPooledRequestsTaskInterval * 40L, configPooledRequestsTaskInterval * 20L);
@Override public ScheduledVotifierTask repeatOnPool(Runnable runnable, int delay, int repeat, TimeUnit unit) { return new BukkitTaskWrapper(plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, runnable, toTicks(delay, unit), toTicks(repeat, unit))); }
task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
public RedstoneCounter() { plg.getServer().getScheduler().runTaskTimerAsynchronously(plg, new Runnable() { @Override public void run() {
public void start() { if (FunnyGuilds.getInstance().isDisabling()) { return; } if (this.task != null) { return; } FunnyGuilds funnyGuilds = FunnyGuilds.getInstance(); ConcurrencyManager concurrencyManager = funnyGuilds.getConcurrencyManager(); long interval = this.getSettings().dataInterval * 60 * 20; DataSaveRequest saveRequest = new DataSaveRequest(); this.task = Bukkit.getScheduler().runTaskTimerAsynchronously(funnyGuilds, () -> concurrencyManager.postRequests(saveRequest), interval, interval); }
public HighfrequencyRedstoneCleaner() { plg.getServer().getPluginManager().registerEvents(this, plg); plg.getServer().getScheduler().runTaskTimerAsynchronously(plg, new Runnable() { @Override public void run() { if (cm.redstoneAsyncCheck) { asyncRestoneRecord.clear(); } } }, cm.redstoneCheckInterval * 20L, cm.redstoneCheckInterval * 20L); plg.getServer().getScheduler().runTaskTimer(plg, new Runnable() { @Override public void run() { if (!cm.redstoneAsyncCheck) { syncRestoneRecord.clear(); } } }, cm.redstoneCheckInterval * 20L, cm.redstoneCheckInterval * 20L); }
case REPEATING: if (effect.isAsynchronous()) { task = s.runTaskTimerAsynchronously(owningPlugin, effect, effect.getDelay(), effect.getPeriod()); } else { task = s.runTaskTimer(owningPlugin, effect, effect.getDelay(), effect.getPeriod());
private void setupMonitoringDatabase() { try { String host = getConfig().getString("host"); int port = getConfig().getInt("port"); String database = getConfig().getString("database"); boolean usessl = getConfig().getBoolean("usessl"); String username = getConfig().getString("username"); String password = getConfig().getString("password"); String tablePrefix = getConfig().getString("tablePrefix"); Storage storage = new Storage(getLogger(), host, port, database, usessl, username, password, tablePrefix); storage.createTables(); BukkitScheduler scheduler = getServer().getScheduler(); scheduler.runTaskTimerAsynchronously(this, new TPSSaveTask(tpsHistoryTask, storage), 20L, getConfig().getInt("tps-save-interval") * 20L); //this can run async because it runs independently from the main thread scheduler.runTaskTimerAsynchronously(this, new MonitorSaveTask(this, storage), 20L,getConfig().getInt("monitor-save-interval") * 20L); scheduler.runTaskTimerAsynchronously(this, new NativeSaveTask(this, storage), 20L,getConfig().getInt("native-save-interval") * 20L); } catch (SQLException sqlEx) { getLogger().log(Level.SEVERE, "Failed to setup monitoring database", sqlEx); } }
getServer().getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
@Override public int schedule(Runnable entry, long firstStart, long repeating, boolean async) { if (!async) { if (repeating == 0) { return ((BukkitLoader) getCaller().getLoader()).getServer().getScheduler().runTaskLater(((BukkitLoader) getCaller().getLoader()), entry, firstStart * TICK_LENGTH).getTaskId(); } else { return ((BukkitLoader) getCaller().getLoader()).getServer().getScheduler().scheduleSyncRepeatingTask(((BukkitLoader) getCaller().getLoader()), entry, firstStart * TICK_LENGTH, repeating * TICK_LENGTH); } } else { if (repeating == 0) { return ((BukkitLoader) getCaller().getLoader()).getServer().getScheduler().runTaskLaterAsynchronously(((BukkitLoader) getCaller().getLoader()), entry, firstStart * TICK_LENGTH).getTaskId(); } else { return ((BukkitLoader) getCaller().getLoader()).getServer().getScheduler().runTaskTimerAsynchronously(((BukkitLoader) getCaller().getLoader()), entry, firstStart * TICK_LENGTH, repeating * TICK_LENGTH).getTaskId(); } } }