1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
package org.bukkit.scheduler;
import org.bukkit.plugin.Plugin;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.List;
public interface BukkitScheduler {
/**
* Schedules a once off task to occur after a delay
* This task will be executed by the main server thread
*
* @param plugin Plugin that owns the task
* @param task Task to be executed
* @param delay Delay in server ticks before executing task
* @return Task id number (-1 if scheduling failed)
*/
public int scheduleSyncDelayedTask(Plugin plugin, Runnable task, long delay);
/**
* Schedules a once off task to occur as soon as possible
* This task will be executed by the main server thread
*
* @param plugin Plugin that owns the task
* @param task Task to be executed
* @return Task id number (-1 if scheduling failed)
*/
public int scheduleSyncDelayedTask(Plugin plugin, Runnable task);
/**
* Schedules a repeating task
* This task will be executed by the main server thread
*
* @param plugin Plugin that owns the task
* @param task Task to be executed
* @param delay Delay in server ticks before executing first repeat
* @param period Period in server ticks of the task
* @return Task id number (-1 if scheduling failed)
*/
public int scheduleSyncRepeatingTask(Plugin plugin, Runnable task, long delay, long period);
/**
* Schedules a once off task to occur after a delay
* This task will be executed by a thread managed by the scheduler
*
* @param plugin Plugin that owns the task
* @param task Task to be executed
* @param delay Delay in server ticks before executing task
* @return Task id number (-1 if scheduling failed)
*/
public int scheduleAsyncDelayedTask(Plugin plugin, Runnable task, long delay);
/**
* Schedules a once off task to occur as soon as possible
* This task will be executed by a thread managed by the scheduler
*
* @param plugin Plugin that owns the task
* @param task Task to be executed
* @return Task id number (-1 if scheduling failed)
*/
public int scheduleAsyncDelayedTask(Plugin plugin, Runnable task);
/**
* Schedules a repeating task
* This task will be executed by a thread managed by the scheduler
*
* @param plugin Plugin that owns the task
* @param task Task to be executed
* @param delay Delay in server ticks before executing first repeat
* @param period Period in server ticks of the task
* @return Task id number (-1 if scheduling failed)
*/
public int scheduleAsyncRepeatingTask(Plugin plugin, Runnable task, long delay, long period);
/**
* Calls a method on the main thread and returns a Future object
* This task will be executed by the main server thread
* <p />
* Note: The Future.get() methods must NOT be called from the main thread
* Note2: There is at least an average of 10ms latency until the isDone() method returns true
*
* @param <T> The callable's return type
* @param plugin Plugin that owns the task
* @param task Task to be executed
* @return Future Future object related to the task
*/
public <T> Future<T> callSyncMethod(Plugin plugin, Callable<T> task);
/**
* Removes task from scheduler
*
* @param taskId Id number of task to be removed
*/
public void cancelTask(int taskId);
/**
* Removes all tasks associated with a particular plugin from the scheduler
*
* @param plugin Owner of tasks to be removed
*/
public void cancelTasks(Plugin plugin);
/**
* Removes all tasks from the scheduler
*/
public void cancelAllTasks();
/**
* Check if the task currently running.
* <p />
* A repeating task might not be running currently, but will be running in the future.
* A task that has finished, and does not repeat, will not be running ever again.
* <p />
* Explicitly, a task is running if there exists a thread for it, and that thread is alive.
*
* @param taskId The task to check.
* <p />
* @return If the task is currently running.
*/
public boolean isCurrentlyRunning(int taskId);
/**
* Check if the task queued to be run later.
* <p />
* If a repeating task is currently running, it might not be queued now but could be in the future.
* A task that is not queued, and not running, will not be queued again.
*
* @param taskId The task to check.
* <p />
* @return If the task is queued to be run.
*/
public boolean isQueued(int taskId);
/**
* Returns a list of all active workers.
* <p />
* This list contains asynch tasks that are being executed by separate threads.
*
* @return Active workers
*/
public List<BukkitWorker> getActiveWorkers();
/**
* Returns a list of all pending tasks. The ordering of the tasks is not related to their order of execution.
*
* @return Active workers
*/
public List<BukkitTask> getPendingTasks();
}
|