精华内容
下载资源
问答
  • 每隔一定将redis里面的数据取出并存储到数据库中,这里记录一下如何在ssm项目中整合Java Timer创建定时任务并启动。 1.创建定时任务对象: import java.util.TimerTask; public class RedisTask extends TimerTask...

    为了统计用户使用系统菜单的点击次数,将相应的日志信息存储到数据库中,但是一次一条的插入会导致存储速率缓慢,占用服务器及数据库资源等相关一系列的问题,所以为了避免这种情况,损耗了一定的实时性,将数据先存储至redis,每隔一定将redis里面的数据取出并存储到数据库中,这里记录一下如何在ssm项目中整合Java Timer创建定时任务并启动。

    1.创建定时任务对象:

    import java.util.TimerTask;
    
    public class RedisTask extends TimerTask{
    
    	@Override
    	public void run() {
    		System.out.println("执行redisTask");
    	}
    }
    
    

    run方法中即是定时执行的代码。

    2.注入定时任务到spring ioc容器,交由容器管理:

    <!-- 注册定时任务类:redis定时任务 -->
    <bean id="redisTask" class="com.gaotime.fc.platform.web.controller.task.RedisTask"></bean> 
    

    3.对该定时任务配置相关的定时任务信息:

    <!-- 配置任务计划:注册定时器信息 -->
    <bean id="taskInfo" class="org.springframework.scheduling.timer.ScheduledTimerTask">
    	<!-- 第一次执行任务前需要等待的时间 -->
    	<property name="delay" value="1000"></property>
    	<!-- 设置任务的执行周期 -->
    	<property name="period" value="10000"></property>
    	<!-- 设置具体执行的任务 -->
    	<property name="timerTask" ref="redisTask"></property>
    </bean>
    

    如需一个配置配置多个定时任务,可在timerTask属性中使用list。

    4.配置该定时任务的调度器:

    <!-- 配置定时器任务的调度器 -->
    <bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
    	<!-- 注册定时器列表 -->
    	<property name="scheduledTimerTasks">
    		<list>
    			<ref local="taskInfo"></ref>
    		</list>
    	</property>
    </bean>
    

    5.配置扫描:

    将配置的xml文件在web.xml中进行配置,启动即可:

    <context-param>
    	<param-name>contextConfigLocation</param-name>
    	<param-value>classpath*:/spring/*.xml</param-value>  <!--加载多个spring配置文件 -->
    </context-param>
    <listener> 
    	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    

    文章参考:

    展开全文
  • springboot+redis 相信是不少中下企业进行项目开发必备的技术之一,用它做定时任务可谓是恰到好处,本文以一个简单的案例入手,讲述如何实现任务的获取和执行。 jedis工具类 @Log @Component public class ...
    • springboot+redis 相信是不少中下企业进行项目开发必备的技术之一,用它做定时任务可谓是恰到好处,本文以一个简单的案例入手,讲述如何实现任务的获取和执行。

    • jedis工具类

    @Log
    @Component
    public class JedisClient {
    
    	public static JedisPool jedisPool = null;
    
    	 static {
    		
    		if(jedisPool == null){
    			JedisPoolConfig config = new JedisPoolConfig();
    			config.setMaxTotal(200);
    			config.setMaxIdle(50);
    			config.setMinIdle(8);//设置最小空闲数
    			config.setMaxWaitMillis(10000);
    			config.setTestOnBorrow(true);
    			config.setTestOnReturn(true);
    			//Idle时进行连接扫描
    			config.setTestWhileIdle(true);
    			//表示idle object evitor两次扫描之间要sleep的毫秒数
    			config.setTimeBetweenEvictionRunsMillis(30000);
    			//表示idle object evitor每次扫描的最多的对象数
    			config.setNumTestsPerEvictionRun(10);
    			//表示一个对象至少停留在idle状态的最短时间,然后才能被idle object evitor扫描并驱逐;这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义
    			config.setMinEvictableIdleTimeMillis(60000);
    			jedisPool = new JedisPool(config, "127.0.0.1", 6379, 10000, "",2); 
    		}
    		
    		
    	}
    	
    	
    
    	/**
    	 * 获取Jedis实例
    	 * @return
    	 */
    	public synchronized static Jedis getJedis() {
    		try{
    			if (jedisPool != null) {
    				Jedis resource = jedisPool.getResource();
    				return resource;
    			} 
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * 释放jedis资源
    	 * @param jedis
    	 */
    	public static void close(final Jedis jedis) {
            if (jedis != null) {
        	    jedis.close();
            }
    	}
    
    	// 添加查询队列
    	public static boolean addEmsTraceInfoUploadToQue(JSONObject json) {
    		Jedis jedis =null;
    		
    		try {
    			jedis = getJedis();
    				long r = 0;
    				r = jedis.rpush("one_que", json.toString());
    				if (r > 0) {
    					return true;
    				} else {
    					return false;
    				}
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    
    		return false;
    	}
    
    	
    	/**
    	 * 获取抓取任务
    	 * @return
    	 */
    	public static JSONObject takeEmsTraceInfoUploadFromQue() {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			String jsonList = jedis.lpop("one_que");
    			if (StringUtils.isNotBlank(jsonList)) {
    				return JSONObject.fromObject(jsonList);
    			}
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return null;
    	}
    	
    	
    	/**
    	 * 添加  list的值  从左边添加 lpush
    	 * @return
    	 */
    	public static boolean addDataToQueList(String key,String value) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			jedis.lpush(key,value); //key>=0从头到尾,key<0从尾到头
    			return true;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return false;
    	}
    	
    	/**
    	 * 添加  hash的值  
    	 * @return
    	 */
    	public static boolean addDataToQueSet(String key,String field,String value) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			jedis.hset(key, field, value);
    			return true;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return false;
    	}
    	
    	/**
    	 * 从左边获取  list 一个 值
    	 * @return
    	 */
    	public static String takeOneDataFromQueLeftList(String key) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			String value = jedis.lindex(key, 0); //key>=0从头到尾,key<0从尾到头
    			return value;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return null;
    	}
    	
    	/**
    	 * 获取  hash 一个 值
    	 * @return
    	 */
    	public static String takeOneDataFromQueLeftSet(String key,String field) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			String hget = jedis.hget(key, field);
    			return hget;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return null;
    	}
    	
    	/**
    	 * 获取  hash 所有 值
    	 * @return
    	 */
    	public static Map<String, String> takeAllDataFromQueLeftSet(String key) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			Map<String, String> hgetAll = jedis.hgetAll(key);
    			return hgetAll;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return null;
    	}
    	
    	/**
    	 * 获取  hash 的长度
    	 * @return
    	 */
    	public static Long getLengthSet(String key) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			Long hlen = jedis.hlen(key);
    			return hlen;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return null;
    	}
    	
    	/**
    	 * 获取 zset 的长度/数量
    	 * @return
    	 */
    	public static Long getLengthZSet(String key) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			Long hlen = jedis.zcard(key);
    			return hlen;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return null;
    	}
    	
    	/**
    	 * 添加  zset 成员
    	 * @return
    	 */
    	public static boolean addZsetOneData(String key,Long score,String member) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			Long zrange = jedis.zadd(key, score, member);
    			return true;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return false;
    	}
    	
    	/**
    	 * 删除  zset 成员
    	 * @return
    	 */
    	public static boolean delZsetOneData(String key,double start,double end) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			jedis.zremrangeByScore(key, start, end);
    			return true;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return false;
    	}
    	
    	/**
    	 * 获取zset 成员排名  从小到大
    	 * @return
    	 */
    	public static Set<Tuple> getRangeZrangeWithScores(String key) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			Set<Tuple> zrange = jedis.zrangeWithScores(key, 0, -1);
    			return zrange;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return null;
    	}
    	
    	/**
    	 * 从左边获取  list 所有 值
    	 * @return
    	 */
    	public static List<String> takeAllDataFromQueList(String key) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			List<String> value = jedis.lrange(key, 0, -1); //key>=0从头到尾,key<0从尾到头
    			return value;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return null;
    	}
    	
    	
    	/**
    	 * 删除  list  值 从头到尾 删除一个 list的元素
    	 * @return
    	 */
    	public static boolean delDataFromQueList(String key) {
    		
    		Jedis jedis = null;
    		try {
    			jedis = getJedis();
    			jedis.lpop(key); //key>=0从头到尾,key<0从尾到头
    			return true;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		} finally {
    			close(jedis);
    		}
    		return false;
    	}
    	
    	public static long getQueSize(String redisKey) {
    		Jedis jedis = getJedis();
    		long size = 0;
    		try {
    			size = jedis.llen(redisKey);
    			return size;
    		} catch (Exception ex) {
    			ex.printStackTrace();
    			return 0;
    		} finally {
    			close(jedis);
    		}
    	}
    }
    
    • 定时获取任务
    @Log
    @Component
    public class TrackJob {
    	
    	@Autowired
    	private JdbcTemplate jdbcTemplate;
    	
    	@Autowired
    	private JedisClient jedisClient;
    	
    	private static boolean isRunning = false;
    	
    	@Scheduled(cron="*/23 * * * * ?") // 每秒钟启动     0 0 23 * * ?      0 */1 * * * ?  0 0 8 * * ?
    	public void trackMailedJob() {
    		
    		Map<String, Object> queryForList = jdbcTemplate.queryForMap(
    				"select setting_value1,setting_value2,setting_value3 from d_setting where setting_key='t1'");
    		
    		String settingValue1 = queryForList.get("setting_value1").toString();
    
    		if (settingValue1.equalsIgnoreCase("on")) {
    
    			if (isRunning) {
    				return;
    			}
    			isRunning = true;
    			try {
    				List<Map<String, Object>> queryForMap = jdbcTemplate
    						.queryForList("select id,bag_code from p_bag where cur_status between 10 and 16 and receive_time >= ? and receive_time<=? and cur_operate_time<=? order by id desc limit 50", 
    								TimeUtil.dataStringToNumber(queryForList.get("setting_value2").toString()),TimeUtil.dataStringToNumber(queryForList.get("setting_value3").toString()),System.currentTimeMillis()-2*3600000l);
    				if (queryForMap.size() == 0) {
    					log.info("没有要爬取的任务===========");
    					isRunning = false;
    					return;
    				}
    				log.info("开始抓取要查询的数据");
    				for (Map<String, Object> map : queryForMap) {
    					long id = (long) map.get("id");
    					String bagCode = (String) map.get("bag_code");
    					JSONObject jsonObject = new JSONObject();
    					jsonObject.put("id", id);
    					jsonObject.put("bagCode", bagCode);
    					jedisClient.addEmsTraceInfoUploadToQue(jsonObject);
    					log.info("QCS获取任务:"+jsonObject);
    				}
    				isRunning = false;
    			} catch (Exception e) {
    				log.info(e.getLocalizedMessage());
    			}finally {
    				isRunning = false;
    			}
    			
    		}
    	}
    }
    
    • 获取任务并执行
    @Service
    @Log
    public class TrackBagServiceJob {
    	
    	@Autowired
    	private QcsMailTrackService qcsMailTrackService;
    	
    	@Autowired
    	private JdbcTemplate jdbcTemplate;
    	
    	@Autowired
    	private JedisClient jedisClient;
    	
    	
    	@Scheduled(cron="*/47 * * * * ?") // 每秒钟启动     0 0 23 * * ?      0 */1 * * * ?  0 0 8 * * ?
        public void handelBagCode(){
        	
        	if (QcsMailTrackService.loginStatus == 0) {
        		List<Map<String,Object>> queryForList = jdbcTemplate.queryForList("select setting_value1,setting_value2 from d_setting where setting_key=?","track_username_password");
            	String username="";
            	String password="";
            	for (Map<String, Object> map : queryForList) {
        			 username =(String) map.get("setting_value1");
        			 password =(String) map.get("setting_value2");
        		}
            	try {
            		JSONObject login = qcsMailTrackService.login(username, password);
            		if (login.optString("status").equals("true")) {
            			try {
            				while (true) {
            					JSONObject takeEmsTraceInfoUploadFromQue = jedisClient.takeEmsTraceInfoUploadFromQue();
                				long id = takeEmsTraceInfoUploadFromQue.optLong("id");
                				String bagCode = takeEmsTraceInfoUploadFromQue.optString("bagCode");
                				if (bagCode != null) {
                					beginTrack(id, bagCode);
                				}
    						}
            				
            			} catch (Exception e) {
            				log.info("爬取数据出错"+e.getLocalizedMessage());
            			}
            		}else {
            			QcsMailTrackService.loginStatus=0;
        				Thread.sleep(60000);
            			log.info("登录失败,自动重试中,错误信息:"+login.optString("error"));
            		}
        		} catch (Exception e) {
        			log.info("访问QCS失败"+e.getLocalizedMessage());
        		}
    		}else {
    			while (true) {
    				JSONObject takeEmsTraceInfoUploadFromQue = jedisClient.takeEmsTraceInfoUploadFromQue();
    				long id = takeEmsTraceInfoUploadFromQue.optLong("id");
    				String bagCode = takeEmsTraceInfoUploadFromQue.optString("bagCode");
    				if (bagCode != null) {
    					beginTrack(id, bagCode);
    				}
    			}
    			
    		}
    	}
    
    	private void beginTrack(Long id, String bagCode){
    		
    		try {
    			JSONObject queryBag = qcsMailTrackService.queryBag(bagCode);
    			jdbcTemplate.execute("update p_bag set cur_operate_time="+System.currentTimeMillis()+" where id="+id);
    			if (queryBag.optString("error").contains("moved")) {
    				QcsMailTrackService.loginStatus=0;
    				Thread.sleep(60000);
    			}else {
    				String sentedTime="";
    				String mailedTime="";
    				if (StringUtils.isNotBlank(queryBag.optString("sentedTime"))  ) {
    					sentedTime = queryBag.optString("sentedTime");
    				}else{
    					sentedTime="";
    				}
    				
    				if (StringUtils.isNotBlank(queryBag.optString("mailedTime"))  ) {
    					mailedTime = queryBag.optString("mailedTime");
    				}else {
    					mailedTime="";
    				}
    				
    				if(StringUtils.isNotBlank(sentedTime)) {
    					jdbcTemplate.execute("update p_bag set dispatch_time="+TimeUtil.dataStringToNumber(sentedTime)+" where id="+id);
    					
    				}
    				if(StringUtils.isNotBlank(mailedTime)) {
    					jdbcTemplate.execute("update p_bag set mailed_time="+TimeUtil.dataStringToNumber(mailedTime)+" where id="+id);					
    				}
    				
    				if (StringUtils.isNotBlank(sentedTime) && StringUtils.isNotBlank(mailedTime) ) {
    					long dataStringToNumber1 = TimeUtil.dataStringToNumber(sentedTime);
    					long dataStringToNumber2 = TimeUtil.dataStringToNumber(mailedTime);
    					int i = TimeUtil.differentDaysByMillisecond(dataStringToNumber1,dataStringToNumber2);
    					jdbcTemplate.execute("update p_bag set total_time="+i+", cur_status=17 where id="+id);
    				}
    			}
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    			log.info("保存数据出错啦"+e.getLocalizedMessage());
    		}
    	
    	}
    }
    
    展开全文
  • 主要给大家介绍了基于redis实现定时任务的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用redis具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • }else { log.info("========>>定时任务正在运行中,{}",key); } } else { shardedJedis.set(key, GroupOrderTask.IDENTITY_TAG); shardedJedis.expire(key, 180); // log.info("value is NULL key = " + key + " ...

        public static String IDENTITY_TAG = String.valueOf(Math.random());

     

    if (!isRunTaskMethod("GroupOrderTask.groupOrder")) {
                return;
    }

     

    private boolean isRunTaskMethod(String key) {
            ShardedJedis shardedJedis = null;
            try {
                shardedJedis = shardedJedisPool.getResource();
                String value = shardedJedis.get(key);
                if (value != null) {
                    // log.info("value is not NULL key = " + key + " value = " + value);
                    if (GroupOrderTask.IDENTITY_TAG.equals(value)) {
                        return true;
                    }else {
                        log.info("========>>定时任务正在运行中,{}",key);
                    }
                } else {
                    shardedJedis.set(key, GroupOrderTask.IDENTITY_TAG);
                    shardedJedis.expire(key, 180);
                    // log.info("value is NULL key = " + key + " value = " + value);
                    return true;
                }
            } catch (Exception ex) {
                log.error("get key error.", ex);
                returnBrokenResource(shardedJedis);
            } finally {
                returnResource(shardedJedis);
            }
            return false;
        }

    展开全文
  • 在分布式系统中部署定时任务时,所有的定时任务会在不同的节点上都执行一遍,以下是使用shedlock的解决方案: 第一步:引入shedlock包 maven中pom文件添加如下配置: <dependency> <groupId>...

    参考shedlock官网:https://github.com/lukas-krecan/ShedLock

    在分布式系统中部署定时任务时,所有的定时任务会在不同的节点上都执行一遍,以下是使用shedlock的解决方案:

    要求:不使用Redis。

    第一步:引入shedlock包

    maven中pom文件添加如下配置:

    <dependency>
       <groupId>net.javacrumbs.shedlock</groupId>
       <artifactId>shedlock-spring</artifactId>
       <version>2.2.1</version>
    </dependency>

    第二步:添加shedlock-provider-jdbc-template依赖(以JDBC为例)

    maven中pom文件添加如下配置:

    <dependency>
       <groupId>net.javacrumbs.shedlock</groupId>
       <artifactId>shedlock-provider-jdbc-template</artifactId>
       <version>2.2.1</version>
    </dependency>

    若使用的是其他类型的数据库,需要添加的依赖也不同,以MongoDB为例:MongoDB的依赖如下:

    <dependency>
        <groupId>net.javacrumbs.shedlock</groupId>
        <artifactId>shedlock-provider-mongo</artifactId>
        <version>4.14.0</version>
    </dependency>

    具体的依赖请参考shedlock官网:https://github.com/lukas-krecan/ShedLock#jdbctemplate

    第三步:向数据库中插入表shedlock(必须)

    建表语句如下:

    CREATE TABLE shedlock(
    NAME VARCHAR(64),
    lock_until TIMESTAMP(3) NULL,
    locked_at TIMESTAMP(3) NULL,
    locked_by VARCHAR(255),
    PRIMARY KEY (NAME)
    )

    若没有创建该表则会报错。

    正常情况下完成后续操作以后查看shedlock表可以看到数据:

    第四步:添加配置类

    代码如下:

    import net.javacrumbs.shedlock.core.LockProvider;
    import net.javacrumbs.shedlock.provider.jdbctemplate.JdbcTemplateLockProvider;
    import net.javacrumbs.shedlock.spring.ScheduledLockConfiguration;
    import net.javacrumbs.shedlock.spring.ScheduledLockConfigurationBuilder;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    import javax.sql.DataSource;
    import java.time.Duration;
    
    /**
     * Created by 
     * Created 2020-09-01-17:10
     * Modify:
     */
    @Component
    public class ShedLockConfig {
        @Bean
        public LockProvider lockProvider(DataSource dataSource) {
            return new JdbcTemplateLockProvider(dataSource);
        }
    
        @Bean
        public ScheduledLockConfiguration scheduledLockConfiguration(LockProvider lockProvider) {
            return ScheduledLockConfigurationBuilder.withLockProvider(lockProvider)
                    .withPoolSize(10)
                    .withDefaultLockAtMostFor(Duration.ofMinutes(10))
                    .build();
        }
    }
    

    第五步:在启动类上添加@EnableSchedulerLock启动注解

    否则SchedulerLock不会生效,注解如下:

    @EnableSchedulerLock(defaultLockAtMostFor = "PT50S")


    第六步:添加@SchedulerLock到定时器业务方法入口

    在定时任务的方法中添加如下注解:

    @SchedulerLock(name = "scheduledTask", lockAtMostFor = ?, lockAtLeastFor = ?)
    

    相关参数说明:

    name属性:锁名称,必须指定,每次只能执行一个具有相同名字的任务,锁名称应该是全局唯一的;
    lockAtMostFor属性:设置锁的最大持有时间,为了解决如果持有锁的节点挂了,无法释放锁,其他节点无法进行下一次任务;
    lockAtMostForString属性:成功执行任务的节点所能拥有的独占锁的最长时间的字符串表达,例如“PT14M”表示为14分钟
    lockAtLeastFor属性:指定保留锁的最短时间。主要目的是在任务非常短的且节点之间存在时钟差异的情况下防止多个节点执行。这个属性是锁的持有时间。设置了多少就一定会持有多长时间,再此期间,下一次任务执行时,其他节点包括它本身是不会执行任务的
    lockAtLeastForString属性:成功执行任务的节点所能拥有的独占锁的最短时间的字符串表达,例如“PT14M”表示为14分钟

    第七步:测试

    本次遇到的问题是使用Scheduled定时发送邮件,在分布式系统中会根据节点数使每个节点发送重复的邮件,这样明显不符合业务要求。本次测试的定时任务代码如下:

    @Scheduled(fixedDelay = 3 * 60 * 1000, initialDelay = 60 * 1000)
        @SchedulerLock(name = "scheduledTask", lockAtMostFor = 60000, lockAtLeastFor = 60000)
        public void downloadScheduled() {
            System.err.println("localhost:8080 已发送测试邮件,请检查是否收到两封?");
            artificialPeekService.artificialPeekAudit(361655195741552640L, false);
        }

    本地启动两个相同的项目来模仿分布式系统,不同的是两个项目的端口号不同,相关的yml中端口号配置如下:

    同时启动两个项目:

    一段时间后,查看控制台输出,发现两个节点都执行了该定时任务,其中一个节点执行了1次另一个节点执行了3次:

    在看看各节点执行时间间隔:

    localhost:8080节点的执行时间分别为

    2020-09-01 19:58:28、2020-09-01 20:01:31、2020-09-01 20:04:32

    localhost:8081节点的执行时间为2020-09-01 20:07:32

    一段时间后,localhost:8080执行了第4次,时间为2020-09-01 20:10:32

    可以看到两个节点中任意两次任务的执行时间间隔为3分钟。

    再检查邮件发送时间间隔,也均为3分钟。

     

    展开全文
  • redis | 使用 redis 完成定时任务,这个场景你知道吗?
  • 需求:点击菜单时统计菜单的点击数量,由于菜单点击很频繁,采用redis缓存再定时存入mysql // 添菜单使用情况存入redis public PageData addRedis(PageData pd) { // 将对象转换成json字符串 String pdJson = JSON...
  • Spring Boot 整合Redis 在pom.xml中引入依赖 <!-- 引入 redis 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis&...
  • (六) Redis 实现Schedule 定时任务

    千次阅读 2019-10-17 22:58:26
    Schedule(定时任务) ⼀张图来说明(任务执⾏⻓度超过周期的情况): ​ 虽然定时任务可以嵌⼊到web应⽤程序和WAR⽂件中,但下⾯演⽰⼀种更简单的⽅法创建了⼀个独⽴的应⽤程序。您将所有的内容打包在⼀个单⼀的、可...
  • 一 因为项目中部署多台tomcat,同时定时任务希望只执行一次,在网上找了不少方法,结合自己的项目完成了redis分布式锁 项目是SSM,关于redis结合spring的配置就不贴了,网上有很多,大家认真找可以找到 首先我的...
  • redis与 crontab 定时任务

    千次阅读 2015-03-27 20:02:24
    redis php操作Redis 1、安装phpredis扩展 2、php链接redis服务-connect(127.0.0.1,6379) 3、set 设置缓存 4、 get获取缓存 设置缓存失效时间函数setex ...contab -e //设置定时任务 相当于设
  • Java redis精选面试题

    2020-12-27 23:55:13
    1.Redis 是一个基于内存的高性能key-value数据库。 2.Redis相比memcached有哪些优势: memcached所有的值均是简单的字符串,redis作为其替代者,支持更为丰富的数据类型 redis的速度比memcached快很多 redis可以...
  • Java Redis 做分布式锁

    2018-08-23 10:27:00
    最近在做集群的时候,多台服务器上都有Spring定时任务的代码。...2.在代码块中增加向Redis请求添加KEY的操作,添加成功则表示锁定,当前服务器执行定时任务。添加失败不执行定时任务。 3.执行完成...
  • Redis常用的数据类型 Redis的五种常用的数据类型分别是:String、Hash、List、Set和Sorted set Redis的使用场景 1.Counting(计数) 2.展示最近、最热、点击率最高、活跃度最高等等条件的top list 3.用户最近访问...
  • XXL任务调度平台+java实现定时任务

    万次阅读 2018-04-09 18:40:07
    1.java实现定时任务的四种方案1.1:Thread/** * 定时任务----Thread * Created by lizhen on 2018/4/9 0009. */ public class TimeTask001 { public static int i = 0; public static void main(String[] args)...
  • 在一些大的互联网平台,通常都会使用定时任务处理一些周期性的业务,而为了保障系统的高可用性,定时任务也会多节点部署,而解决多节点并发问题(分布式锁),大家通常会想到使用缓存,如redis,但是如果使用set / ...
  • 使用Redis+任务调度定时清理失效文件 场景 用户提交文件(以头像图片为例),用户上传头像需要将图片上传到文件服务器,文件的信息...1.需要定时任务定时清理这些没有被用户提交的图片(失效图片)。 任务调度框架:
  • 集群项目问题之一:定时任务的执行。页面配置/项目启动等产生的定时任务如何在集群下维护? 1.触发第一次启动线程时刻,...4.运行过程中修改定时任务相关配置,使用redis发布订阅重新开启定时任务。 ...
  • 最近公司需要推送一些信息给其他系统,因为数据数据量多,所以可以选择手动推送,也可以自动推送,说白了,就是做个定时任务推送给他们,哪有啥想的,搞呗,打工人,话不多说,直接上代码。 /** * 推送部门整体...
  • 使用定时框架quartz等,如果需要做以秒为单位的定时任务,那是相当大的一个体量。 这时我们就可以使用redis来完成。 使用的框架是Spring boot ,Spring Data Jpa pom文件如下: <?xml version="1.0" encoding=...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,364
精华内容 8,945
关键字:

javaredis定时任务

java 订阅
redis 订阅