A Java timer is a mechanism provided by the Java programming language to execute a given task within a predetermined time interval. It allows you to create a large number of cron tasks for some important application needs, such as automated backups, logging, data cleaning, etc. In this article, we will delve into the principle of Java timer implementation and how to use Java timer to implement task scheduling. This article will explain the implementation principle of java timer in detail from the following aspects:
1. Basic concept of timer
Before understanding the implementation principle of Java timers, we need to understand what a timer is. A timer is a timer that calculates the time difference between two points in time. In programming, a timer is a timer object that is used to calculate time and also provides a mechanism for timing tasks. The timer can specify an interval time, when the time is up, the timer will trigger an event, and the preset operation can be performed. Timers are usually used to implement task scheduling, such as periodic tasks, delayed tasks, etc.
2. Implementation principle of timer
The implementation principle of the Java timer is based on the time wheel algorithm. The time wheel algorithm is an efficient event scheduling algorithm, which can put a large number of different types of tasks into a timer and perform polling according to a predetermined time period. When a task is polled, the timer will take the task out of the queue and execute it, and then put the task back into the corresponding round.
The Java Time Wheel Algorithm (Time Wheel Algorithm) is an efficient way to implement timers. It manages and triggers a large number of timed tasks by dividing the time wheel into multiple scales, each of which represents a time period. In Java, the time wheel algorithm is mainly used in NIO network programming, scheduling tasks and other occasions.
The core idea of the time wheel algorithm is to put all tasks to be executed into buckets within a fixed time interval, and the time wheel rotates continuously. When the pointer of the time wheel points to a certain bucket, all tasks in the bucket can be executed.
The following are the specific implementation steps of the time wheel algorithm:
1. Create a time wheel
First, a time wheel needs to be created, which consists of multiple ticks, each tick representing a period of time. For example, if we divide the time wheel into 60 ticks, each tick represents 1 second, then the period of the entire time wheel is 60 seconds.
2. Create bucket
Each tick has a bucket, which is used to store tasks that need to be executed during that time period.
3. Add task
When it is necessary to add a timed task, calculate which scale bucket the task should be placed in, and put the task into the corresponding bucket.
4. Start the time wheel
After the time wheel is started, the time wheel will run in a continuous loop, moving the pointer forward by one scale each time it loops, and executing all tasks in the scale bucket.
5. Delete task
When a scheduled task is completed or canceled, the task needs to be deleted from the corresponding bucket.
The following is a code sample of the Java Timewheel Algorithm:
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
/**
* Timer task
*/
class TimeTask {<!-- -->
private String name; // task name
private long delay; // delay time
private TimerTask task; // task object
public TimeTask(String name, long delay) {<!-- -->
this.name = name;
this. delay = delay;
this.task = new TimerTask() {<!-- -->
@Override
public void run() {<!-- -->
System.out.println("Task " + TimeTask.this.name + " executed");
}
};
}
public TimerTask getTask() {<!-- -->
return task;
}
public long getDelay() {<!-- -->
return delay;
}
}
/**
* time wheel
*/
class TimeWheel {<!-- -->
private int size; // time wheel size (number of ticks)
private List<List<TimeTask>> buckets; // bucket list
private Timer timer; // timer
private int currentIndex = 0; // current pointer position
public TimeWheel(int size) {<!-- -->
this. size = size;
this. buckets = new ArrayList<>();
for (int i = 0; i < size; i ++ ) {<!-- -->
buckets.add(new ArrayList<>());
}
this.timer = new Timer();
}
/**
* Add tasks
*
* @param task the task to add
*/
public void addTask(TimeTask task) {<!-- -->
int index = (currentIndex + (int)(task. getDelay() / 1000)) % size;
buckets.get(index).add(task);
}
/**
* delete task
*
* @param task the task to delete
*/
public void removeTask(TimeTask task) {<!-- -->
for (List<TimeTask> bucket : buckets) {<!-- -->
bucket. removeIf(t -> t == task);
}
}
/**
* Start time wheel
*/
public void start() {<!-- -->
timer.schedule(new TimerTask() {<!-- -->
@Override
public void run() {<!-- -->
List<TimeTask> bucket = buckets. get(currentIndex);
for (TimeTask task : bucket) {<!-- -->
task. getTask(). run();
}
bucket. clear();
currentIndex = (currentIndex + 1) % size;
}
}, 0, 1000);
}
}
/**
* Test class
*/
public class TimeWheelTest {<!-- -->
public static void main(String[] args) {<!-- -->
TimeWheel timeWheel = new TimeWheel(60);
TimeTask task1 = new TimeTask("Task 1", 5 * 1000);
TimeTask task2 = new TimeTask("Task 2", 10 * 1000);
TimeTask task3 = new TimeTask("Task 3", 15 * 1000);
timeWheel. addTask(task1);
timeWheel. addTask(task2);
timeWheel. addTask(task3);
timeWheel. start();
try {<!-- -->
// wait 20 seconds and cancel task 2
Thread. sleep(20 * 1000);
timeWheel. removeTask(task2);
// wait 20 seconds before adding a new task
Thread. sleep(20 * 1000);
timeWheel.addTask(new TimeTask("Task 4", 30 * 1000));
} catch (InterruptedException e) {<!-- -->
e.printStackTrace();
}
}
}
6. Test
After the time wheel is started, all tasks in the corresponding bucket will be executed periodically. For example, in the above code example, we created three scheduled tasks to be executed after 5 seconds, 10 seconds, and 15 seconds respectively. There is a corresponding bucket in each scale of the time wheel to store the tasks that need to be executed. After the time wheel starts, it will check every second whether there is a task to be executed in the bucket pointed by the current pointer, and if so, execute all the tasks in the bucket.
By running the above code, you can see the following output:
Task Task 1 has been executed Task Task 2 performed Task Task 3 executed Task Task 4 has been executed
This indicates that the four scheduled tasks were successfully executed respectively.
Compared with the traditional timer implementation, the Java time wheel algorithm has higher efficiency and scalability. It can easily manage a large number of tasks and supports operations such as adding, deleting and modifying tasks. Therefore, in high-concurrency and high-performance scenarios, the Java timewheel algorithm is a very good way to implement timers.
Summary:
This article introduces the principle, implementation steps and corresponding code examples of the Java Time Wheel Algorithm. The time wheel algorithm is an efficient timer implementation method. By dividing the time wheel into multiple scales, each scale represents a time period, to manage and trigger a large number of timing tasks. The Java time wheel algorithm has the advantages of high efficiency and scalability, and can be widely used in NIO network programming, scheduling tasks and other occasions.