ื-Java Timer Class ืืื ืืื ืจื ืขืืฆืื ืืืืคืฉืจ ืื ืืชืืื ืืฉืืืืช ืืืืฆืืข ืืืจืืืื ืืื ืืืืืจืื. ืืื ืื ืืชื ืฆืจืื ืืืจืืฅ ืืฉืืื ืคืขื ืืืช ืื ืฉืื ืืฉืื, ืืืืงืช ืืืืืืจ ืืกืคืงืช ืืจื ื ืืื ืืืคืื ืืช ืชืืื ืืืช ื-Java ืฉืื ืืืืืืืืืืช. ืืืืืจ ืื, ื ืืงืืจ ืืช ืืชืืื ืืช ืฉื ืืืืงืช ืืืืืจ Java ืื ืืื ืืืฆื ืืืืฉื ืืืชื ืืืขืืืืช.
ืืืื ืืฉืืขืืจ ืืืืืจ Java
ืืืืงืช ืืืืืืจ ืืื ืืืง ืืืืืืช java.util ืืืฉืืฉืช ืืชืืื ืืฉืืืืช ืืืืฆืืข ืืืื ืืืืืจ ืื ืืืจืืืื ืืื ืงืืืขืื. ืืื ืืกืคืง ืืจื ืคืฉืืื ืืืืื ื ืืืืฆืืข ืงืื ืืืจืืืื ืืื ืงืืืขืื ืืจืืฉ, ืื ืฉืืืคื ืืืชื ืืืืืืืื ืขืืืจ ืืฉืืืืช ืืืื ืืคืขืืช ืืืจืืขืื, ืืืฆืืข ืขืืืื ืื ืชืงืืคืชืืื ืื ืชืืืื ืชืืืืื ืจืงืข. ืืื ืืืฉืชืืฉ ื- Timer Class, ืขืืื ืืืฆืืจ ืืืืืืงื ืืืืืจ ืืืืืืงื java.util.Timer . ืืืืืืงื ืืืืืจ ืื ืืืจืื ืขื ืชืืืื ืืืืฆืืข ืืฉืืืืช ืืืชืื ืืืจืืฉืืช ืฉืื.ืืฆืืจืช ืืืืืืงื ืืืืืจ
ื ืชืืื ืืืฆืืจืช ืืืืืืงื ืืืืืจ ืื ืืงืืจ ืืช ืืฉืืืืช ืฉืื. ืืืืืืช ืืงืื ืืืื, ืื ื ืืืฆืจืื ืืืืืืงื ืืืืืจ ืืืชืืื ืื ืืฉืืื ืืืืฆืืข ืคืขื ืืืช ืืืืจ ืขืืืื ืืืืืจ:
// First we will import the java.util.Timer & java.util.TimerTask classes
import java.util.Timer;
import java.util.TimerTask;
public class TimerExample {
public static void main(String[] args) {
Timer timer = new Timer(); // Creating a Timer object from the timer class
TimerTask task1 = new TimerTask() {
public void run() {
System.out.println("Task 1 executed!");
}
};
TimerTask task2 = new TimerTask() {
public void run() {
System.out.println("Task 2 executed!");
}
};
TimerTask task3 = new TimerTask() {
public void run() {
System.out.println("Task 3 executed!");
}
};
// Scheduling tasks to run after specified delays
timer.schedule(task1, 2000); // Using the schedule method of the timer class
timer.schedule(task2, 4000); // Using the schedule method of the timer class
timer.schedule(task3, 6000); // Using the schedule method of the timer class
}
}
ืืืืืื ืืืขืืืื ืช ืืื, ืืืืืืืงื Timer ื ืืฆืจ ืืืืฆืขืืช ืืืืืงื Timer . ืื TimerTask ืืืืฆื ืืฉืืื ืฉืชืชืืื ืืืืืฆืืข ืขื ืืื ืืืืืืจ. ืฉืืืช ืืจืืฆื ืืชืื ืื TimerTask ืืืืื ืืช ืืงืื ืฉืืืืฆืข ืืืฉืจ ืืืฉืืื ืคืืขืืช. ืืืืจ ืืื, ืืืฉืืืืช ืืชืืืื ืืช ืืืืฆืขืืช ืฉืืืช ืืชืืืื ืฉื ืืืืืงื Timer , ืชืื ืฆืืื ืืืฉืืื ืืืขืืืื ืืืืคืืืช ืฉื ืืืช. ืืงืื ืื ื ืขืฉื ืฉืืืืฉ ืืฉืืืช ืืื ืืืื ืื ืฉืืืฉ ืคืขืืื, ืืื ืคืขื ืขื ืืฉืืื ืฉืื ื ืืขืืืื.
ืชึฐืคืึผืงึธื
ืืืฉืจ ืืชื ืืคืขืื ืืช ืืงืื, ืืื ืืืฆืื:
ืืฉืืื 1 ืืืฆืขื! ืืฉืืื 2 ืืืฆืขื! ืืฉืืื 3 ืืืฆืขื!
ืื ืืฉืืื ืืืืฆืขืช ืืืืจ ืืืฉืืื ืฉืื, ืื ืฉืืืืื ืืช ืืคืื ืงืฆืืื ืืืืช ืฉื ืืืืงืช ื- Timer .
ืฉืืืืช ืืืืืจ
ืืืืงืช ืืืืืืจ ืืกืคืงืช ืฉืืืืช ืฉืื ืืช ืืชืืื ืืฉืืืืช ืืืืฆืืข. ืืืื ื ืืงืืจ ืืื ืืืฉืืืืช ืื ืคืืฆืืช:1. ืืื ืืื ืื (ืืืืช TimerTask, ืขืืืื ืืจืื)
ืฉืืื ืื ืืชืืื ืช ืืช ืืืฉืืื ืฉืฆืืื ื ืืืืฆืืข ืืืืจ ืืขืืืื ืฉืฆืืื. ืืืฉืืื ืืืืืจืช ืืืืคืืืช ืฉื ืืืช. ืืืืืื:
timer.schedule(task, 5000); // Schedule the task to run after a 5-second delay
2. ืืื ืืื ืื (ืืฉืืื TimerTask, ืชืืจืื ืฉืขื)
ืฉืืื ืื ืืชืืื ืช ืืช ืืืฉืืื ืฉืฆืืื ื ืืืืฆืืข ืืืื ืฉืฆืืื. ืืืฉืืื ืชืชืืฆืข ืคืขื ืืืช ืืืื. ืืืืืื:
Date executionTime = new Date(System.currentTimeMillis() + 5000); // Get the current time + 5 seconds
timer.schedule(task, executionTime); // Schedule the task to run at the specified time
3. ืืื ืืื ืื (ืืืืช TimerTask, ืขืืืื ืืจืื, ืชืงืืคื ืืจืืื)
ืฉืืื ืื ืืชืืื ืช ืืช ืืืฉืืื ืฉืฆืืื ื ืืืืฆืืข ืืืืจ ืืืืจ ืืฉืืื ืฉืฆืืื ืืืืจืืืืื ืฉืฆืืื ื. ืืืฉืืื ืืื ืืืื ืืืืคืืืช ืฉื ืืืช ืืคื ื ืืืืฆืืข ืืจืืฉืื, ืืืชืงืืคื ืืื ืืืื ืืืืคืืืช ืฉื ืืืช ืืื ืืืืฆืืขืื ืืืืื. ืืืืืื:
timer.schedule(task, 2000, 5000); // Schedule the task to run after a 2-second delay and repeat every 5 seconds
ืืื ืืื ืื ืฉื ืืืืืจ Java
ืื ืืกืฃ ืืฉืืืืช ืืชืืืื ืืืกืืกืืืช, ืืืืงืช ืืืืืืจ ืืกืคืงืช ืื ืฉืืืช ืชืืืื ืจืืช ืขืืฆืื ืื ืงืจืืช ืืื ืืื ืื (ืืฉืืื TimerTask, Date firstTime, ืชืงืืคื ืืจืืื) . ืฉืืื ืื ืืืคืฉืจืช ืื ืืชืืื ืืฉืืื ืืืืฆืืข ืืืืจ ืืืชืืื ืืฉืขื ืืกืืืืช ืืืืจืืืืื ืงืืืขืื. ืื ื ืืืืื ืฉืืืืืื ืืช ืืฉืืืืฉ ืืฉืืื ืื:
import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;
public class TimerExample {
public static void main(String[] args) {
Timer timer = new Timer();
TimerTask task = new TimerTask() {
public void run() {
System.out.println("Task executed!");
}
};
// Schedule the task to run every 5 seconds starting from the current time
Date startTime = new Date();
timer.schedule(task, startTime, 5000);
}
}
ืืืืืื ืื, ืื ื ืืืฆืจืื ืืืืืืงื Timer ืืืืืืจืื TimerTask ืืื ืงืืื. ืื ื ืื ืืืฆืจืื ืืืืืืงื startTime ืืกืื Date ืืื ืืฆืืื ืืช ืฉืขืช ืืืชืืื ืฉื ืืืฉืืื. ืืืืจ ืืื ื ืขืฉื ืฉืืืืฉ ืืฉืืืช ืืชืืืื ืืื ืืชืืื ืืช ืืืฉืืื ืืคืขืื ืื 5 ืฉื ืืืช ืืื ืืืฉืขื ืื ืืืืืช. ืืฉืืืช ืชืืืื ืื, ืืืฉืืื ืชืืฉืื ืืืชืืฆืข ืืืจืืื ืฉืฆืืื ืขื ืืืืืื ืืืืืืงื ืืืืืืจ ืื ืฉืืชืืื ืืช ืชืกืชืืื. ืืืจืช, ืื ืืืจืืง ืืจืื.
GO TO FULL VERSION