スケジューラは同じタスクをJavaで午前12時に2回実行します

Question

スレッドを使用してスケジューラを作成しました。このスケジューラーの主な動機は、毎日午前12時に特定のタスクを実行することです。しかし、同じタスクを2回実行しているようです（確かではありませんが、2つの異なるスレッドが同時に実行しているようです）。

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

あなたは、あなたがしなければならない、あなたのコンポーネントが定期的にタスクを実行している、春/ SpringBootを使用しています@Scheduled（cron = "0 0 0 0 * *"）の使用を検討する