（仿牛客社区项目）Java开发笔记7.5：任务执行和调度

最新推荐文章于 2022-11-22 11:26:09 发布

Gerrar_d

最新推荐文章于 2022-11-22 11:26:09 发布

阅读量551

点赞数 2

分类专栏： Java项目文章标签： java junit spring

本文链接：https://blog.csdn.net/weixin_45700663/article/details/125978037

版权

Java项目专栏收录该内容

47 篇文章 30 订阅

订阅专栏

文章目录

任务执行和调度
1.测试JDK线程池和Spring线程池
2.测试Spring Quartz

任务执行和调度

NowCoder_34_1

1.测试JDK线程池和Spring线程池

添加ThreadPoolTests测试方法。

1.1测试JDK普通线程池

package com.gerrard.community;

import com.gerrard.community.service.AlphaService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Date;
import java.util.concurrent.*;

@RunWith(SpringRunner.class)
@SpringBootTest
@ContextConfiguration(classes = CommunityApplication.class)
public class ThreadPoolTests {
    private static final Logger logger= LoggerFactory.getLogger(ThreadPoolTests.class);

    //JDK普通线程池
    private ExecutorService excutorService= Executors.newFixedThreadPool(5);

    //JDK可执行定时任务的线程池
    private ScheduledExecutorService scheduledExecutorService=Executors.newScheduledThreadPool(5);

    //Spring普通线程池
    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;

    //Spring可执行定时任务的线程池
    @Autowired
    private ThreadPoolTaskScheduler taskSchedule;


    @Autowired
    private AlphaService alphaService;


    private void sleep(long m){
        try {
            Thread.sleep(m);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

//1.JDK普通线程池
    @Test
    public void testExecutorService(){
        Runnable task=new Runnable() {
            @Override
            public void run() {
                logger.debug("Hello ExecutorService");
            }
        };

        for(int i=0;i<10;i++){
            excutorService.submit(task);
        }

        sleep(10000);
    }

NowCoder_34_2

1.2测试JDK定时任务线程池

 //2.JDK定时任务线程池
    @Test
    public void testScheduledExecutorService(){
        Runnable task=new Runnable() {
            @Override
            public void run() {
                logger.debug("Hello ScheduledExecutorService");
            }
        };
        scheduledExecutorService.scheduleAtFixedRate(task,10000,1000, TimeUnit.MILLISECONDS);

        sleep(30000);

    }

NowCoder_34_3

1.3测试Spring普通线程池

配置文件中添加：

#TaskSchedulingProperties
spring.task.scheduling.pool.size=5

 //3.Spring普通线程池
    @Test
    public void testThreadPoolTaskExecutor(){
        Runnable task=new Runnable() {
            @Override
            public void run() {
                logger.debug("Hello ThreadPoolTaskExecutor");
            }
        };

        for(int i=0;i<10;i++){
            taskExecutor.submit(task);
        }

        sleep(10000);
    }

NowCoder_34_4

1.4测试Spring定时任务线程池

    //4.Spring定时任务线程池
    @Test
    public void testThreadPoolTaskScheduler(){
        Runnable task=new Runnable() {
            @Override
            public void run() {
                logger.debug("Hello ThreadPoolTaskSchduler");
            }
        };

        Date startTime=new Date(System.currentTimeMillis()+10000);
        taskSchedule.scheduleAtFixedRate(task,startTime,1000);

        sleep(30000);
    }

NowCoder_34_5

1.5测试Spring普通线程池(简化)

package com.gerrard.community.service;


import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.slf4j.LoggerFactory;

import org.slf4j.Logger;
@Service
public class AlphaService {

    private static final Logger logger= LoggerFactory.getLogger(AlphaService.class);
    @Async
    public void execute1(){
        logger.debug("execute1");
    }

//    @Scheduled(initialDelay=10000,fixedRate = 1000)
//    public void execute2(){
//        logger.debug("execute2");
//    }
}

    //5.Spring普通线程池(简化)
    // 5.Spring普通线程池(简化)
    @Test
    public void testThreadPoolTaskExecutorSimple() {
        for (int i = 0; i < 10; i++) {
            alphaService.execute1();
        }

        sleep(30000);
    }

NowCoder_34_6

1.6测试Spring定时任务线程池(简化)

package com.gerrard.community.service;


import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.slf4j.LoggerFactory;

import org.slf4j.Logger;
@Service
public class AlphaService {

    private static final Logger logger= LoggerFactory.getLogger(AlphaService.class);
    @Async
    public void execute1(){
        logger.debug("execute1");
    }

    @Scheduled(initialDelay=10000,fixedRate = 1000)
    public void execute2(){
        logger.debug("execute2");
    }
}

 // 6.Spring定时任务线程池(简化)
    @Test
    public void testThreadPoolTaskSchedulerSimple() {
        sleep(30000);
    }

config包中新建ThreadPoolConfig类。

package com.gerrard.community.config;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

@Configuration
@EnableScheduling
@EnableAsync
public class ThreadPoolConfig {

//    //确实，只要容器中有这个bean，就会触发执行
//    private static final Logger logger= LoggerFactory.getLogger(ThreadPoolConfig.class);
//    @Scheduled(initialDelay=10000,fixedRate = 1000)
//    public void execute2(){
//        logger.debug("execute2");
//    }

}

NowCoder_34_7

2.测试Spring Quartz

2.1添加依赖

在pom.xml中添加依赖：

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

2.2添加Quartz配置信息

#QuartzProperties
spring.quartz.job-store-type=jdbc
spring.quartz.scheduler-name=communityScheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
#spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
#用上面那个会报错 版本问题
spring.quartz.properties.org.quartz.jobStore.class=org.springframework.scheduling.quartz.LocalDataSourceJobStore
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount=5

2.3初此使用Quartz执行MySQL数据库脚本

执行tables_mysql_innodb.sql，查看数据库：

NowCoder_34_8

2.4config包

在config包中新建QuartzConfig类，配置使生效。

package com.gerrard.community.config;
import com.gerrard.community.quartz.AlphaJob;
import com.gerrard.community.quartz.PostScoreRefreshJob;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

// 配置 -> 数据库 -> 调用
@Configuration
public class QuartzConfig {

    // FactoryBean可简化Bean的实例化过程:
    // 1.通过FactoryBean封装Bean的实例化过程.
    // 2.将FactoryBean装配到Spring容器里.
    // 3.将FactoryBean注入给其他的Bean.
    // 4.该Bean得到的是FactoryBean所管理的对象实例.

    // 配置JobDetail  要把数据库里的信息删掉，因为这是一次初始化  注意：把bean注解注掉后如果不把数据库信息删除，则定时任务仍生效，会读取数据库中的信息生	//成【bean】
    @Bean
    public JobDetailFactoryBean alphaJobDetail() {
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        factoryBean.setJobClass(AlphaJob.class);
        factoryBean.setName("alphaJob");
        factoryBean.setGroup("alphaJobGroup");
        factoryBean.setDurability(true);
        factoryBean.setRequestsRecovery(true);
        return factoryBean;
    }

    // 配置Trigger(SimpleTriggerFactoryBean, CronTriggerFactoryBean)
     @Bean
    public SimpleTriggerFactoryBean alphaTrigger(JobDetail alphaJobDetail) {
        SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
        factoryBean.setJobDetail(alphaJobDetail);
        factoryBean.setName("alphaTrigger");
        factoryBean.setGroup("alphaTriggerGroup");
        factoryBean.setRepeatInterval(3000);
        factoryBean.setJobDataMap(new JobDataMap());
        return factoryBean;
    }
	/**
    @Bean
    public JobDetailFactoryBean postScoreRefreshJobDetail(){
        JobDetailFactoryBean factoryBean=new JobDetailFactoryBean();
        factoryBean.setJobClass(PostScoreRefreshJob.class);
        factoryBean.setName("postScoreRefreshJob");
        factoryBean.setGroup("communityJobGroup");
        factoryBean.setDurability(true);
        factoryBean.setRequestsRecovery(true);
        return factoryBean;
    }

    @Bean
    public SimpleTriggerFactoryBean postScoreRefreshTrigger(JobDetail postScoreRefreshJobDetail){
        SimpleTriggerFactoryBean factoryBean=new SimpleTriggerFactoryBean();
        factoryBean.setJobDetail(postScoreRefreshJobDetail);
        factoryBean.setName("postScoreRefreshTrigger");
        factoryBean.setGroup("communityTriggerGroup");
        factoryBean.setRepeatInterval(1000 * 60 * 1);
        factoryBean.setJobDataMap(new JobDataMap());
        return factoryBean;
    }
    **/
}

2.5quartz包

新建quartz包，添加AlphaJob类，编写执行的内容。

package com.gerrard.community.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class AlphaJob implements Job {
    @Override
    public void execute(JobExecutionContext Context) throws JobExecutionException {
        System.out.println(Thread.currentThread().getName()+"：execute a quartz job.");
    }
}

2.6添加QuartzTests测试方法

package com.gerrard.community;

import org.junit.Test;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.junit.runner.RunWith;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
@ContextConfiguration(classes = CommunityApplication.class)
public class QuartzTests {

    @Autowired
    private Scheduler scheduler;

    @Test
    public void testDeleteJob(){
        boolean result= false;
        try {
            result = scheduler.deleteJob(new JobKey("alphaJob","alphaJobGroup"));
            System.out.println(result);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }


    private void sleep(long m){
        try {
            Thread.sleep(m);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test(){
        sleep(30000);
    }

}