学会这10种定时任务,我有点飘了

大家好我是苏三,又跟大家见面了。

前言

最近有几个读者私信给我,问我他们的业务场景,要用什么样的定时任务。确实,在不用的业务场景下要用不同的定时任务,其实我们的选择还是挺多的。我今天给大家总结10种非常实用的定时任务,总有一种是适合你的。

一. linux自带的定时任务

crontab

不知道你有没有遇到过这种场景:有时需要临时统计线上的数据,然后导出到excel表格中。这种需求有时较为复杂,光靠写sql语句是无法满足需求的,这就需要写java代码了。然后将该程序打成一个jar包,在线上环境执行,最后将生成的excel文件下载到本地。

为了减小对线上环境的影响,我们一般会选择在凌晨1-2点,趁用户量少的时候,执行统计程序。(其实凌晨4点左右,用户才是最少的)

由于时间太晚了,我们完全没必要守在那里等执行结果,一个定时任务就能可以搞定。

那么,这种情况用哪种定时任务更合适呢?

答案是:linux系统的crontab。(不过也不排除有些项目没部署在linux系统中)

运行crontab -e,可以编辑定时器,然后加入如下命令:

0 2 * * * /usr/local/java/jdk1.8/bin/java -jar /data/app/tool.jar > /logs/tool.log &

就可以在每天凌晨2点,定时执行tool.jar程序,并且把日志输出到tool.log文件中。当然你也可以把后面的执行java程序的命令写成shell脚本,更方便维护。

使用这种定时任务支持方便修改定时规则,有界面可以统一管理配置的各种定时脚本。

crontab命令的基本格式如下:

crontab [参数] [文件名]

如果没有指定文件名,则接收键盘上输入的命令,并将它载入到crontab

参数功能对照表如下:

参数功能
-u指定用户
-e编辑某个用户的crontab文件内容
-l显示某个用户的crontab文件内容
-r删除某用户的crontab文件
-i删除某用户的crontab文件时需确认

以上参数,如果没有使用-u指定用户,则默认使用的当前用户。

通过crontab -e命令编辑文件内容,具体语法如下:

[分] [小时] [日期] [月] [星期] 具体任务

其中:

  • 分,表示多少分钟,范围:0-59

  • 小时,表示多少小时,范围:0-23

  • 日期,表示具体在哪一天,范围:1-31

  • 月,表示多少月,范围:1-12

  • 星期,表示多少周,范围:0-7,0和7都代表星期日

还有一些特殊字符,比如:

  • *代表如何时间,比如:*1*** 表示每天凌晨1点执行。

  • /代表每隔多久执行一次,比如:*/5 **** 表示每隔5分钟执行一次。

  • ,代表支持多个,比如:10 7,9,12 *** 表示在每天的7、9、12点10分各执行一次。

  • -代表支持一个范围,比如:10 7-9 *** 表示在每天的7、8、9点10分各执行一次。

此外,顺便说一下crontab需要crond服务支持,crondlinux下用来周期地执行某种任务的一个守护进程,在安装linux操作系统后,默认会安装crond服务工具,且crond服务默认就是自启动的。crond进程每分钟会定期检查是否有要执行的任务,如果有,则会自动执行该任务。

可以通过以下命令操作相关服务:

service crond status // 查看运行状态
service crond start //启动服务
service crond stop //关闭服务
service crond restart //重启服务
service crond reload //重新载入配置

使用crontab的优缺点:

  • 优点:方便修改定时规则,支持一些较复杂的定时规则,通过文件可以统一管理配好的各种定时脚本。

  • 缺点:如果定时任务非常多,不太好找,而且必须要求操作系统是linux,否则无法执行。

二. jdk自带的定时任务

1.Thread

各位亲爱的朋友,你没看错,Thread类真的能做定时任务。如果你看过一些定时任务框架的源码,你最后会发现,它们的底层也会使用Thread类。

实现这种定时任务的具体代码如下:

public static void init() {
    new Thread(() -> {
        while (true) {
            try {
                System.out.println("doSameThing");
                Thread.sleep(1000 * 60 * 5);
            } catch (Exception e) {
                log.error(e);
            }
        }
    }).start();
}

使用Thread类可以做最简单的定时任务,在run方法中有个while的死循环(当然还有其他方式),执行我们自己的任务。有个需要特别注意的地方是,需要用try...catch捕获异常,否则如果出现异常,就直接退出循环,下次将无法继续执行了。

这种方式做的定时任务,只能周期性执行,不能支持定时在某个时间点执行。

此外,该线程可以定义成守护线程,在后台默默执行就好。

使用场景:比如项目中有时需要每隔10分钟去下载某个文件,或者每隔5分钟去读取模板文件生成静态html页面等等,一些简单的周期性任务场景。

使用Thread类的优缺点:

  • 优点:这种定时任务非常简单,学习成本低,容易入手,对于那些简单的周期性任务,是个不错的选择。

  • 缺点:不支持指定某个时间点执行任务,不支持延迟执行等操作,功能过于单一,无法应对一些较为复杂的场景。

2.Timer

Timer类是jdk专门提供的定时器工具,用来在后台线程计划执行指定任务,在java.util包下,要跟TimerTask一起配合使用。

Timer类其实是一个任务调度器,它里面包含了一个TimerThread线程,在这个线程中无限循环从TaskQueue中获取TimerTask(该类实现了Runnable接口),调用其run方法,就能异步执行定时任务。我们需要继承TimerTask类,实现它的run方法,在该方法中加上自己的业务逻辑。

实现这种定时任务的具体代码如下:

public class TimerTest {

    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("doSomething");
            }
        },2000,1000);
    }
}

先实例化一个Timer类,然后调用它的schedule方法,在该方法中实例化TimerTask类,业务逻辑写在run方法中。schedule方法最后的两次参数分别表示:延迟时间间隔时间,单位是毫秒。上面例子中,设置的定时任务是每隔1秒执行一次,延迟2秒执行。

主要包含6个方法:

  • schedule(TimerTask task, Date time), 指定任务task在指定时间time执行

  • schedule(TimerTask task, long delay), 指定任务task在指定延迟delay后执行

  • schedule(TimerTask task, Date firstTime,long period),指定任务task在指定时间firstTime执行后,进行重复固定延迟频率peroid的执行

  • schedule(TimerTask task, long delay, long period), 指定任务task 在指定延迟delay 后,进行重复固定延迟频率peroid的执行

  • scheduleAtFixedRate(TimerTask task,Date firstTime,long period), 指定任务task在指定时间firstTime执行后,进行重复固定延迟频率peroid的执行

  • scheduleAtFixedRate(TimerTask task, long delay, long period), 指定任务task 在指定延迟delay 后,进行重复固定延迟频率peroid的执行

不过使用Timer实现定时任务有以下问题:

  1. 由于Timer是单线程执行任务,如果其中一个任务耗时非常长,会影响其他任务的执行。

  2. 如果TimerTask抛出RuntimeException,Timer会停止所有任务的运行。

使用Timer类的优缺点:

  • 优点:非常方便实现多个周期性的定时任务,并且支持延迟执行,还支持在指定时间之后支持,功能还算强大。

  • 缺点:如果其中一个任务耗时非常长,会影响其他任务的执行。并且如果TimerTask抛出RuntimeExceptionTimer会停止所有任务的运行,所以阿里巴巴开发者规范中不建议使用它。

3.ScheduledExecutorService

ScheduledExecutorService是JDK1.5+版本引进的定时任务,该类位于java.util.concurrent并发包下。

ScheduledExecutorService是基于多线程的,设计的初衷是为了解决Timer单线程执行,多个任务之间会互相影响的问题。

它主要包含4个方法:

  • schedule(Runnable command,long delay,TimeUnit unit),带延迟时间的调度,只执行一次,调度之后可通过Future.get()阻塞直至任务执行完毕。

  • schedule(Callable<V> callable,long delay,TimeUnit unit),带延迟时间的调度,只执行一次,调度之后可通过Future.get()阻塞直至任务执行完毕,并且可以获取执行结果。

  • scheduleAtFixedRate,表示以固定频率执行的任务,如果当前任务耗时较多,超过定时周期period,则当前任务结束后会立即执行。

  • scheduleWithFixedDelay,表示以固定延时执行任务,延时是相对当前任务结束为起点计算开始时间。

实现这种定时任务的具体代码如下:

public class ScheduleExecutorTest {

    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("doSomething");
        },1000,1000, TimeUnit.MILLISECONDS);
    }
}

调用ScheduledExecutorService类的scheduleAtFixedRate方法实现周期性任务,每隔1秒钟执行一次,每次延迟1秒再执行。

这种定时任务是阿里巴巴开发者规范中用来替代Timer类的方案,对于多线程执行周期性任务,是个不错的选择。

ScheduledExecutorService的优缺点:

  • 优点:基于多线程的定时任务,多个任务之间不会相关影响,支持周期性的执行任务,并且带延迟功能。

  • 缺点:不支持一些较复杂的定时规则。

最近我建了新的技术交流群,打算将它打造成高质量的活跃群,欢迎小伙伴们加入。

我以往的技术群里技术氛围非常不错,大佬很多。


加微信:su_san_java,备注:加群,即可加入该群。

三. spring支持的定时任务

1.spring task

spring taskspring3以上版本自带的定时任务,实现定时任务的功能时,需要引入spring-context包,目前它支持:xml注解 两种方式。

1. 项目实战

由于xml方式太古老了,我们以springboot项目中注解方式为例。

第一步,在pom.xml文件中引入spring-context相关依赖。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
</dependency>

第二步,在springboot启动类上加上@EnableScheduling注解。

@EnableScheduling
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
    }
}

第三步,使用@Scheduled注解定义定时规则。

@Service
public class SpringTaskTest {

    @Scheduled(cron = "${sue.spring.task.cron}")
    public void fun() {
        System.out.println("doSomething");
    }
}

第四步,在applicationContext.properties文件中配置参数:

sue.spring.task.cron=*/10 * * * * ?

这样就能每隔10秒执行一次fun方法了。

2. cron规则

spring4以上的版本中,cron表达式包含6个参数:

[秒] [分] [时] [日期] [月] [星期]

还支持几个常用的特殊符号:

  • *:表示任何时间触发任务

  • ,:表示指定的时间触发任务

  • -:表示一段时间内触发任务

  • /:表示从哪一个时刻开始,每隔多长时间触发一次任务。

  • ?:表示用于月中的天和周中的天两个子表达式,表示不指定值。

cron表达式参数具体含义:

  1. 秒,取值范围:0-59,支持*,-/

  2. 分,取值范围:0-59,支持*,-/

  3. 时,取值范围:0-23,支持*,-/

  4. 日期,取值范围:1-31,支持*,-/。比秒多了?,表示如果指定的星期触发了,则配置的日期变成无效。

  5. 月,取值范围:1-12,支持*,-/

  6. 星期,取值范围:1~7,1代表星期天,6代表星期六,其他的以此类推。支持*,-/?。比秒多了?,表示如果指定的日期触发了,则配置的星期变成无效。

常见cron表达式使用举例:

  • 0 0 0 1 * ?  每月1号零点执行

  • 0 0 2 * * ?  每天凌晨2点执行

  • 0 0 2 * * ?  每天凌晨2点执行

  • 0 0/5 11 * * ? 每天11点-11点55分,每隔5分钟执行一次

  • 0 0 18 ? * WED 每周三下午6点执行

spring task先通过ScheduledAnnotationBeanPostProcessor类的processScheduled方法,解析和收集Scheduled注解中的参数,包含:cron表达式。

然后在ScheduledTaskRegistrar类的afterPropertiesSet方法中,默认初始化一个单线程的ThreadPoolExecutor执行任务。

对spring task感兴趣的小伙伴,可以加我微信找我私聊。

使用spring task的优缺点:

  • 优点:spring框架自带的定时功能,springboot做了非常好的封装,开启和定义定时任务非常容易,支持复杂的cron表达式,可以满足绝大多数单机版的业务场景。单个任务时,当前次的调度完成后,再执行下一次任务调度。

  • 缺点:默认单线程,如果前面的任务执行时间太长,对后面任务的执行有影响。不支持集群方式部署,不能做数据存储型定时任务。

2.spring quartz

quartzOpenSymphony开源组织在Job scheduling领域的开源项目,是由java开发的一个开源的任务日程管理系统。

quartz能做什么?

  • 作业调度:调用各种框架的作业脚本,例如shell,hive等。

  • 定时任务:在某一预定的时刻,执行你想要执行的任务。

架构图如下:

quartz包含的主要接口如下:

  • Scheduler 代表调度容器,一个调度容器中可以注册多个JobDetail和Trigger。

  • Job 代表工作,即要执行的具体内容。

  • JobDetail 代表具体的可执行的调度程序,Job是这个可执行程调度程序所要执行的内容。

  • JobBuilder 用于定义或构建JobDetail实例。

  • Trigger 代表调度触发器,决定什么时候去调。

  • TriggerBuilder 用于定义或构建触发器。

  • JobStore 用于存储作业和任务调度期间的状态。

1. 项目实战

我们还是以springboot集成quartz为例。

第一步,在pom.xml文件中引入quartz相关依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

第二步,创建真正的定时任务执行类,该类继承QuartzJobBean

public class QuartzTestJob extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        String userName = (String) context.getJobDetail().getJobDataMap().get("userName");
        System.out.println("userName:" + userName);
    }
}

第三步,创建调度程序JobDetail和调度器Trigger

@Configuration
public class QuartzConfig {
    @Value("${sue.spring.quartz.cron}")
    private String testCron;

    /**
     * 创建定时任务
     */
    @Bean
    public JobDetail quartzTestDetail() {
        JobDetail jobDetail = JobBuilder.newJob(QuartzTestJob.class)
                .withIdentity("quartzTestDetail", "QUARTZ_TEST")
                .usingJobData("userName", "susan")
                .storeDurably()
                .build();
        return jobDetail;
    }

    /**
     * 创建触发器
     */
    @Bean
    public Trigger quartzTestJobTrigger() {
        //每隔5秒执行一次
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(testCron);

        //创建触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .forJob(quartzTestDetail())
                .withIdentity("quartzTestJobTrigger", "QUARTZ_TEST_JOB_TRIGGER")
                .withSchedule(cronScheduleBuilder)
                .build();
        return trigger;
    }
}

第四步,在applicationContext.properties文件中配置参数:

sue.spring.quartz.cron=*/5 * * * * ?

这样就能每隔5秒执行一次QuartzTestJob类的executeInternal方法了。

CronTrigger配置格式:

[秒] [分] [小时] [日] [月] [周] [年]

spring quartzspring taskcron表达式规则基本一致,只是spring4以上的版本去掉了后面的,而quartzCronTrigger是非必填的,这里我就不做过多介绍了。

使用spring quartz的优缺点:

  • 优点:默认是多线程异步执行,单个任务时,在上一个调度未完成时,下一个调度时间到时,会另起一个线程开始新的调度,多个任务之间互不影响。支持复杂的cron表达式,它能被集群实例化,支持分布式部署。

  • 缺点:相对于spring task实现定时任务成本更高,需要手动配置QuartzJobBeanJobDetailTrigger等。需要引入了第三方的quartz包,有一定的学习成本。不支持并行调度,不支持失败处理策略和动态分片的策略等。

四. 分布式定时任务

1.xxl-job

xxl-job是大众点评(许雪里)开发的一个分布式任务调度平台,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线,开箱即用。

xxl-job框架对quartz进行了扩展,使用mysql数据库存储数据,并且内置jetty作为RPC服务调用。

主要特点如下:

  1. 有界面维护定时任务和触发规则,非常容易管理。

  2. 能动态启动或停止任务

  3. 支持弹性扩容缩容

  4. 支持任务失败报警

  5. 支持动态分片

  6. 支持故障转移

  7. Rolling实时日志

  8. 支持用户和权限管理

管理界面:

整体架构图如下:

使用quartz架构图如下:

项目实战

xxl-admin管理后台部署和mysql脚本执行等这些前期准备工作,我就不过多介绍了,有需求的朋友可以找我私聊,这些更偏向于运维的事情。

假设前期工作已经OK了,接下来我们需要:

第一步,在pom.xml文件中引入xxl-job相关依赖。

<dependency>
   <groupId>com.xuxueli</groupId>
   <artifactId>xxl-job-core</artifactId>
</dependency>

第二步,在applicationContext.properties文件中配置参数:

xxl.job.admin.address: http://localhost:8088/xxl-job-admin/
xxl.job.executor.appname: xxl-job-executor-sample
xxl.job.executor.port: 8888
xxl.job.executor.logpath: /data/applogs/xxl-job/

第三步,创建HelloJobHandler类继承IJobHandler类:

@JobHandler(value = "helloJobHandler")
@Component
public class HelloJobHandler extends IJobHandler {

    @Override
    public ReturnT<String> execute(String param) {
        System.out.println("XXL-JOB, Hello World.");
        return SUCCESS;
    }
}

这样定时任务就配置好了。

建议把定时任务单独部署到另外一个服务中,跟api服务分开。根据我以往的经验,job大部分情况下,会对数据做批量操作,如果操作的数据量太大,可能会对服务的内存和cpu资源造成一定的影响。

使用xxl-job的优缺点:

  • 优点:有界面管理定时任务,支持弹性扩容缩容、动态分片、故障转移、失败报警等功能。它的功能非常强大,很多大厂在用,可以满足绝大多数业务场景。

  • 缺点:和quartz一样,通过数据库分布式锁,来控制任务不能重复执行。在任务非常多的情况下,有一些性能问题。

最近我建了新的技术交流群,打算将它打造成高质量的活跃群,欢迎小伙伴们加入。

我以往的技术群里技术氛围非常不错,大佬很多。


加微信:su_san_java,备注:加群,即可加入该群。

2.elastic-job

elastic-job是当当网开发的弹性分布式任务调度系统,功能丰富强大,采用zookeeper实现分布式协调,实现任务高可用以及分片。它是专门为高并发和复杂业务场景开发。

elastic-job目前是apacheshardingsphere项目下的一个子项目,官网地址:http://shardingsphere.apache.org/elasticjob/。

elastic-job在2.x之后,出了两个产品线:Elastic-Job-LiteElastic-Job-Cloud,而我们一般使用Elastic-Job-Lite就能够满足需求。Elastic-Job-Lite定位为轻量级无中心化解决方案,使用jar包的形式提供分布式任务的协调服务,外部仅依赖于Zookeeper。。

主要特点如下:

  • 分布式调度协调

  • 弹性扩容缩容

  • 失效转移

  • 错过执行作业重触发

  • 作业分片一致性,保证同一分片在分布式环境中仅一个执行实例

  • 自诊断并修复分布式不稳定造成的问题

  • 支持并行调度

整体架构图:

项目实战

第一步,在pom.xml文件中引入elastic-job相关依赖。

<dependency>
    <groupId>com.dangdang</groupId>
    <artifactId>elastic-job-lite-core</artifactId>
</dependency>
<dependency>
    <groupId>com.dangdang</groupId>
    <artifactId>elastic-job-lite-spring</artifactId>
</dependency>

第二步,增加ZKConfig类,配置zookeeper

@Configuration
@ConditionalOnExpression("'${zk.serverList}'.length() > 0")
public class ZKConfig {

    @Bean
    public ZookeeperRegistryCenter registry(@Value("${zk.serverList}") String serverList,
                                             @Value("${zk.namespace}") String namespace) {
        return new ZookeeperRegistryCenter(new ZookeeperConfiguration(serverList, namespace));
    }

}

第三步,定义一个类实现SimpleJob接口:

public class TestJob implements SimpleJob {

    @Override
    public void execute(ShardingContext shardingContext){
        System.out.println("ShardingTotalCount:"+shardingContext.getShardingTotalCount());
        System.out.println("ShardingItem:"+shardingContext.getShardingItem());
    }
}

第四步,增加JobConfig配置任务:

@Configuration
public class JobConfig {
    @Value("${sue.spring.elatisc.cron}")
    private String testCron;
    @Value("${sue.spring.elatisc.itemParameters}")
    private  String shardingItemParameters;
    @Value("${sue.spring.elatisc.jobParameters}")
    private String jobParameters =;
    @Value("${sue.spring.elatisc.shardingTotalCount}")
    private int shardingTotalCount;
    
    @Autowired
    private ZookeeperRegistryCenter registryCenter;

    @Bean
    public SimpleJob testJob() {
        return new TestJob();
    }

    @Bean
    public JobScheduler simpleJobScheduler(final SimpleJob simpleJob) {
        return new SpringJobScheduler(simpleJob, registryCenter, getConfiguration(simpleJob.getClass(),
                cron, shardingTotalCount, shardingItemParameters, jobParameters));
    }

    private geConfiguration getConfiguration(Class<? extends SimpleJob> jobClass,String cron,int shardingTotalCount,String shardingItemParameters,String jobParameters) {
        JobCoreConfiguration simpleCoreConfig = JobCoreConfiguration.newBuilder(jobClass.getName(), testCron, shardingTotalCount).
                shardingItemParameters(shardingItemParameters).jobParameter(jobParameters).build();
        SimpleJobConfiguration simpleJobConfig = new SimpleJobConfiguration(simpleCoreConfig, jobClass.getCanonicalName());
        LiteJobConfiguration jobConfig = LiteJobConfiguration.newBuilder(simpleJobConfig).overwrite(true).build();
        return jobConfig;
    }
}

其中:

  • cron:cron表达式,定义触发规则。

  • shardingTotalCount:定义作业分片总数

  • shardingItemParameters:定义分配项参数,一般用分片序列号和参数用等号分隔,多个键值对用逗号分隔,分片序列号从0开始,不可大于或等于作业分片总数。

  • jobParameters:作业自定义参数

第五步,在applicationContext.properties文件中配置参数:

spring.application.name=elasticjobDemo
zk.serverList=localhost:2181
zk.namespace=elasticjobDemo
sue.spring.elatisc.cron=0/5 * * * * ?
sue.spring.elatisc.itemParameters=0=A,1=B,2=C,3=D
sue.spring.elatisc.jobParameters=test
sue.spring.elatisc.shardingTotalCount=4

这样定时任务就配置好了,创建定时任务的步骤,相对于xxl-job来说要繁琐一些。

使用elastic-job的优缺点:

  • 优点:支持分布式调度协调,支持分片,适合高并发,和一些业务相对来说较复杂的场景。

  • 缺点:需要依赖于zookeeper,实现定时任务相对于xxl-job要复杂一些,要对分片规则非常熟悉。

3.其他分布式定时任务

1. Saturn

Saturn是唯品会开源的一个分布式任务调度平台。取代传统的Linux Cron/Spring Batch Job的方式,做到全域统一配置,统一监控,任务高可用以及分片并发处理。

Saturn是在当当开源的Elastic-Job基础上,结合各方需求和我们的实践见解改良而成。使用案例:唯品会、酷狗音乐、新网银行、海融易、航美在线、量富征信等。 

github地址:https://github.com/vipshop/Saturn/

2. TBSchedule

 TBSchedule是阿里开发的一款分布式任务调度平台,旨在将调度作业从业务系统中分离出来,降低或者是消除和业务系统的耦合度,进行高效异步任务处理。

目前被广泛应用在阿里巴巴、淘宝、支付宝、京东、聚美、汽车之家、国美等很多互联网企业的流程调度系统中。

github地址:https://github.com/taobao/TBSchedule

老实说优秀的定时任务还是挺多的,不是说哪种定时任务牛逼我们就一定要用哪种,而是要根据实际业务需求选择。每种定时任务都有优缺点,合理选择既能满足业务需求,又能避免资源浪费,才是上上策。当然在实际的业务场景,通常会多种定时任务一起配合使用。

顺便说一句,欢迎亲爱的小伙伴们,找我一起聊聊:你用过哪些定时任务,遇到过哪些问题,以及如何解决问题的。如果有相关问题也可以问我。

希望我们能够共同进步,一起成长。

最后说一句(求关注,别白嫖我)

如果这篇文章对您有所帮助,或者有所启发的话,帮忙扫描下发二维码关注一下,您的支持是我坚持写作最大的动力。

求一键三连:点赞、转发、在看。

关注公众号:【苏三说技术】,在公众号中回复:面试、代码神器、开发手册、时间管理有超赞的粉丝福利,另外回复:加群,可以跟很多BAT大厂的前辈交流和学习。

 个人公众号

 个人微信

  • 6
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
继“Java开发微信朋友圈PC版系统-架构1.0”之后,debug这段时间日撸夜撸,终于赶在春节放假前给诸位带来了这一系统的架构2.0版本,特此分享给诸位进行学习,以掌握、巩固更多的技术栈以及项目和产品开发经验,同时也为即将到来的金三银四跳槽季做准备! 言归正传,下面仍然以问答的方式介绍下本门课程的相关内容! (1)问题一:这是一门什么样的课程? 很明显,本门课程是建立在架构1.0,即 第1门课程 的基础上发布的,包含了架构1.0的内容,即它仍然是一门项目、产品实战课,基于Spring Boot2.X + 分布式中间件开发的一款类似“新浪微博”、“QQ空间”、“微信朋友圈”PC版的互联网社交软件,包含完整的门户网前端 以及 后台系统管理端,可以说是一套相当完整的系统! (2)问题二:架构2.0融入了哪些新技术以及各自有什么作用? 本课程对应着系统架构2.0,即第2阶段,主要目标:基于架构1.0,优化系统的整体性能,实现一个真正的互联网社交产品;其中,可以学习到的技术干货非常多,包括:系统架构设计、Spring Boot2.X、缓存Redis、多线程并发编程、消息中间件RabbitMQ、全文搜索引擎Elastic Search、前后端消息实时通知WebSocket、分布式任务调度中间件Elastic Job、Http Restful编程、Http通信OKHttp3、分布式全局唯一ID、雪花算法SnowFlake、注册中心ZooKeeper、Shiro+Redis 集群Session共享、敏感词自动过滤、Java8 等等; A.  基于Elastic Search实现首页列表数据的初始化加载、首页全文检索;B.  基于缓存Redis缓存首页朋友圈“是否已点赞、收藏、关注、评论、转发”等统计数据;整合Shiro实现集群部署模式下Session共享;C.  多线程并发编程并发处理系统产生的废弃图片、文件数据;D.  基于Elastic Job切片作业调度分布式多线程清理系统产生的废弃图片;E.  基于RabbitMQ解耦同步调用的服务模块,实现服务模块之间异步通信;F.  基于WebSocket实现系统后端 与 首页前端 当前登录用户实时消息通知;G.  基于OKHttp3、Restful风格的Rest API实现ES文档、分词数据存储与检索;H.  分布式全局唯一ID 雪花算法SnowFlake实现朋友圈图片的唯一命名;I.  ZooKeeper充当Elastic Job创建的系统作业的注册中心;J.  为塑造一个健康的网络环境,对用户发的朋友圈、评论、回复内容进行敏感词过滤;K.  大量优雅的Java8  Lambda编程、Stream编程;  (3)问题三:系统运行起来有效果图看吗?
### 回答1: 1 使用java Timer类来实现:通过 Timer 和 TimerTask 来实现定时任务。2. 使用java Quartz来实现:Quartz 是一个完全由 Java 编写的开源定时任务框架。3. 使用Spring 框架的Task定时任务:Spring 框架自带的Task定时任务,可以利用这个特性来实现定时任务。4. 使用Java线程池来实现:可以使用Java线程池来实现定时任务,通过设置线程池中线程的定时执行时间来实现定时任务。 ### 回答2: 以下是几Java定时任务的实现案例: 1. 使用Timer类:Timer类可用于在指定的时间间隔内调度任务。可以创建一个Timer对象,并使用Timer.schedule()方法在指定的时间间隔内执行任务。 例如: ``` Timer timer = new Timer(); TimerTask task = new TimerTask() { public void run() { // 执行任务逻辑 } }; // 在延迟1000毫秒后,每隔2000毫秒执行一次任务 timer.schedule(task, 1000, 2000); ``` 2. 使用ScheduledExecutorService接口:ScheduledExecutorService是一个高度可用的并发定时任务执行器,可用于按指定的时间间隔执行任务。 例如: ``` ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); Runnable task = new Runnable() { public void run() { // 执行任务逻辑 } }; // 在延迟1000毫秒后,每隔2000毫秒执行一次任务 executor.scheduleAtFixedRate(task, 1000, 2000, TimeUnit.MILLISECONDS); ``` 3. 使用Quartz框架:Quartz是一个功能强大的开源任务调度框架,可以用于执行复杂的定时任务。它提供了灵活的配置选项和强大的调度功能,支持持久性存储和集群部署。 例如: ```java // 创建触发器 Trigger trigger = TriggerBuilder.newTrigger() .withIdentity("trigger1", "group1") .withSchedule(SimpleScheduleBuilder.simpleSchedule() .withIntervalInMilliseconds(2000) .repeatForever()) .build(); // 创建任务 JobDetail job = JobBuilder.newJob(MyJob.class) .withIdentity("job1", "group1") .build(); // 创建调度器 Scheduler scheduler = new StdSchedulerFactory().getScheduler(); scheduler.start(); scheduler.scheduleJob(job, trigger); ``` 需要注意的是,以上这些只是Java定时任务的几个常见实现方式,还有其他方式,如使用Spring框架的任务调度功能、使用Quartz的注解方式等。根据项目的具体需求和场景,可以选择合适的定时任务实现方式。 ### 回答3: 以下是几Java定时任务的实现案例: 1. 使用Java的Timer类:可以通过Timer类来实现简单的定时任务。可以创建一个Timer对象,并使用其schedule()方法来指定任务要运行的时间,并在指定的时间间隔内运行。例如,可以使用Timer类来创建一个每隔一分钟执行一次的任务。 2. 使用Java的ScheduledExecutorService接口:该接口是Java提供的一个更强大的定时任务执行框架。可以通过创建一个ScheduledExecutorService对象,并使用其schedule()或者scheduleAtFixedRate()方法来指定任务的运行时间和间隔。例如,可以使用ScheduledExecutorService来创建一个每隔一分钟执行一次的任务,并在任务执行后延迟一定的时间再次执行。 3. 使用Spring框架的@Scheduled注解:如果你的应用程序是基于Spring框架的,可以使用Spring的@Scheduled注解来实现定时任务。只需在你的任务方法上添加@Scheduled注解,并指定任务的执行时间间隔。Spring会自动创建一个定时任务调度器,定时执行你的任务。 4. 使用Quartz框架:Quartz是一个功能强大的开源任务调度框架,可以用于Java应用程序中的定时任务管理Quartz提供了丰富的API来定义和调度任务,支持复杂的定时任务配置。使用Quartz,可以创建基于时间表达式的任务,并将其作为独立的模块集成到你的应用程序中。 这些只是一些常见的Java定时任务实现案例,具体实现取决于你的需求和应用程序的架构。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苏三说技术

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值