자바 정시 작업 의 몇 가지 실현 방식

27533 단어 JAVA
JAVA 가 정시 임 무 를 수행 하 는 몇 가지 방식
@(JAVA)[spring|quartz|타이머]최근 프로젝트 개발 에 서 는 특정한 이벤트 가 끝 날 때 수상 명단 을 자동 으로 생 성하 고 엑셀 을 내 보 내 는 등 동적 으로 시간 임 무 를 추가 해 야 합 니 다.이러한 임 무 는 활동 시간 이 동적 이기 때문에 시간 임 무 를 설정 파일 에 설정 하거나 코드 에 기록 할 수 없습니다.물론 정기 적 으로 스 캔 하 는 임 무 를 추가 해서 실현 할 수도 있다.이번 기회 에 AVA 가 정시 임 무 를 수행 하 는 데 자주 사용 되 는 몇 가지 방식 을 정리 해 간략하게 소개 한다.현 재 는 주로 다음 과 같은 몇 가지 실현 방식 이 있다.-JDK 자체 테이프:JDK 자체 테이프 의 Timer 와 JDK 1.5+새로 추 가 된 Scheduled Executor Service;-Quartz:간단 하면 서도 강력 한 JAVA 작업 스케줄 링 프레임 워 크-Spring 3.0 이후 자체 적 으로 가 져 온 task:경량급 Quartz 로 볼 수 있 고 Quartz 보다 훨씬 간단 합 니 다.다음은 상기 세 가지 실현 방식 을 일일이 소개 할 것 이다.
  • JAVA 가 정시 임 무 를 실현 하 는 몇 가지 방식
  • JDK 자체 의 타이머 가
  • 을 실현 합 니 다.
  • Quartz 타이머
  • 실현
  • Spring 관련 임무 스케줄

  • JDK 자체 타이머 구현
  • Timer 클래스 는 자바 util.Timer Task 작업 을 예약 할 수 있 습 니 다.주로 다음 과 같은 몇 가지 방법 이 있다.
  • 
    1. schedule(TimerTask task, long delay)    delay      
    public static void main(String[] args) {
            for (int i = 0; i < 10; ++i) {
                new Timer("timer - " + i).schedule(new TimerTask() {
                    @Override
                    public void run() {
                        println(Thread.currentThread().getName() + " run ");
                    }
                }, 1000);
            }
        }
    out :
    timer - 2 run 
    timer - 1 run 
    timer - 0 run 
    timer - 3 run 
    timer - 9 run 
    timer - 4 run 
    timer - 8 run 
    timer - 5 run 
    timer - 6 run 
    timer - 7 run 
    
    2. schedule(TimerTask task, Date time)       
    public static void main(String[] args) {
            for (int i = 0; i < 10; ++i) {
                new Timer("timer - " + i).schedule(new TimerTask() {
                    @Override
                    public void run() {
                        println(Thread.currentThread().getName() + " run ");
                    }
                }, new Date(System.currentTimeMillis() + 2000));
            }
        }
    out:
    timer - 0 run 
    timer - 7 run 
    timer - 6 run 
    timer - 8 run 
    timer - 3 run 
    timer - 5 run 
    timer - 2 run 
    timer - 1 run 
    timer - 4 run 
    timer - 9 run 
    
    3. schedule(TimerTask task, long delay, long period)    delay      period     
    public static void main(String[] args) {
            for (int i = 0; i < 10; ++i) {
                new Timer("timer - " + i).schedule(new TimerTask() {
                    @Override
                    public void run() {
                        println(Thread.currentThread().getName() + " run ");
                    }
                }, 2000 , 3000);
            }
        }
    out:
    timer - 0 run 
    timer - 5 run 
    timer - 4 run 
    timer - 8 run 
    timer - 3 run 
    timer - 2 run 
    timer - 1 run 
    timer - 7 run 
    timer - 9 run 
    timer - 6 run 
    timer - 3 run 
    timer - 7 run 
    timer - 5 run 
    timer - 4 run 
    timer - 8 run 
  • Scheduled Executor Service 인터페이스 실현 류 Scheduled Executor Service 는 JAVA 1.5 이후 추 가 된 정시 작업 인터페이스 로 주로 다음 과 같은 몇 가지 방법 이 있다.
  • - ScheduledFuture> schedule(Runnable command,long delay, TimeUnit unit);
    -  ScheduledFuture schedule(Callable callable,long delay, TimeUnit unit);
    - ScheduledFuture> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnitunit);
    - ScheduledFuture> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnitunit);

    기본적으로 Scheduled ThreadPoolExecutor 로 구현 되 었 습 니 다.ThreadPoolExecutor 의 스 레 드 풀 특성 을 계승 하여 future 특성 에 맞 춰 Timer 보다 더 강력 합 니 다.구체 적 인 용법 은 JDK 문 서 를 읽 을 수 있다.spring Task 。예제 코드:
    public static void main(String[] args) throws SchedulerException {
            ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(10);
            for (int i = 0; i < 10; ++i) {
                executor.schedule(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + " run ");
                    }
                } , 2 , TimeUnit.SECONDS);
            }
            executor.shutdown();
        }
    
    out:
    pool-1-thread-2 run 
    pool-1-thread-5 run 
    pool-1-thread-4 run 
    pool-1-thread-3 run 
    pool-1-thread-8 run 
    pool-1-thread-5 run 
    pool-1-thread-7 run 
    pool-1-thread-2 run 
    pool-1-thread-1 run 
    pool-1-thread-6 run 

    Quartz 타이머 구현
    Quartz 는 자바 가 완전히 작성 한 오픈 소스 작업 스케줄 링 프레임 워 크 로 자바 응용 프로그램 에서 작업 스케줄 링 을 하 는 데 간단 하면 서도 강력 한 메커니즘 을 제공 합 니 다.Quartz 는 개발 자 들 이 시간 간격 에 따라 작업 을 스케줄 링 할 수 있 도록 허용 한다.그것 은 작업 과 트리거 의 여러 쌍 의 관 계 를 실현 하고 여러 작업 을 서로 다른 트리거 와 연결 시 킬 수 있다. 。org.quarz.Job 인터페이스의 자바 류 를 간단하게 만 듭 니 다.Job 인 터 페 이 스 는 유일한 방법 을 포함 합 니 다.
    public void execute(JobExecutionContext context) throws JobExecutionException;
    

    Job 인터페이스 구현 클래스 에 필요 한 논 리 를 execute()방법 에 추가 합 니 다.Job 구현 클래스 를 설정 하고 스케줄 링 시간표(Trigger)를 설정 하면 Quartz 는 자동 으로 설 정 된 시간 스케줄 링 작업 에서 execute()를 실행 합 니 다.
    Quartz 를 통합 한 응용 프로그램 은 서로 다른 이벤트 의 작업 을 다시 사용 할 수 있 고 하나의 이벤트 에 여러 작업 을 조합 할 수 있 습 니 다.Quartz 는 속성 파일 을 통 해 JDBC 트 랜 잭 션 의 데이터 원본,전역 작업,트리거 디텍터,플러그 인,스 레 드 풀 등 을 설정 합 니 다.(quartz.properties)
  • Maven 을 통 해 의존 도입(여기 서 주로 2.3.0 을 소개 합 니 다)주의:shiro-scheduler 1.x
  • 
            <dependency>
                <groupId>org.quartz-schedulergroupId>
                <artifactId>quartzartifactId>
                <version>2.3.0version>
            dependency>
  • Job 류
  • 만 들 기
    public class TestJob implements Job{
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            println(Thread.currentThread().getName() + " test job begin " + DateUtil.getCurrentTimeStr());
        }
    }
  • 스케줄 링 임무
  • public static void main(String[] args) throws InterruptedException, SchedulerException {
    
            Scheduler scheduler = new StdSchedulerFactory().getScheduler();
            //   
            scheduler.start();
            // job      test.test-1
            JobKey jobKey = new JobKey("test" , "test-1");
            JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("test" , "test")
                    //       
                    .startAt(new Date(System.currentTimeMillis() + 1000))
                    //             
            .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
                    .build();
            scheduler.scheduleJob(jobDetail , trigger);
    
            Thread.sleep(5000);
            //   job
            scheduler.deleteJob(jobKey);
        }
    
    out :
    DefaultQuartzScheduler_Worker-1test job begin 2017-06-03 14:30:33
    DefaultQuartzScheduler_Worker-2test job begin 2017-06-03 14:30:34
    DefaultQuartzScheduler_Worker-3test job begin 2017-06-03 14:30:35
    DefaultQuartzScheduler_Worker-4test job begin 2017-06-03 14:30:36
    DefaultQuartzScheduler_Worker-5test job begin 2017-06-03 14:30:37
    Quartz
    Job:하나의 인터페이스 입 니 다.하나의 방법 만 void execute(JobExecution Context
    context)개발 자 는 이 인터페이스 에서 실행 작업 을 정의 합 니 다.JobExecutionContext 류 는 컨 텍스트 를 관리 하 는 다양한 정 보 를 제공 합 니 다.Job 이 실 행 될 때의 정 보 는 JobDataMap 인 스 턴 스 에 저 장 됩 니 다.
    JobDetail:Quartz 는 Job 을 실행 할 때마다 Job 인 스 턴 스 를 다시 만 들 기 때문에 Job 의 인 스 턴 스 를 직접 받 아들 이지 않 고,반대로 Job 구현 클래스 를 받 아들 여 실행 할 때 new Instance()의 반사 체 제 를 통 해 Job 을 예화 합 니 다.따라서 하나의 클래스 를 통 해 Job 의 실현 클래스 와 다른 정적 정 보 를 묘사 해 야 한다.예 를 들 어 Job 이름,설명,관련 감청 기 등 정 보 는 JobDetail 이 이 역할 을 맡 았 다.
    Trigger:Job 이 실행 하 는 시간 트리거 규칙 을 설명 하 는 클래스 입 니 다.주로 Simple Trigger 와 Cron Trigger 두 가지 키 가 있 습 니 다.한 번 만 터치 하거나 고정 시간 간격 으로 실행 하면 Simple Trigger 가 가장 적합 한 선택 입 니 다.한편,CronTrigger 는 Cron 표현 식 을 통 해 각종 복잡 한 시간 규칙 의 스케줄 링 방안 을 정의 할 수 있다.예 를 들 어 아침 9 시 에 실행 되 고 월요일,수요일,금요일 오후 5 시 에 실행 되 는 등 이다.
    Calendar:org.quartz.Calendar 는 자바 util.Calendar 와 달리 달력 의 특정 시간 대의 집합 입 니 다.하나의 Trigger 는 시간 대 를 제외 하거나 포함 할 수 있 도록 여러 개의 Calendar 와 연결 할 수 있 습 니 다.만약 에 우리 가 매주 월요일 오전 10 시 에 임 무 를 수행 하도록 배정 하지만 법정 명절 에 부 딪 히 면 임 무 를 수행 하지 않 는 다 면 이 때 는 Trigger 트리거 체 제 를 바탕 으로 Calendar 를 사용 하여 정기 적 으로 제거 해 야 한다.
    Scheduler:Quartz 를 대표 하 는 독립 적 인 실행 용기 입 니 다.Trigger 와 JobDetail 은 Scheduler 에 등록 할 수 있 습 니 다.둘 은 Scheduler 에서 각자 의 그룹 과 이름 을 가지 고 있 습 니 다.그룹 과 이름 은 Scheduler 가 포 지 셔 닝 용기 의 특정한 대상 을 찾 는 근거 입 니 다.Trigger 의 그룹 과 이름 은 하나 여야 합 니 다.JobDetail 의 그룹 과 이름 도 유일 해 야 합 니 다(단,Trigger 의 그룹 과 이름 이 같 을 수 있 습 니 다.유형 이 다 르 기 때문이다.Scheduler 는 여러 개의 인터페이스 방법 을 정의 하여 외부 에서 그룹 및 이름 을 통 해 용기 의 Trigger 와 JobDetail 에 접근 하고 제어 할 수 있 도록 합 니 다.
    Scheduler 는 Trigger 를 특정한 JobDetail 에 연결 할 수 있 습 니 다.이렇게 하면 Trigger 가 트리거 할 때 해당 하 는 Job 이 실 행 됩 니 다.하나의 Job 은 여러 개의 Trigger 에 대응 할 수 있 지만 하나의 Trigger 는 하나의 Job 에 만 대응 할 수 있 습 니 다.Scheduler Factory 를 통 해 Scheduler 인 스 턴 스 를 만 들 수 있 습 니 다.Scheduler 는 ServletContext 와 유사 한 Scheduler 컨 텍스트 정 보 를 저장 하고 있 으 며,Job 과 Trigger 는 Scheduler Context 내 정 보 를 방문 할 수 있 습 니 다.SchedulerContext 내 부 는 하나의 Map 을 통 해 키 값 이 맞 는 방식 으로 컨 텍스트 데 이 터 를 유지 합 니 다.SchedulerContext 는 데 이 터 를 저장 하고 가 져 오 는 데 여러 개의 put()와 getXxx()방법 을 제공 합 니 다.스케줄 러 를 통 해#
    getContext()에 대응 하 는 SchedulerContext 인 스 턴 스 가 져 오기;
    ThreadPool:Scheduler 는 하나의 스 레 드 탱크 를 작업 수행 의 인 프 라 로 사용 하고 임 무 는 스 레 드 탱크 의 스 레 드 를 공유 하여 운행 효율 을 높 인 다. , quartz example, 。
    Quartz 정시 퀘 스 트 학습(1)간단 한 퀘 스 트 Quartz 정시 퀘 스 트 학습(2)웹 응용 Quartz 정시 퀘 스 트 학습(3)속성 파일 과 jar 이하 추천 블 로그 주소 quartz 상세 설명 2:quartz 는 얕 은 것 에서 깊 은 것 으로 들어간다.
    Spring 관련 작업 스케줄 링
  • Spring 3.0+자체 테이프 의 임무 배정 실현 은 주로 TaskScheduler 인터페이스의 몇 가지 실현 유형 에 의 해 이 루어 진다. 의 주요 용법 은 다음 과 같은 세 가지 가 있다.
  • Spring 프로필
  • 실현
  • 주해
  • 실현
  • 코드 동적 추가
  • spring-schedule.xml
    
    <task:scheduler id="myScheduler" pool-size="10" />
    <task:scheduled-tasks scheduler="myScheduler">
        <task:scheduled ref="job" method="test" cron="0 * * * * ?"/>
    </task:scheduled-tasks>
    spring-schedule.xml
    <task:scheduler id="myScheduler" pool-size="10" />
    //     
    <task:annotation-driven scheduler="myScheduler"/> 
    @Component  
    public class Task{  
    
           @Scheduled(cron="0/5 * *  * * ? ")   // 5            
           public void execute(){     
                 DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    
                 System.out.println(sdf.format(DateTime.now().toDate())+"*********B   5         ");      
           }      
    }  
    spring-schedule.xml
    
    id = "myScheduler" class="org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler">
            <property name="poolSize" value="10"/>
            <property name="threadGroupName" value="myScheduler" />
            <property name="threadNamePrefix" value="-1" />
    
    "myScheduler"/> 
    @Component
    public class Test {
    
        @Autowired
        private ThreadPoolTaskScheduler myScheduler;
    
        public void addJob(){
    
            myScheduler.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " run ");
                }
            } , new CronTrigger("0/5 * *  * * ? ")); // 5     
        }
    }
  • spring 과 quartz 를 결합 하여 임무 스케줄 링 을 실현 하 다
  • spring 프로필 spring-quartz.xml
  • <bean id="quartzsScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false">
            <property name="triggers">
                <list>
                <ref bean="testTrigger" />
                list>
            property>
    bean>
    
    
    <bean id="testJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
                  <property name="jobClass">
                         <value>com.test.TestJobvalue>
                  property>
                  <property name="durability" value="true" />
                  
                  <property name="requestsRecovery" value="true" />
    bean>
    <bean id="testTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
                  <property name="jobDetail" ref="testJobDetail" />
                  <property name="cronExpression" value="0 0 10 * * ?" />
    bean>

    동적 추가 삭제
    @Component
    public class Test {
    
        @Autowired
        private SchedulerFactoryBean quartzScheduler;
    
        public void addJob() throws SchedulerException {
    
            Scheduler scheduler = quartzScheduler.getScheduler();
            JobKey jobKey = new JobKey("test", "test");
            if (scheduler.checkExists(jobKey)) {
                return;
            }
            JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("test", "test")
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever()).build();
            scheduler.scheduleJob(jobDetail, trigger);
        }
    }

    이상 은 단지 자신의 학습 에 대한 총 결 일 뿐 이 고 깊이 이해 하려 면 관련 자 료 를 찾 아야 한다.예 를 들 어 동적 증가,정시 작업 수정.그리고 Quartz 의 클 러 스 터 모델 등.

    좋은 웹페이지 즐겨찾기