En el desarrollo, a menudo necesitamos algunas operaciones periódicas, como realizar una determinada operación cada pocos minutos. En este momento, necesitamos establecer un temporizador. La forma más conveniente y eficiente de implementarlo en Java es usar la clase de herramientas java.util.timer, y luego programar la tarea java.util.timerTask.
El temporizador es una herramienta que lo usa para organizar tareas que se ejecutarán en hilos de fondo más adelante. Las tareas se pueden ejecutar una vez, o se pueden ejecutar repetidamente. En realidad, es un hilo que programa las Timtertas de propiedad de programación cronometrada.
TimeTkask es una clase abstracta cuyas subclases están organizadas por el temporizador como tareas que se ejecutan o se repiten. De hecho, es una clase con un método de ejecución, y el código que debe ejecutarse regularmente se coloca en el cuerpo del método de ejecución.
Java lanzó el temporizador de la clase de temporizador en JDK1.3, y luego Doulea desarrolló recientemente el SchedulethreadPoolExecutor que admite múltiples subprocesos después de JDK1.5. A juzgar por el rendimiento de este último, podemos considerar reemplazar completamente el temporizador.
Comparación entre Timer y SchedulethreadPoolExecutor:
1. El temporizador comienza con JDK1.3. Su principio es usar una matriz de TimeTask como cola para agregar todas las tareas de tiempo a esta cola. Luego comience un hilo. Cuando la cola está vacía, el hilo se bloqueará. Cuando hay datos en la cola, el hilo eliminará una tarea de tiempo para juzgar
Si el tiempo está actualizado, la tarea comienza a ejecutarse si el tiempo de ejecución es menor o igual a la hora actual. Debido a su naturaleza de hilo único, trae varios problemas (el código detallado es más tarde):
Primero, cuando las tareas que agregamos al temporizador requieren mucho tiempo, ya que este temporizador ejecuta las tareas del temporizador de una manera secuencial de un solo hilo, afectará la ejecución oportuna de tareas posteriores.
Código Java
// Ejemplo del problema: m_timer.scheduleatfixedRate (nuevo taskuselongtime (), 1000, 5000); m_timer.schedleatfixedRate (nuevo taskNormal (), 5000, 3000); Resultado de la ejecución: 14:44:29: el temporizador está durmiendo 10 segundos 14:44:39: el temporizador está durmiendo 14:44:39: el temporizador está durmiendo 10 segundos 14:44:49: Tarea Normal Ejecutada 14:44:49: Tarea Normal Ejecutada 14:44:49: Tarea Normal Ejecutada 14:44:49: Tarea Normal Ejecutada 14:44:49 Ejecutada Ejecutada 14:44 44 44: Tarea Normal ejecutada 14:44:49 14:44:49: Tarea Normal Ejecutada 14:44:49: El temporizador está durmiendo 10 segundos Análisis de resultados: La tarea TaskNormal no se puede garantizar que se ejecute una vez cada 3 segundos, solo puede esperar a que Taskuselongtime se ejecute después de que se complete.
En segundo lugar, el hilo en el temporizador solo captará la excepción de InterruptEdException, por lo que si nuestra tarea de tiempo personalizado no atrapa posibles excepciones y causa la excepción, se lanza,
// Ejemplo 2: m_timer.schedule (new TaskThrowException (), 1000); m_timer.schedule (nuevo taskNormal (), 2000); Resultado de ejecución: 14:47:37: Excepción de la excepción de lanzamiento en el hilo "Timer-0" java.lang.runtimeException en timer_test.timertest $ taskthrowexception.run (timertest.java:85) en java.util.timerthread.mainloop (Timer.Java:512) en el java.util.timerthread.run (Timer.java:462) Análisis de resultados: Después de que una tarea se lanza una tarea, la tarea posterior no puede continuar ejecutándose.
Esto hará que nuestro hilo del temporizador se detenga, de modo que no se pueden ejecutar otras tareas posteriores.
Tercero, no puede manejar múltiples tareas de tiempo que ocurran simultáneamente
// Análisis de las tres preguntas: m_timer.scheduleatfixedRate (nuevo TaskUselongTime ("Timer1"), 1000, 15000); m_timer.schedleatfixedRate (nuevo TaskUselongTime ("Timer2"), 1000, 15000); Resultado de la ejecución: 14:50:16: Timer1 está durmiendo 10 segundos 14:50:26: Timer2 está durmiendo 10 segundos 14:50:36: Timer2 está durmiendo 10 segundos Análisis de resultados: Mi tiempo de inicio es 1 segundo más tarde, pero el tiempo de inicio entre Timer1 y Timer2 es obviamente inconsistenteEjemplo de código:
paquete timer_test; import java.text.simpledateFormat; import java.util.date; import java.util.timer; import java.util.timerTask; public class TimeTest {private final Timer m_timer = new Timer (); public static void main (string [] args) {new Timertest (). Ejemplo del problema: m_timer.schedleatfixedRate (nuevo taskUselongTime (), 1000, 5000); m_timer.schedleatfixedRate (new TaskNormal (), 5000, 3000); // Ejemplo 2: // M_Timer.schedule (New TaskThrowException (), 1000); // m_timer.schedule (nuevo taskNormal (), 2000); // Ejemplo 3: // m_timer.scheduleatfixedRate (nuevo TaskUselongTime ("Timer1"), 1000, 5000); // m_timer.scheduleatfixedRate (new TaskUselongTime ("Timer2"), 1000, 5000);} de clase privada TaskUselongTime extiende TimerTask {private String m_taskName = "Timer"; public TaskUselongTime () {} public TaskUselongTime (String TaskName) {M_TaskName (TaskSeBeNeN; {try {System.out.println (getCurrentTime ()+":"+m_taskname+"es durmiendo 10 segundos"); horte.sleep (10000);} catch (interruptedException e) {}}} clase privada TaskNormal Extiende TimerTask {@Override public void run () {System.out.Println (getCeCren ejecutado ");}} TaskThrowException de la clase privada extiende TimeTask {@Override public void run () {System.out.println (getCurrentTime ()+": throLe excepcion "); throw newTimeException ();}} private string getCurrentTime () {return new SimpledAformat (" hh: mm: ss ").2.SchedulethreadPoolExecutor
Schedulethreadpoolexecutor comenzó con JDK1.5 y fue escrito por el Sr. Doulea. Utiliza la combinación inteligente de ThreadPoolExecutor y Delayqueue para completar la implementación del temporizador de múltiples subprocesos, resolviendo los tres defectos anteriores causados por un solo hilo en el temporizador.
El problema en la pregunta 1 es que las tareas posteriores no se pueden completar a tiempo porque los hilos únicos se ejecutan secuencialmente. Vemos que el subproceso múltiple puede resolver fácilmente este problema. Al mismo tiempo, notamos que el tiempo de ejecución de Taskuselongtime es de 10s (consulte el código posterior). Programamos el intervalo de tareas de 5 segundos, pero desde el resultado, descubrimos que nuestro intervalo de ejecución de tareas es de 10 segundos, por lo que podemos juzgar que SchedulethreadPoolExecutor funciona en un modo por hilo por tarea.
// Problema 1: m_timer.schedleatfixedRate (nuevo taskusEngtime (), 1000, 5000, TimeUnit.MilliseConds); m_timer.schedleatfixedRate (nuevo taskNormal (), 1000, 5000, TimeUnit.milliseConds); Resultado de ejecución: 14:54:37: Tarea Normal Ejecutada 14:54:37: El temporizador está durmiendo 10 segundos 14:54:42: Tarea Normal Ejecutada 14:54:47: Tarea Normal Ejecutada 14:54:47: Tarea Normal Ejecutada 14:54:47: Temporizador Duerme 10 segundos 14:54:52: Tarea Normal ejecutada Ejecutada ejecutada
En la pregunta 2, encontramos que cuando se lanza la excepción, la ejecución de la tarea no afecta la operación de otras tareas. Al mismo tiempo, descubrimos que nuestra excepción no fue lanzada en el resultado de la ejecución. Esto se debe a que la clase SchedulethreadPoolExecutor devolverá un resultado de la ejecución de FUTUREDE después de ejecutar la tarea cronometrada. Ya sea que el resultado sea exitoso o hay excepciones, se guardará aquí.
// Problema 2: m_timer.scheduleatfixedRate (nuevo taskthrowException (), 1000, 5000, TimeUnit.milliseConds); m_timer.schedleatfixedRate (nuevo taskNormal (), 1000, 5000, TimeUnit.milliseConds); Resultado de ejecución: 14:58:36: Excepción de lanzamiento 14:58:36: Tarea Normal Ejecutada 14:58:41: Tarea Normal Ejecutada 14:58:46: Tarea Normal Ejecutada 14:58:46: Tarea Normal Ejecutada 14:58:46
Pregunta 3 Dado que es multiproceso, podemos asegurarnos de que nuestras tareas de tiempo se puedan ejecutar al mismo tiempo.
// Problema 3: m_timer.schedleatfixedRate (nuevo taskusEngtime ("Timer1"), 1000, 5000, TimeUnit.MilliseConds); m_timer.schedleatfixedRate (nuevo TaskUselongTime ("Timer2"), 1000, 5000, TimeUnit.MilliseConds); Running result: 15:01:12: timer1 is sleeping 10 seconds 15:01:12: timer2 is sleeping 10 seconds 15:01:22: timer2 is sleeping 10 seconds 15:01:22: timer2 is sleeping 10 seconds 15:01:22: timer2 is sleeping 10 seconds 15:01:22: timer2 is sleeping 10 seconds 15:01:22: timer2 is sleeping 10 seconds 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 es durmiendo 10 segundos 15:01:22: Tiempo Timero 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 está durmiendo 10 segundos 15:01:22: Timer2 Durming 10 segundos 15:01: Segundos 15:01:22: Timer1 es durmiendo 10 segundos 15:01:01: Segundos 15:01:32: Timer2 está durmiendo 10 segundosCódigo detallado:
package timer_test;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.Callable;import java.util.concurrent.ScheduledThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class ScheduleThreadPoolExecutorTest {private final ProchulEdThreadPoolExecutor m_timer = new SchedulEdThreadPoolExeCutor (10); public static void main (string [] args) {schedulethreadPoolexeCutortest TimeTest = new SchedulethreadPoolExeCutortest (); timertest.test (); intit {throve.sleep (100000);} catch (interruptedExcente {timertest.shutdown ();}} public void shutdown () {m_timer.shutdown ();} public void test () {// pregunta 1: // m_timer.scheduleatfixedRate (new TaskUselongTime (), 1000, 5000, tiempo de tiempo. Miliseconds); // m_timer.scheduleatfixedRate (nuevo taskNormal (), 1000, 5000, TimeUnit.MilliseConds); // Pregunta 2: // m_timer.scheduleatfixedRate (nueva tareaThrowException (), 1000, 5000, TimeUnit.MilliseConds); // m_timer.scheduleatfixedRate (nuevo taskNormal (), 1000, 5000, TimeUnit.MilliseConds); // Problema 3: m_timer.schedleatfixedRate (nuevo taskUselongTime ("temporizador1"), 1000, 5000, TimeUnit.milliseConds); m_timer.scheduleatfixedRate (nuevo taskuselongtime ("timer2"), 1000, 5000, timeUnit.milliseConds);} Callable <Integer>, runnable {private String m_taskName = "timer"; private taskUselongTime () {} private taskUselongtime (string tarquel segundos "); thread.sleep (10000);} catch (interruptedException e) {}} public Integer Call () lanza excepción {run (); return 0;}}@supressWarnings (" sin uso ") de la clase privada TaskNormal Implements Callable <Integer>, Runnable {Public Integer Call () Dela la excepción {Run (); {System.out.println (getCurrentTime ()+": tarea normal ejecutado");}}@supressWarnings ("no usado") clase privada tareas de taskThowException implementa <integer>, runnable {public Integer llamado () Shows {System.out.Println (GetCrUrRentTime ()+": Showe Exception"); Shouge New RuneReee; run () {System.out.println (getCurrentTime ()+": Show Exception"); Throw New RuntimeException ();}} private String getCurrentTime () {return new SimpleDateFormat ("HH: MM: SS"). Format (nueva fecha ());}}Resumir
Lo anterior se trata de la breve discusión de este artículo sobre la historia del desarrollo de los temporizadores de Java, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a este sitio:
Java implementa un análisis de código de temporizador simple
El principio y la implementación del temporizador de temporizador multithreaded Java
Ejemplo de código de cómo usar el temporizador de temporizador Java
Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!