Java 当前的工作正在增加

我已经用quartz创建了一个示例程序。其中主程序将触发一个控制器作业，该作业每3秒运行一次，我已从该控制器计划了一个作业，以cron计划运行

我的要求是，如果作业的一个实例正在运行，那么下一个实例不应该启动。因此，我迭代了当前活动作业的调度程序上下文中的jobcontext列表，检查与当前作业实例匹配的作业实例是否存在，然后返回

为了测试这一点，我在各自的作业中实现了一个线程睡眠，该睡眠时间超过了预定时间。作业实例未按预期并行触发，但我的计划程序上下文当前活动作业列表正在不断增加。我需要帮助减少/保持检查当前活动作业的大小

我的程序如下

主程序：

package com.test.objectpool;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class CronTriggerExample {

    public static void main(String[] args) throws Exception {
        JobDetail job = JobBuilder.newJob(QuartzSchedulerController.class).withIdentity("job-a-cntrl", "group.12-1")
                .build();
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger.1", "group.12-1")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever()).build();

        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.start();
        scheduler.scheduleJob(job, trigger);

    }
}

控制器作业：

package com.test.objectpool;

import org.quartz.CronScheduleBuilder;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;

public class QuartzSchedulerController implements Job {

    public void execute(JobExecutionContext context) {

        try {
            context.getScheduler().getCurrentlyExecutingJobs().forEach(job -> {
                if (job.getTrigger().equals(context.getTrigger()) && !job.getJobInstance().equals(this)) {
                    System.out.println("There's another instance running crontroller , so leaving" + this);
                    return;
                }
            });

            Thread.sleep(4000);
            System.out.println("Inside scheduler controller --- >> ");
            Scheduler scheduler = context.getScheduler();

            JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity("hello-1.1", "group1-1.2").build();
            JobKey jbK = job.getKey();
            System.out.println("Job key is " + jbK);
            if (!scheduler.checkExists(jbK)) {
                System.out.println("Scheduling hellow world -----");
                Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger.1", "group1-1.2").withSchedule(
                        CronScheduleBuilder.cronSchedule("0/2 * * * * ?").withMisfireHandlingInstructionDoNothing())
                        .build();

                scheduler.scheduleJob(job, trigger);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

最后，由控制器控制的作业类是：

package com.test.objectpool;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.UUID;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.SchedulerException;

public class HelloJob implements Job {
    private static int count = 0;

    public void execute(JobExecutionContext context) throws JobExecutionException {

        try {
            List<JobExecutionContext> jobs = context.getScheduler().getCurrentlyExecutingJobs();
            System.out.println("The size of the job queue is " + jobs.size());
            for (JobExecutionContext job : jobs) {
                if (job.getTrigger().equals(context.getTrigger()) && !job.getJobInstance().equals(this)) {
                    System.out.println("There's another instance running, so leaving" + this);
                    return;
                }

            }
            Date dt = Calendar.getInstance().getTime();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss.SSS");
            String uniqueID = UUID.randomUUID().toString();
            System.out.println("Hello Quartz!" + context.getScheduledFireTime() + " :With count " + count
                    + " :Current date " + sdf.format(dt) + " UUID =" + uniqueID);

            Thread.sleep(10000);
            // System.out.println("Hello Quartz!"+
            // context.getScheduledFireTime());

            System.out.println("Completed " + "With count " + count + " UUID : " + uniqueID);
            count++;
        } catch (SchedulerException | InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
    }

}

package com.test.objectpool；
导入java.text.simpleDataFormat；
导入java.util.Calendar；
导入java.util.Date；
导入java.util.List；
导入java.util.UUID；
导入org.quartz.Job；
导入org.quartz.JobExecutionContext；
导入org.quartz.JobExecutionException；
导入org.quartz.SchedulerException；
公共类HelloJob实现作业{
私有静态整数计数=0；
public void execute（JobExecutionContext上下文）引发JobExecutionException{
试一试{
列表作业=context.getScheduler（）.getCurrentlyExecutingJobs（）；
System.out.println（“作业队列的大小为”+jobs.size（））；
for（JobExecutionContext作业：作业）{
if（job.getTrigger（）.equals（context.getTrigger（））&&！job.getJobInstance（）.equals（this））{
System.out.println（“有另一个实例正在运行，所以留下“+this”）；
返回；
}
}
Date dt=Calendar.getInstance（）.getTime（）；
SimpleDataFormat sdf=新的SimpleDataFormat（“yyyyMMddHHmmss.SSS”）；
字符串uniqueID=UUID.randomUUID（）.toString（）；
System.out.println（“Hello Quartz！”+context.getScheduledFileTime（）+”：带count+count
+“：当前日期”+sdf.format（dt）+“UUID=“+uniqueID”）；
睡眠（10000）；
//System.out.println（“你好，石英！”+
//getScheduledRetime（））；
System.out.println（“已完成”+，带有计数“+count+”UUID:“+uniqueID”）；
计数++；
}捕获（ScheduleException | InterruptedException e1）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
}
}

---

问题是，使用这种方法，

context.getScheduler（）.getCurrentlyExecutingJobs（）

会不断增加。

只需使用如下注释您的作业：

@DisallowConcurrentExecution
public class QuartzSchedulerController implements Job {
    ...

Quartz将负责不运行超过1个实例

将

作业

类标记为不能同时执行多个实例的注释（其中实例基于

作业详细信息

定义，或者换句话说，基于

作业关键字

）