Programación en Java

1. Programe un proceso utilizando los métodos de interfaz ScheduledExecutorService en Java
2. Programe un hilo usando la clase Timer en Java

La programación es el proceso de ejecutar una tarea o función en un intervalo de tiempo fijo. La programación encuentra su uso en la ejecución de procesos Batch, enviando desencadenantes basados ​​en eventos como deseos de cumpleaños, enviando notificaciones automáticas. Estos procesos deben ejecutarse en un tiempo bien definido en función de las condiciones y el intervalo de tiempo dados.

Programe un proceso utilizando los métodos de interfaz ScheduledExecutorService en Java

package scheduling;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class ScheduleTask {
  private static int counter = 0;

  public static void main(String[] args) throws InterruptedException {
    ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
    Runnable executeTask = () -> {
      counter++;
      System.out.println("Task" + counter);
    };

    ScheduledFuture<?> scheduleAtFixedRate =
        service.scheduleAtFixedRate(executeTask, 5, 1, TimeUnit.SECONDS);

    while (true) {
      Thread.sleep(1000);
      if (counter == 5) {
        System.out.println("Stopping the scheduled task!");
        scheduleAtFixedRate.cancel(true);
        service.shutdown();
        break;
      }
    }
  }
}

En el código anterior, primero, una variable de contador estático se inicializa a un valor cero. El newScheduledThreadPool es un método estático de la clase Executors. El método crea un grupo de subprocesos que debe ejecutarse periódicamente con el parámetro dado en la lista de argumentos. Entonces, en nuestro caso, se crea un solo subproceso para su ejecución, ya que el parámetro en la lista de argumentos de métodos define el número de grupos de subprocesos. El método devuelve una instancia de ScheduledExecutorService que se almacena en la variable de referencia service y arroja IllegalArgumentException si el tamaño del grupo es menor que cero.

El Runnable es una interfaz que cualquier clase puede ampliar y es la interfaz funcional. Tiene un solo método estático como método run y está diseñado para que se ejecute el hilo. Usando la expresión lambda expresada como el símbolo ()-> paréntesis y una flecha, la estructura indica que no estamos pasando ningún argumento al método de ejecución. Hemos definido las declaraciones en la definición del método de ejecución. La declaración presente dentro del bloque incrementará la variable del contador e imprimirá la tarea en la salida de la consola. Todas estas declaraciones son referenciadas por la variable llamada variable executeTask.

La variable de referencia servicio llama al método scheduleAtFixedRate de la interfaz ScheduledExecutorService. El método crea y ejecuta la tarea periódica que debe ejecutarse después del retraso inicial y más tarde dentro del período dado. Se necesitan cuatro parámetros, un comando ejecutable que se supone que debe ejecutarse, y la variable initialDelay es el tiempo para retrasar la primera ejecución, period denota la duración entre ejecuciones sucesivas y unit es la unidad de tiempo en segundos , minutos y horas. El hilo comienza a ejecutarse tan pronto como se llama al método.

En el bucle while, primero, el subproceso en ejecución actual se ve obligado a dormir. El método Thread.sleep() detiene temporalmente el subproceso en ejecución durante el tiempo definido. El parámetro es el número en milisegundos durante el cual el hilo de trabajo actual debería detenerse. El método arroja IllegalArgumentException si el valor es negativo y InterruptedException si se interrumpe el hilo actual. Posteriormente se comprueba el valor de un contador con un valor definido. Esta comprobación se aplica para ejecutar el método while durante un número definido de veces. De lo contrario, el bloque funcionará durante un número infinito que nunca terminará. En el bloque while, la variable scheduleAtFixedRate llama al método cancel, que cancela la ejecución actual del hilo. La función también toma un parámetro booleano que indica si el hilo en ejecución actual puede interrumpirse o no.

El método service.shutdown inicia el proceso de apagado en el que se supone que se ejecutan las tareas enviadas previamente y no se acepta nada nuevo.

La salida del bloque de código anterior es la siguiente.

Task1
Task2
Task3
Task4
Task5
Stopping the scheduled task!

Programe un hilo usando la clase Timer en Java

A continuación se muestra el bloque de código simple que instancia dos objetos de clase definidos por el usuario utilizando sus constructores. TimerImplementation es la clase definida por el usuario para el mismo. Se crea una instancia de Timer que creará un nuevo hilo. El objeto recién creado de un temporizador llamará al método scheduleAtFixedRate. Este método toma parámetros como task que necesita ser programado, delay retrasa la tarea en milisegundos, y period es el tiempo en milisegundos para la ejecución sucesiva.

package timer;

import java.util.Timer;

public class UsingTimerClass {
  public static void main(String[] args) {
    TimerImplementation timer1 = new TimerImplementation("Thread1");
    TimerImplementation timer2 = new TimerImplementation("Thread2");

    Timer t = new Timer();
    t.scheduleAtFixedRate(timer1, 0, 2000);
    t.scheduleAtFixedRate(timer2, 0, 1000);
  }
}

A continuación se muestra la implementación de la clase definida por el usuario. La clase TimerImplementation extiende la clase abstracta TimerTask que contiene un único método abstracto llamado ejecutar. Extendemos la clase TimerTask en una clase definida por el usuario y luego se anula el método run.

La clase tiene un constructor definido por el usuario que establece el nombre definido por el usuario en el objeto del hilo.

Podemos dar una lógica real en el método de ejecución del hilo. Incluye una declaración como print que imprimirá el nombre del hilo que se está ejecutando actualmente. Thread.currentThread().getName() devuelve el nombre del hilo en ejecución actual. El método de suspensión se llama a través de Thread1 que interrumpe la ejecución durante 1000 milisegundos. El método sleep arroja InterruptedException si algún hilo interrumpe el hilo actual, y es por eso que se incluye en el bloque try-catch.

package timer;

import java.util.TimerTask;

public class TimerImplementation extends TimerTask {
  private String name;

  public TimerImplementation(String n) {
    this.name = n;
  }

  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName() + " " + name);
    if ("Thread1".equalsIgnoreCase(name)) {
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

A continuación se muestra la salida interminable del código anterior. Dado que no hemos definido ninguna condición de terminación en el método de ejecución, el subproceso se ejecutará sin cesar hasta que se aplique una parada externa para detener la ejecución del subproceso principal.

Timer-0 Thread1
Timer-0 Thread2
Timer-0 Thread2
Timer-0 Thread2
Timer-0 Thread1
Timer-0 Thread2
Timer-0 Thread2
Timer-0 Thread1
Timer-0 Thread2