A complete example of java implementing scheduled tasks based on thread pool and reflection mechanism

The example in this article describes how Java implements scheduled tasks based on the thread pool and reflection mechanism. Share it with everyone for your reference, the details are as follows:

Mainly includes the following implementation classes:

1. Main class:

Entrance for task execution:

Call the main method to start loading the task configuration and execute the task

package com.yanek.task; 
import java.util.List; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ScheduledExecutorService; 
import java.util.concurrent.TimeUnit; 
public class Main { 
 /** 
  * @param args 
  */
 public static void main(String[] args) { 
  ScheduledExecutorService scheduExec = Executors.newScheduledThreadPool(1); 
  /* 
  TaskModel tm=new TaskModel(); 
  tm.setClassName("com.yanek.task.TaskA"); 
  tm.setMethodName("testA"); 
  tm.setInitialDelay(3); 
  tm.setPeriod(5); 
  */
  List tasks=XmlReader.getTasks(); 
  for (int i=0;i<tasks.size();i++) 
  { 
   TaskModel tm=(TaskModel)tasks.get(i); 
   scheduExec.scheduleAtFixedRate(new MyTask(tm),tm.getInitialDelay(), tm.getPeriod(), TimeUnit.SECONDS); 
  } 
 } 
}

2. The MyTask class implements the Runnable interface, and calls

package com.yanek.task; 
import java.lang.reflect.InvocationTargetException; 
import java.lang.reflect.Method; 
import java.util.Date; 
public class MyTask implements Runnable { 
 private TaskModel taskModel; 
 public MyTask() {} 
 public MyTask(TaskModel tm) { 
  this.taskModel = tm; 
 } 
 public void run() { 
   System.out.println("call at " + (new Date())); 
   try { 
    Class<?> classType = Class.forName(taskModel.getClassName()); 
    Method getMethod = classType.getMethod(taskModel.getMethodName()); 
    getMethod.invoke(classType); 
   } catch (SecurityException e) { 
    e.printStackTrace(); 
   } catch (IllegalArgumentException e) { 
    e.printStackTrace(); 
   } catch (ClassNotFoundException e) { 
    e.printStackTrace(); 
   } catch (NoSuchMethodException e) { 
    e.printStackTrace(); 
   } catch (IllegalAccessException e) { 
    e.printStackTrace(); 
   } catch (InvocationTargetException e) { 
    e.printStackTrace(); 
   } 
 } 
}

3 in the main class. TaskModel: Encapsulation of the task class

package com.yanek.task; 
public class TaskModel { 
 public String getClassName() { 
  return className; 
 } 
 public void setClassName(String className) { 
  this.className = className; 
 } 
 public String getMethodName() { 
  return methodName; 
 } 
 public void setMethodName(String methodName) { 
  this.methodName = methodName; 
 } 
 public long getInitialDelay() { 
  return initialDelay; 
 } 
 public void setInitialDelay(long initialDelay) { 
  this.initialDelay = initialDelay; 
 } 
 public long getPeriod() { 
  return period; 
 } 
 public void setPeriod(long period) { 
  this.period = period; 
 } 
 private String className; 
 private String methodName; 
 private long initialDelay; 
 private long period; 
}

4. The static methods of these classes are configured in xml files and are called.

package com.yanek.task; 
import java.io.File; 
import java.io.IOException; 
import java.util.ArrayList; 
import java.util.List; 
import org.apache.commons.lang.StringUtils; 
import org.jdom.Document; 
import org.jdom.Element; 
import org.jdom.JDOMException; 
import org.jdom.input.SAXBuilder; 
public class XmlReader { 
 public static void main(String[] args) { 
  XmlReader.getTasks(); 
 } 
 public static List getTasks() { 
  List tasks = new ArrayList(); 
  System.out.println("load task config start..."); 
  String path = "/work/TaskManager/conf/taskconfig.xml"; 
  File file = new File(path); 
  if (file.exists() && !file.isDirectory()) { 
   try { 
    SAXBuilder sx = new SAXBuilder(); 
    Document doc = sx.build(file); 
    Element rootelement = doc.getRootElement(); 
     List<Element> childs = rootelement.getChildren(); 
     for (int i = 0; i < childs.size(); i++) { 
      TaskModel tModel = new TaskModel(); 
      tModel.setClassName(childs.get(i).getChildText("class")); 
      System.out.println(childs.get(i).getChildText("class")); 
      tModel.setMethodName(childs.get(i).getChildText("method")); 
      System.out.println(childs.get(i).getChildText("method")); 
      String initialDelay = childs.get(i).getChildText("initialDelay"); 
      tModel.setInitialDelay((Long.valueOf(initialDelay))); 
      System.out.println("距离首次运行还差" + initialDelay + "秒！"); 
      tModel.setPeriod(Integer.valueOf(childs.get(i).getChildText("period"))); 
      System.out.println(childs.get(i).getChildText("period")); 
      tasks.add(tModel); 
    } 
   } catch (NumberFormatException e) { 
    // TODO Auto-generated catch block 
    e.printStackTrace(); 
   } catch (JDOMException e) { 
    // TODO Auto-generated catch block 
    e.printStackTrace(); 
   } catch (IOException e) { 
    // TODO Auto-generated catch block 
    e.printStackTrace(); 
   } 
  } else { 
   System.out.println("file no exist!"); 
  } 
  System.out.println("load task config end !"); 
  return tasks; 
 } 
}

I hope this article will be helpful to everyone in Java programming.

For more Java-based complete examples of scheduled tasks based on thread pools and reflection mechanisms, please pay attention to the PHP Chinese website!