在java中，调度程序在凌晨12点执行同一任务两次。

Question

我已经创建了一个使用线程的调度程序。这个调度程序的主要动机是在每天上午12点执行一个特定的任务。但它似乎在执行同一任务两次(不确定，看起来像是两个不同的线程同时执行)。

ScheduledTask.java

package com.abc.advertising.scheduler;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.sql.DataSource;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import com.heb.advertising.service.ReportEmail;
import com.heb.advertising.service.ReportService;

@Component
public class ScheduledTask {

private static final Logger LOG = Logger.getLogger(ScheduledTask.class.getName());

@Autowired
@Qualifier(value="ReportService")
private ReportService reportService;
@Autowired
@Qualifier(value="reportEmail")
private ReportEmail reportEmail;
SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
public static Date primaryDate=null;
public Date existDate;
@PostConstruct
public void scheduledTask(){
    //System.out.println("Hii Scheduled!!");
    Calendar timeOfDay = Calendar.getInstance();
    timeOfDay.set(Calendar.HOUR_OF_DAY, 00);
    timeOfDay.set(Calendar.MINUTE,30);
    timeOfDay.set(Calendar.SECOND, 00);

    new DailyRunnerDaemon(timeOfDay, new Runnable()
    {
       @Override
       public void run()
       {
          try
          {
              reportService.initScheduled();
          }
          catch(Exception e)
          {
            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw);
            e.printStackTrace(pw);
            reportEmail.sentErrorEmail("PA",sw.toString());
              LOG.error("An error occurred performing daily Scheduled Task", e);
          }
       }
    }, "Scheduled-Task").start();
}
}

DailyRunnerDaemon.java

package com.abc.advertising.scheduler;

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class DailyRunnerDaemon
{
private final Runnable dailyTask;
private final int hour;
private final int minute;
private final int second;
private final String runThreadName;

public DailyRunnerDaemon(Calendar timeOfDay, Runnable dailyTask, String    runThreadName)
{
  this.dailyTask = dailyTask;
  this.hour = timeOfDay.get(Calendar.HOUR_OF_DAY);
  this.minute = timeOfDay.get(Calendar.MINUTE);
  this.second = timeOfDay.get(Calendar.SECOND);
  this.runThreadName = runThreadName;
}

public void start()
{
  startTimer();
}

private void startTimer()
{
  new Timer(runThreadName, true).schedule(new TimerTask()
  {
     @Override
     public void run()
     {
        dailyTask.run();
        startTimer();
     }
  }, getNextRunTime());
}


private Date getNextRunTime()
{
  Calendar startTime = Calendar.getInstance();
  Calendar now = Calendar.getInstance();
  startTime.set(Calendar.HOUR_OF_DAY, hour);
  startTime.set(Calendar.MINUTE, minute);
  startTime.set(Calendar.SECOND, second);
  startTime.set(Calendar.MILLISECOND, 0);

  if(startTime.before(now) || startTime.equals(now))
  {
     startTime.add(Calendar.DATE, 1);
  }

  return startTime.getTime();
}
}

ApplicationConfiguration.java

package com.abc;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executor;

import javax.sql.DataSource;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.embedded.FilterRegistrationBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.web.SpringBootServletInitializer;
import org.springframework.boot.orm.jpa.EntityScan;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.PropertySource;
import     org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import     org.springframework.context.support.ReloadableResourceBundleMessageSource;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import  org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor;
import org.springframework.orm.jpa.vendor.HibernateJpaDialect;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.filter.DelegatingFilterProxy;
import org.springframework.web.multipart.support.MultipartFilter;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.view.ContentNegotiatingViewResolver;
import org.springframework.web.servlet.view.json.MappingJackson2JsonView;

import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.S3ClientOptions;
import com.jolbox.bonecp.BoneCPDataSource;

/**
 * Application configuration in JavaConfig (replacing what would be the     web.xml and spring-context.xml).
 */
@EnableTransactionManagement()
@EnableJpaRepositories(basePackages=     {"com.abc"},entityManagerFactoryRef="entityManagerFactoryBean")
@ComponentScan({"com.abc"})
@EnableJpaAuditing
@EntityScan(basePackages={"com.abc.advertising.entity"})
@SpringBootApplication(exclude = {RabbitAutoConfiguration.class})
        @PropertySource("classpath:application-${spring.profiles.active}.properties")
public class ApplicationConfiguration extends SpringBootServletInitializer{

private static final String DATABASE =     "org.hibernate.dialect.Oracle10gDialect";

private static final String PUNIT_LOCATION = "classpath:META-    INF/persistence.xml";

private static final String PUNIT = "punit";

private static final String V2_AUTH_SIGNER = "S3SignerType";

private static Logger LOG =     Logger.getLogger(ApplicationConfiguration.class.getName());

private @Value("${cloud.aws.credentials.accessKey}") String accessKey;
private @Value("${cloud.aws.credentials.secretKey}") String secretKey;
private @Value("${cloud.aws.s3.endpoint}") String s3endpoint;

/**
 * Spring Boot Runner.
 *
 * @param args Optional parameters from command-line.
 */
public static void main(String[] args) {
    LOG.info("ApplicationConfiguration ....");
    PropertySourcesPlaceholderConfigurer     propertySourcesPlaceholderConfigurer = propertyPlaceholderConfigurer();
    SpringApplication.run(ApplicationConfiguration.class, args);
 }

@Bean
 public static PropertySourcesPlaceholderConfigurer propertyPlaceholderConfigurer() {
     PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new       PropertySourcesPlaceholderConfigurer();
     return propertySourcesPlaceholderConfigurer;
 }

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder    application) {
    return application.sources(ApplicationConfiguration.class);
}

@Bean
public MessageSource messageSource() {
    ReloadableResourceBundleMessageSource messageSource = new  ReloadableResourceBundleMessageSource();
    messageSource.setBasenames("classpath:/messages");
    messageSource.setDefaultEncoding("UTF-8");
    messageSource.setCacheSeconds(3600);
    messageSource.setConcurrentRefresh(true);
    return messageSource;
}

 private @Value("${spring.datasource.primary.driver-class-name}") String        driverClassName;
 private @Value("${spring.datasource.primary.url}") String primaryDataSourceURL;
 private @Value("${spring.datasource.primary.username}") String primaryDataSourUserName;
 private @Value("${spring.datasource.primary.password}") String primaryDataSourUserPassword;
 @Bean(name="promoDataSource")
 @Primary
 public DataSource primaryDataSource() {
   BoneCPDataSource dataSource = new BoneCPDataSource();
   dataSource.setDriverClass(driverClassName);
   dataSource.setJdbcUrl(primaryDataSourceURL);
   dataSource.setUsername(primaryDataSourUserName);
   dataSource.setPassword(primaryDataSourUserPassword);

   dataSource.setIdleConnectionTestPeriodInMinutes(60);
   dataSource.setIdleMaxAgeInSeconds(300);
   dataSource.setMaxConnectionsPerPartition(100);
   dataSource.setMinConnectionsPerPartition(10);
   dataSource.setPartitionCount(3);
   dataSource.setAcquireRetryDelayInMs(10000);
   dataSource.setAcquireIncrement(5);
   dataSource.setStatementsCacheSize(100);
   dataSource.setReleaseHelperThreads(5);
   dataSource.setConnectionTimeoutInMs(6000000);
   dataSource.setServiceOrder("FIFO");
   dataSource.setDefaultAutoCommit(true);

   return dataSource;
 }

@Bean
@ConfigurationProperties(prefix = "datasource.arbaf")
public DataSource secondaryDataSource() {
    return DataSourceBuilder.create().build();
}

@Bean(name="transactionManager")
public JpaTransactionManager jpaTransactionManager() {
    JpaTransactionManager transactionManager = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(entityManagerFactoryBean().getObject());
    transactionManager.setDataSource(primaryDataSource());
    transactionManager.setJpaDialect(getHibernateJpaDialect());
    return transactionManager;
}

private HibernateJpaDialect getHibernateJpaDialect(){
    HibernateJpaDialect promoPlannerJpaDialect = new HibernateJpaDialect();
    return promoPlannerJpaDialect;
}

 private HibernateJpaVendorAdapter vendorAdaptor() {
    HibernateJpaVendorAdapter vendorAdapter = new     HibernateJpaVendorAdapter();
    vendorAdapter.setDatabasePlatform(DATABASE);
    vendorAdapter.setShowSql(false);
    vendorAdapter.setGenerateDdl(false);
    return vendorAdapter;
}

@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() {
 LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new  LocalContainerEntityManagerFactoryBean();
    entityManagerFactoryBean.setJpaVendorAdapter(vendorAdaptor());
    entityManagerFactoryBean.setDataSource(primaryDataSource());
   /*  entityManagerFactoryBean.setPersistenceProviderClass(HibernatePersistenceProvider.class);*/
    entityManagerFactoryBean.setPackagesToScan(getClass().getPackage().getName());             
   /* entityManagerFactoryBean.setJpaProperties(jpaHibernateProperties());*/
   entityManagerFactoryBean.setPersistenceXmlLocation(PUNIT_LOCATION);
   entityManagerFactoryBean.setPersistenceUnitName(PUNIT);
    entityManagerFactoryBean.setLoadTimeWeaver(new  InstrumentationLoadTimeWeaver());
    return entityManagerFactoryBean;
}

public PersistenceAnnotationBeanPostProcessor  getPersistenceAnnotationBeanPostProcessor(){
   return new PersistenceAnnotationBeanPostProcessor();
}
/*
 * Reorder the filters so that the multipart filter resolves before the  spring security filter as prescribe
 * by Spring when trying to handle those types of requests.
 */

@Bean
public FilterRegistrationBean multipartFilterRegistration() {
    FilterRegistrationBean registration =
            new FilterRegistrationBean(new MultipartFilter());
    registration.setOrder(0);
    return registration;
}

@Bean
public FilterRegistrationBean springSecurityFilterRegistration() {
    FilterRegistrationBean registrationBean =
            new FilterRegistrationBean(new DelegatingFilterProxy("springSecurityFilterChain"));
    registrationBean.setOrder(1);
    return registrationBean;
}
@Bean
public ContentNegotiatingViewResolver contentNegotiatingViewResolver() {
    ContentNegotiatingViewResolver contentNegotiatingViewResolver = new ContentNegotiatingViewResolver();
    contentNegotiatingViewResolver.setOrder(1);
    Map<String,String> m=new HashMap<String,String>();
    m.put("json", "application/json");
    m.put("file", "application/vnd.ms-excel");
    contentNegotiatingViewResolver.setMediaTypes(m);
    List<View> list=new ArrayList<>();
    list.add(new MappingJackson2JsonView());
    contentNegotiatingViewResolver.setDefaultViews(list);
     return contentNegotiatingViewResolver;
 }
}

Answer 1

您正在使用Spring/SpringBoot，您的组件正在定期运行任务，您应该考虑使用@Scheduled(cron="0 0 0* *")