zoukankan      html  css  js  c++  java
  • 分布式job-任务调度(一)

    什么是任务调度:

    任务调度:在单位时间内,去调用某个方法或者执行某段代码

    java实现方式:

    方法一(使用线程实现):

        public static void ThreadTskScheduling() {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            Thread.sleep(2000);
                            System.out.println("执行一次:" + count++);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
                }
            }).start();
        }

    方法二(使用timerTask):

    public static void timerTaskTskScheduling() {
            TimerTask timerTask = new TimerTask() {
                @Override
                public void run() {
                    // 执行任务代码
                    System.out.println("执行一次:" + count++);
                }
            };
    
            Timer timer = new Timer();
            // 任务执行前的毫秒延迟。
            long delay = 0;
            // 间隔的秒数
            long period = 1000;
            timer.scheduleAtFixedRate(timerTask, delay, period);
        }

    方法三(使用定时线程池):

    public static void ExecutorsTaskTskScheduling() {
            Runnable runnable = new Runnable() {
                public void run() {
                    System.out.println("执行一次:" + count++);
                }
            };
            // 定时线程池
            ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
            // 第二个参数为首次执行的延时时间,第三个参数为定时执行的间隔时间,最后表示时间单位  表示启动以后延迟5秒执行,执行间隔是1秒
            service.scheduleAtFixedRate(runnable, 5, 1, TimeUnit.SECONDS);
        }

    方法四(使用springboot自带的定时任务):

    package com.springboot;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.annotation.EnableScheduling;
    //整合常见注解,扫包作用(当前同级目录)
    @SpringBootApplication
    @EnableAsync 
    @EnableScheduling   // 2.开启定时任务
    public class App {
        public static void main(String[] args) {
            SpringApplication.run(App.class, args);
        }
    }
    package com.springboot.scheduledtasks;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    @Component
    public class ScheduledTasks {
        private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
    
        @Scheduled(fixedRate = 5000)
        public void reportCurrentTime() {
            System.out.println("任务1:" + dateFormat.format(new Date()));
        }
    
    }

     实现方式五(使用quartz):

    package com.example.demo;
    
    import java.util.Date;
    
    import org.quartz.CronScheduleBuilder;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.Trigger;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    
    public class JobStart {
        public static void main(String[] args) throws SchedulerException {
            // https://www.w3cschool.cn/quartz_doc/quartz_doc-jop62d45.html
            // 1.创建Scheduler的工厂
            SchedulerFactory sf = new StdSchedulerFactory();
            // 2.从工厂中获取调度器实例
            Scheduler scheduler = sf.getScheduler();
    
            // 3.创建JobDetail
            JobDetail jb = JobBuilder.newJob(MyJob.class).withDescription("jiahou.quartz") // job的描述
                    .withIdentity("jiahou", "jiahouJob") // job 的name和group
                    .build();
    
            // 任务运行的时间,SimpleSchedle类型触发器有效
            long time = System.currentTimeMillis() + 3 * 1000L; // 3秒后启动任务
            Date statTime = new Date(time);
            // 4.创建Trigger
            Trigger t = TriggerBuilder.newTrigger().withDescription("").withIdentity("ramTrigger", "ramTriggerGroup")
                    .startAt(statTime) // 默认当前时间启动
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")) // 两秒执行一次
                    .build();
    
            // 5.注册任务和定时器
            scheduler.scheduleJob(jb, t);
            // 6.启动 调度器
            scheduler.start();
            // 停止
            // scheduler.shutdown();
    
        }
    }
    package com.example.demo;
    
    import java.util.Date;
    
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    public class MyJob implements Job {
    
        // 执行任务调度方法
        public void execute(JobExecutionContext context) throws JobExecutionException {
            System.out.println("执行任务:" + System.currentTimeMillis());
        }
    
    }

    以上都是可以解决任务调度的方法,但在实际项目中,一般都是使用第三方quartz实现任务调度功能,既然已经有了quartz为什么还需要使用xxl-job呢?

    参考:https://www.w3cschool.cn/quartz_doc/quartz_doc-jop62d45.html

  • 相关阅读:
    [Java学习] Java包装类、拆箱和装箱详解
    [Java学习] Java多态和动态绑定
    [Java学习] Java继承的概念与实现
    [Java学习] Java super关键字
    [Java代码] Java是自学好还是参加培训班好?
    [Java学习] Java字符串(String)
    [Java学习] Java方法重载
    [.NET源码] EF的增删改查
    C#面向服务WebService从入门到精通
    CoordinatorLayout-带图片伸缩工具栏
  • 原文地址:https://www.cnblogs.com/920913cheng/p/10750421.html
Copyright © 2011-2022 走看看