任务调度的简单实现

最新推荐文章于 2022-10-07 13:21:47 发布
最新推荐文章于 2022-10-07 13:21:47 发布
阅读量307 收藏
点赞数
分类专栏： java 文章标签： web.xml java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xj8844/article/details/84006211
版权

做了个简单的任务调度实例，主要思想功能如下：
模拟master和slave2台机器，master机器有一个任务队列，通过启动一个线程定时轮询改任务队列，如果其中有任务，则调用slave的接口将任务分配给slave机器处理。同时，slave机器配置了心跳检测，即slave启动一个线程，每隔一段时间调用master的接口修改master的全局变量lasterAliveTime的值为当前时间，同时，master也有一个线程用来定时计数当前时间与这个lasterAliveTime的时间差，如果超过2秒则认为slave机器死亡。
实现代码如下：


Master包下为master机器运行的类，Slave包下为slave机器运行的类。

模拟2个服务的方法如下;

1.模拟master服务：

在pom.xml里使用jetty插件，并设定端口为8081，如下：

 

<plugins>

<!-- jetty插件 -->

<plugin>

<groupId>org.mortbay.jetty</groupId>

<artifactId>maven-jetty-plugin</artifactId>

<version>6.1.22</version>

<configuration>

<contextPath>/</contextPath>

<connectors>

<connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">

<port>8081</port>

<maxIdleTime>60000</maxIdleTime>

</connector>

</connectors>

<requestLog implementation="org.mortbay.jetty.NCSARequestLog">

<filename>target/access.log</filename>

<retainDays>90</retainDays>

<append>false</append>

<extended>false</extended>

<logTimeZone>GMT+8:00</logTimeZone>

</requestLog>

<systemProperties>

<systemProperty>

<name>productionMode</name>

<value>false</value>

</systemProperty>

</systemProperties>

</configuration>

</plugin>

<plugins>

 

本实例通过实现ServletContextListener接口实现服务启动后自动启动相关类功能，所以配置web.xml如下：

 

<?xml version="1.0" encoding="GB2312"?>

<web-app id="WebApp_ID" version="2.4"

xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

 

<servlet>

<servlet-name>test</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

 

<servlet-mapping>

<servlet-name>test</servlet-name>

<url-pattern>/service/*</url-pattern>

</servlet-mapping>

 

 

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

   classpath*:/spring/*.xml</param-value>

</context-param>

 

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

 

<!--随着服务启动自动运行-->

<listener>

               <listener-class>com.TaskScheduling.Master.AutoRun</listener-class>

        </listener>

 

</web-app>

运行mvn jetty:run命令启动master服务。

2.模拟slave机器
除了web.xml文件外其他代码无需改动，web.xml需修改的配置如下：

        <listener>

               <listener-class>com.TaskScheduling.Slave.SlaveAutoRun</listener-class>

        </listener>

 

运行mvn clean install ,将生成的war包放到jetty的%jetty_home%/webapps路径下,jetty默认的端口为8080,启动jetty,在%jetty_home%下执行命令：java -jar start.jar。

 

 

相关代码如下:

web.xml:

 

<?xml version="1.0" encoding="GB2312"?>

<web-app id="WebApp_ID" version="2.4"

xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

 

<servlet>

<servlet-name>test</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

 

<servlet-mapping>

<servlet-name>test</servlet-name>

<url-pattern>/service/*</url-pattern>

</servlet-mapping>

 

 

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

   classpath*:/spring/*.xml</param-value>

</context-param>

 

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

 

        <welcome-file-list>

<welcome-file>/jsp/login.jsp</welcome-file>

</welcome-file-list>

<listener>

    <listener-class>com.TaskScheduling.Master.AutoRun</listener-class>

<!--    <listener-class>com.TaskScheduling.Slave.SlaveAutoRun</listener-class>-->

    </listener>

 

 

 

</web-app>

 

在%classpath%/spring/autorun.xml:

 

 

<?xml version="1.0" encoding="utf-8"?>

 

<beans default-autowire="byName"

xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:util="http://www.springframework.org/schema/util"

xsi:schemaLocation="http://www.springframework.org/schema/beans 

http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 

http://www.springframework.org/schema/aop 

http://www.springframework.org/schema/aop/spring-aop-2.0.xsd 

http://www.springframework.org/schema/util 

http://www.springframework.org/schema/util/spring-util-2.5.xsd ">

 

 

<bean id="jobService" class="com.TaskScheduling.Master.JobService"/>

 

<bean id="heartBeatCheck" class="com.TaskScheduling.Master.HeartBeatCheck" />

<bean id="slaveHeartBeat" class="com.TaskScheduling.Master.impl.SlaveHeartBeatImpl" />

<bean id="heartBeat" class="com.TaskScheduling.Slave.HeartBeat" />

 

        <bean id="testService" class="com.TaskScheduling.Slave.service.TestService" />

 

<bean name="/HeatBeat"

class="org.springframework.remoting.caucho.HessianServiceExporter">

<property name="service" ref="slaveHeartBeat" />

<property name="serviceInterface" value="com.TaskScheduling.Master.SlaveHeartBeat" />

</bean>

 

<bean name="/JobProcess"

class="org.springframework.remoting.caucho.HessianServiceExporter">

<property name="service" ref="jobProcess" />

<property name="serviceInterface" value="com.TaskScheduling.Slave.JobProcess" />

</bean>

 

<bean id="jobProcess" class="com.TaskScheduling.Slave.impl.JobProcessImpl" />

 

</beans>

 

master相关类：

com.TaskScheduling.Master.SlaveHeartBeat：

 

package com.TaskScheduling.Master;

 

public interface SlaveHeartBeat {

public String check() ;

}


com.TaskScheduling.Master.impl.SlaveHeartBeatImpl：
package com.TaskScheduling.Master.impl;

import java.util.Date;

import com.TaskScheduling.Master.MasterGlobalResource;
import com.TaskScheduling.Master.SlaveHeartBeat;

public class SlaveHeartBeatImpl implements SlaveHeartBeat {
/**
* slave定期调用master的该接口修改master的全局变量MasterGlobalResource的Lastalivetime值
*/
public String check() {
MasterGlobalResource.setLastalivetime(new Date());
System.out.println(MasterGlobalResource.getLastalivetime());
return "OK";
}
}

com.TaskScheduling.Master.AutoRun：
package com.TaskScheduling.Master;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpServlet;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


@SuppressWarnings("serial")
public class AutoRun extends HttpServlet implements ServletContextListener {
/**
 * 服务器停止前自动执行
 */
@Override
public void contextDestroyed(ServletContextEvent arg0) {
 DeleteFile();
}
/**
* 服务器启动后自动运行
*/
@Override
public void contextInitialized(ServletContextEvent arg0) {
WriteFile();
/*也可以通过 ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(arg0.getServletContext()); 获取spring上下文，
但不可以通过让AutoRun 类实现ApplicationContextAware接口来获取上下文，应为autorun类实现了ServletContextListener，所以在sp ring启动前启动，所以得到的上下文将为null*/
                 ApplicationContext app = new ClassPathXmlApplicationContext("classpath*:spring/*.xml");
//任务队列轮询
MasterGlobalResource.getExecutor().execute((JobService)app.getBean("jobService"));
//检测slave机器是否存活
MasterGlobalResource.getExecutor().execute((HeartBeatCheck)app.getBean("heartBeatCheck"));
}
 public void WriteFile() {
       try {
        System.out.println("write");
           FileWriter fw = new FileWriter("c:/WriteData.txt");
           // 将字符串写入文件
           fw.write("Hello World！");
           fw.write("Hello Everyone!");
           fw.close();
       } catch (IOException e) {
       }
   }

   public void DeleteFile() {
       File f = new File("c:/WriteData.txt");
       // 检查文件是否存在，如果存在，直接删除文件
       if (f.exists()) {
           f.delete();
       }
   }

}

com.TaskScheduling.Master.HeartBeatCheck：
package com.TaskScheduling.Master;

import java.util.Date;

public class HeartBeatCheck implements Runnable{
@Override
public void run() {
while(true)
{
Date lastAliveTime = MasterGlobalResource.getLastalivetime();
Date nowTime = new Date();
System.out.println("nowTime="+nowTime.getTime()+"   lastAliveTime="+lastAliveTime.getTime());
//如果超过2秒slave机器没有调用master机器的接口修改Lastalivetime值则认为slave死亡
if(nowTime.getTime()-lastAliveTime.getTime()>2000)
System.out.println("slave has no feedback in 2 second...");
try {
//每1秒钟监测一次
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}

com.TaskScheduling.Master.JobService：
package com.TaskScheduling.Master;

import com.TaskScheduling.Slave.JobProcess;
import com.caucho.hessian.client.HessianProxyFactory;
/**
 * 任务调度
 *
 */
public class JobService implements Runnable {
private HessianProxyFactory factory = new HessianProxyFactory();
@Override
public void run() {
try {
//添加10个任务到任务队列
Thread.sleep(5000);
for(int i=0;i<10;i++)
{
ZephyrJobWrapper job=new ZephyrJobWrapper();
job.setJobId(String.valueOf(i));
job.setJobName(String.valueOf(i));
job.setJobBeanName("testService");//任务bean名
job.setJobMethodName("getJobInfo");//任务方法名
job.setJobArgs(new Object[]{"hello","xj"+String.valueOf(i)});//方法的参数
MasterGlobalResource.setWaitingJobQueue(job);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//slave处理任务的接口
JobProcess jobProcess=(JobProcess)factory.create(JobProcess.class, "http://localhost:8080/rmi.test/service/JobProcess");
//轮询任务队列
while(true)
{
System.out.println("size="+MasterGlobalResource.getWaitingJobQueue().size());
for(ZephyrJobWrapper job:MasterGlobalResource.getWaitingJobQueue())
{
//如果任务队列有任务则通过hessian接口交给slave机器执行任务
jobProcess.process(job);
}
   //轮询间隔为一秒钟
Thread.sleep(1000);
}
} catch (Exception e) {
System.out.println(e);
System.out.println("job process failed");
}
}
}

com.TaskScheduling.Master.MasterGlobalResource：
package com.TaskScheduling.Master;

import java.util.Date;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * master机器的全局变量
 *
 */
public  class MasterGlobalResource {
/**
* slave最后心跳时间
*/
private  static Date lastalivetime=new Date();
/**
* 线程池
*/
private static ThreadPoolExecutor                                      executor                 = new ThreadPoolExecutor(
             10,
             10,
             0L,
             TimeUnit.MILLISECONDS,
             new LinkedBlockingQueue<Runnable>(),
             new ThreadPoolExecutor.DiscardPolicy());
/**
 * 任务队列
 */
private static LinkedBlockingQueue<ZephyrJobWrapper>             waitingJobQueue          = new LinkedBlockingQueue<ZephyrJobWrapper>(); 
 
public static ThreadPoolExecutor getExecutor() {
       return executor;
   }
 
public static LinkedBlockingQueue<ZephyrJobWrapper> getWaitingJobQueue()
{
return waitingJobQueue;
}
 
public static void setWaitingJobQueue(ZephyrJobWrapper job)
{
waitingJobQueue.add(job);
}

public static Date getLastalivetime() {
return lastalivetime;
}

public static void setLastalivetime(Date lastalivetime) {
MasterGlobalResource.lastalivetime = lastalivetime;
}

}

com.TaskScheduling.Master.SlaveHeartBeat：
package com.TaskScheduling.Master;

public interface SlaveHeartBeat {
public String check() ;
}

com.TaskScheduling.Master.ZephyrJobWrapper：
package com.TaskScheduling.Master;

import java.io.Serializable;
/**
 * job定义类
 *
 */
public class ZephyrJobWrapper implements Serializable{
private static final long serialVersionUID = 6453296403466572073L;
public String jobId;
public String jobName;
public String getJobId() {
return jobId;
}
public void setJobId(String jobId) {
this.jobId = jobId;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
}

slave相关类：
com.TaskScheduling.Slave.JobProcess：
package com.TaskScheduling.Slave;

import com.TaskScheduling.Master.ZephyrJobWrapper;

public interface JobProcess {
public String process(ZephyrJobWrapper job);

}


com.TaskScheduling.Slave.impl.JobProcessImpl：
package com.TaskScheduling.Slave.impl;

import java.lang.reflect.Method;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import com.TaskScheduling.Master.ZephyrJobWrapper;
import com.TaskScheduling.Slave.JobProcess;
/**
 * 处理master分配给slave的任务
 *
 */
public class JobProcessImpl implements JobProcess,ApplicationContextAware{
private ApplicationContext  applicationContext;

@Override
public String process(ZephyrJobWrapper job) {
String result="success";
Object jobBean = applicationContext.getBean(job.getJobBeanName());
        Class<?> clazz = jobBean.getClass();
        Method jobMethod = null;
        Object[] args = null;
        for (Method method : clazz.getMethods()) {
            Class<?>[] paramTypes = method.getParameterTypes();

            if (method.getName().equals(job.getJobMethodName())) {
                Object jobArgs = job.getJobArgs();

                /** 传入Object[]参数时，检查方法名和参数个数 **/
                if (jobArgs != null && jobArgs.getClass().getSimpleName().equals("Object[]")) {
                    args = (Object[]) jobArgs;

                    if (args.length == paramTypes.length) {
                        jobMethod = method;
                        break;
                    }
                }
                /** 不传参或者传入其它类型参数时，只检查方法名 **/
                else {
                    jobMethod = method;
                    break;
                }
            }
        }
        try {
if (jobMethod != null) {
   if (args == null) {
       jobMethod.invoke(jobBean, job.getJobArgs());
   } else {
       jobMethod.invoke(jobBean, args);
   }
} else {
result="failed";
}
} catch (Exception e) {
result="failed";
} 
System.out.println("complete process job "+job.getJobName()+"successful!");
return result;
}

@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext=applicationContext;
}

}


com.TaskScheduling.Slave.HeartBeat：
package com.TaskScheduling.Slave;


import com.TaskScheduling.Master.SlaveHeartBeat;
import com.caucho.hessian.client.HessianProxyFactory;
/**
 * 每1秒调用master接口修改最后更新时间，用来心跳监测
 *
 */
public class HeartBeat implements Runnable {
private HessianProxyFactory factory                = new HessianProxyFactory();

@Override
public void run() {
while(true)
{
try {
SlaveHeartBeat heatBeat=(SlaveHeartBeat)factory.create(SlaveHeartBeat.class, "http://localhost:8081/service/HeatBeat");
String result=heatBeat.check();
System.out.println(result);
Thread.sleep(1000);
} catch (Exception e) {
System.out.println("slave cannot connect to master...check master run well");
}
}
}
}

com.TaskScheduling.Slave.SlaveAutoRun：
package com.TaskScheduling.Slave;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpServlet;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

@SuppressWarnings("serial")
public class SlaveAutoRun extends HttpServlet implements ServletContextListener {
public SlaveGlobalResource slaveGlobalResource;

@Override
public void contextDestroyed(ServletContextEvent arg0) {

}

@SuppressWarnings("static-access")
@Override
public void contextInitialized(ServletContextEvent arg0) {
ApplicationContext app=new ClassPathXmlApplicationContext("classpath*:spring/*.xml");
//心跳检测
slaveGlobalResource.getExecutor().execute((HeartBeat)app.getBean("heartBeat"));
}

}

com.TaskScheduling.Slave.SlaveGlobalResource：
package com.TaskScheduling.Slave;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * slave的全局变量
 *
 */
public class SlaveGlobalResource {
public static ThreadPoolExecutor executor=new ThreadPoolExecutor( 10,
            10,
            0L,
            TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(),
            new ThreadPoolExecutor.DiscardPolicy()); 
public static ThreadPoolExecutor getExecutor()
{
return executor;
}

}

com.TaskScheduling.Slave.service.TestService:
package com.TaskScheduling.Slave.service;
/**
 * 需要slave处理的任务类
 *
 */
public class TestService {
public void getJobInfo(String str1,String str2)
{
System.out.println(str1+"---------"+str2);
return ;
}

}


xj8844
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
任务调度之队列(queue)
qwuheuhf的博客
12-18 812
队列像栈一样，都是表,队列的特点是在队列的一端(队尾)进行插入而在另一端(对头)进行删除操作，采取的是先进先出的策略。 阻塞队列（同步）： LinkedBlockingQueue:java.util.concurrent这是一个基于链表实现的的阻塞队列(当多个线程操作共同的队列时不需要额外的同步),他的范围可以自由的设定,如果不设定则默认为Integ...
简单的任务调度（自整理）
weixin_34309435的博客
09-07 1万+
为什么80%的码农都做不了架构师？>>> ...
如何自己设计一个定时任务分布式调度器
m0_71777195的博客
10-07 1254
使用分布式调度器能够很好的管理我们的定时任务接口，开发人员也只需专注开发业务接口，让业务与配置完全分离。定时配置还可以根据业务场景统一进行时间协调管理，以免在有些时间点多任务同时处理，可以将时间配置的分散点以减轻CPU的压力。如果系统业务量少，定时任务也不多的情况也没必要多浪费时间开发一个调度系统。
Android使用JobService后台实现静默安装apk的功能
j086924的专栏
08-10 1036
一．JobService介绍 １．JobService类的继承关系 JobService extends Service java.lang.Object   android.content.Context      android.content.ContextWrapper        android.app.Service   ...
STM32简单任务调度的总结
weixin_43637946的博客
11-08 5525
概述 STM32的开发目前大多数还开处于“裸奔”的阶段，处于开发成本的考虑，可能还未嵌入任何的RTOS系统，由于没有操作系统的支持，因而不能方便的对多任务进行调度和管理。而有的任务不紧急，不需要过多的时间去循环执行，因此需要一个简单的任务调度来解决这个问题。 STM32F103ZE的AHB时钟为72MHz，通过HSE的8M倍频到72M，然后APB1预分频系数为2，所以TIM2-7时钟为2*36M...
FreeRTOS简单任务调度实现
01-06
本次FreeRTOS任务调度通过S32K144来实现，首先进行工程的创建，然后做代码分析。 选择file->new->S32DS Application Project 填写工程名称，选择S32K144，点击next FPU Support选择Hardware:-mfloat -abi = hard...
Springboot实现调度任务动态管理
12-30
首先，我们要了解Spring Boot中用于任务调度的核心组件——`@Scheduled`注解和`TaskScheduler`接口。`@Scheduled`是Spring提供的一个定时任务注解，可以直接在方法上使用，用于执行周期性的任务。而`TaskScheduler`...
SpringBoot任务调度器的实现代码
08-26
SpringBoot 任务调度器是一种基于注解的任务调度机制，它允许开发者使用简单的注解来实现任务的调度。这种机制可以帮助开发者轻松地实现复杂的任务调度逻辑，从而提高应用程序的可靠性和可维护性。 要使用 ...
Quartz Job实现java任务调度
03-27
Quartz是功能强大的开源作业调度库，几乎可以集成到任何Java应用程序中-从最小的独立应用程序到最大的电子商务系统。Quartz可用于创建简单或复杂的计划，以执行数以万计，数以万计的工作；任务定义为标准Java组件的...
几种任务调度的Java实现方法与比较
02-24
Timer相信大家都已经非常熟悉java.util.Timer了，它是最简单的一种实现任务调度的方法，下面给出一个具体的例子：清单1.使用Timer进行任务调度使用Timer实现任务调度的核心类是Timer和TimerTask。其中Timer负责设定...
c语言简单队列
04-22
#include #include #include //队列最大长度 #define MAX_QUEUE 1024 //偷懒，就用静态队列了 static int mQueue[MAX_QUEUE]; //队列插入 void InsertData(int **Front, int **Rear) { if (*Rear + 1 == *Front && (*Rear + 1 - MAX_QUEUE != *Front)) { //当队列数据已满，返回 puts("Queue Size Overflow!\n"); return; } else if (*Rear - mQueue > MAX_QUEUE) { //实现的是类似循环队列，但由于是静态线性队列(数组) //而不是用链表来实现的，所以到静态队列(数组)尾部,尾指针自动指向(数组)头部 *Rear = mQueue; } puts("Input Data:"); scanf("%d", *Rear); //输入数据后，尾指针后移 *Rear += 1; } //从头指针删除一个队列中的数据 void DeleteData(int **Front, int **Rear) { if (*Front == *Rear) { //头指针尾指针重合，队列空，不能删除，返回 puts("Queue Empty!\n"); return; } else if (*Front - mQueue > MAX_QUEUE) { //参考 Rear *Front = mQueue; } //从头指针删除一个数据 *Front += 1; } //显示队列数据 void ShowData(int **Front, int **Rear) { int *temp; for (temp=*Front; temp!=*Rear; temp++) { printf("%d --> ", *temp); } puts("\n"); } void usage(void) { puts("1. Insert Data"); puts("2. Delete Data"); puts("3. Show Data"); } int main(int argc, char **argv) { //头指针，尾指针 //队列的一个特性 First in first out FIFO int *pFront, *pRear; int op_code; //初始化队列，头指针和尾指针此时指向的地址相同 pFront = pRear = mQueue; while (1) { usage(); scanf("%d", &op_code); switch (op_code) { case 1: printf("%p\n", pFront); printf("%d\n", *pFront); InsertData(&pFront, &pRear); break; case 2: DeleteData(&pFront, &pRear); break; case 3: ShowData(&pFront, &pRear); break; default: break; } } return 0; }
任务调度的实现总结
昆仔的博客
08-16 1745
任务调度的实现总结 前言 我们的应用程序有些定时任务（例如想在凌晨十二点半统计某个互联网金融公司一款借款APP前一天的借款、还款以及逾期情况）需要在指定时间内执行或者周期性执行某个任务（比如每月最后一天统计这个 月的财务报表给财务部门等），这时候我们就需要用到任务调度框架了。Quartz正是一个炙手可热的任务调度框架，它简单易上手，并且可以与Spring集成（这才是重点）。 ...
51 单片机简单的多任务调度例子
phenixyf的专栏
06-05 8010
看大家都在学操作系统，我也想学学。所以想用51写一个来玩玩，发现比较郁闷。     弄了几下，不想再弄了，51弄这个没啥意思。我用的89S52，除了速度慢，RAM资源太少之外，其它都还过得去。弄了一点代码出来，放在那也没啥用，不如拿上来给新手看看，一个任务调度的雏形是什么样子的~~~~~~~~~这些代码没有经过优化， 我只求实现任务切换的功能。     利用定时器2产生10mS的定时中
手把手教你设计一个任务调度器
LuckyWinty的博客
07-08 1405
我们从业务现状出发，考虑需要覆盖的场景，设计调度器需要提供的角色。然后确定了调度器的关键接口，同时给出了简单实现。同时，也提到一些个人设计和实现时候的一些思考，比如多叉树和有向无环图。另外...
laravel 获取job数据
leo09999的博客
04-09 1343
业务场景 开发移动端使用的API 测试环境使用同步机制：QUEUE_DRIVER=sync 正式环境使用异步机制：QUEUE_DRIVER=rabbitmq job 中 handle() 方法执行【请求第三方接口 third_api】 为了方便开发环境调试，接口需要输出third_api是否执行成功。 如果执行失败，说明移动端传输的字段结构有问题，他们可自行排查/解决问题 但是，job中怎...
一个简单的任务调度
nomoney_boy的专栏
09-01 212
import static java.util.concurrent.TimeUnit.SECONDS; import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.ScheduledFuture; public clas...
Laravel 新增一条记录并且获取id
热门推荐
wei的博客
06-10 2万+
Use App/Models/UserFolder; $insertArr=['fid'=>0,'name'=>'文件夹']; // $insertId = UserFolder::getInsertId($insertArr); // 更正-2019-6-5 $insertId = UserFolder::insertGetId($insertArr); ...
Ucosii任务调度
qq_25355591的博客
03-28 542
为了提高查找任务就绪表的速度，建立了一个常量数组和任务就绪表，如图： 图1 图2 图1是从rt-thread中截取的，没错rt-thread的任务调度就是模仿ucosii的。如果没有常量表，在不用前导0命令CLZ的情况下，只能通过循环的形式搜索就绪表中的最高任务优先级。所以个人认为搜索任务的实时性受到微小干扰，是否影响实时性还有待继续深究。Freertos是实时跟踪最高优先级就绪任务，搜索最高优先级就绪任务时只判断该优先级列表是否为空（几乎不可能出现），为空就往下一级，所以freertos不用
使用quartz实现简单任务调度案例
I_Table的博客
03-26 276
第一步，引入jar包 <!--任务调度框架quartz--> <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artif
spring boot 实现定时任务调度
最新发布
04-25
Spring Boot提供了一种简单而强大的方式来实现定时任务调度。下面是使用Spring Boot实现定时任务调度的步骤： 1. 添加依赖：在`pom.xml`文件中添加Spring Boot的定时任务依赖： ```xml <groupId>org.spring...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值