分布式环境下定时任务单点运行_quartz指定ip执行

link之家
链接快照平台
输入网页链接，自动生成快照
标签化管理网页链接
方案一：根据机器的IP来限制

因为部署服务的7台机器ip是已知的，那么就可以通过ip来限制哪台机器上的应用可以跑定时任务，获取本服务器或者客户端ip方法，请移步至: Java获取客户端、本机IP
@Component
@Slf4j
public class RegularTask {
    @Lazy
    @Scheduled(cron = "")
    public void send() {
        //获取本台服务器ip
        String ip = IPUtil.getLocalIP(); 
        //允许执行定时任务的ip强烈建议配置在数据库中，做成可配置化，不要写死
        String allowIp = PropertiesUtil.get("RUN_TASK_IP");
        //ip不匹配直接return
        if (allowIp.indexOf(ip) == -1) { 
            log.info("……");
            return;
        //TODO deal with task
方案二：分布式锁实现 
让7台机器上的应用各自去争取同一把锁，谁抢到了锁就让谁执行，实现方式可以使用zookeeper或者redis，基于redis实现分布式锁:https://blog.csdn.net/fanrenxiang/article/details/79803037、基于zookeeper实现分布式锁:https://blog.csdn.net/fanrenxiang/article/details/81704691。比如redis实现分布式锁的部分代码: 
@Component
public class RegularTask {
    @Autowired
    private JedisPool jedisPool;
    @Lazy
    @Scheduled(cron = "")
    public void send() {
        Jedis jedis =null;
        try {
            jedis = jedisPool.getResource();
            boolean isLock = this.tryLock(jedis, "lock_ip_key", RandomStringUtils.randomNumeric(16), 1800); //过期时间为30min
            if (isLock) {
                //TODO  do task
        }catch (Exception e){
            log.error("");
        }finally {
            if(jedis!=null){
                jedis.close();
    private static final String LOCKED_SUCCESS = "OK";
    private static final String NX = "NX";
    private static final String EXPIRE_TIME = "EX";
    public static boolean tryLock(Jedis jedis, String lockKey, String uniqueId, long expireTime) {
        String result = jedis.set(lockKey, uniqueId, NX, EXPIRE_TIME, expireTime);
        return LOCKED_SUCCESS.equals(result);
方案三：基于zookeeper的master选举 
利用zookeeper来实现Master选举，只有Master机器（leader）上能执行定时任务。分布式机器同时在zookeeper中的同一节点下创建节点，zookeeper保证了只有一个能创建成功（临时节点），Curator里面就封装了这些操作。选举分为Leader Latch和Leader Election两种选举方案，这里使用Leader Latch实现。更多的关于zookeeper客户端curator，请移步这里 
<dependency>
   <groupId>org.apache.curator</groupId>
   <artifactId>curator-recipes</artifactId>
   <version>2.4.1</version>
</dependency> 
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.leader.LeaderLatch;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.io.IOException;
@Component
public class RegularTask {
    private static final Logger log = LoggerFactory.getLogger(RegularTask.class);
    //zookeeper集群，实例数大于等于3
    private static final String ZOOKEEPER_STR = "10.25.142.55:2181,10.48.24.36:2181,10.48.24.36:2182,10.48.124.36:2181,10.48.125.36:2181";
    private static CuratorFramework curatorFramework;
    private static LeaderLatch leaderLatch;
    static {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        curatorFramework = CuratorFrameworkFactory.newClient(ZOOKEEPER_STR, retryPolicy);
        curatorFramework.start();
        leaderLatch = new LeaderLatch(curatorFramework, "/regulartask");
        try {
            leaderLatch.start();
        } catch (Exception e) {
            log.error("LeaderLatch start error:{}", e);
    @Lazy
    @Scheduled(cron = "××")
    public void send() {
        try {
            //判断是否为master
            if (!leaderLatch.hasLeadership()) {
                log.info("current mechine is not a leader");
                return;
            //TODO 定时任务逻辑
        } catch (Exception e) {
            log.error("regulartask run error:{}", e);
        } finally {
            try {
                if (leaderLatch != null) {
                    leaderLatch.close();
            } catch (IOException e) {
                log.error("leaderLatch close error:{}", e);
                e.printStackTrace();
我们项目中使用的就是zookeeper的master选举实现的，可靠，稳定，线上还没出现过问题！ 
 使用quartz实现分布式定时任务(包含管理界面):https://blog.csdn.net/fanrenxiang/article/details/85539918
可在表中加个状态的枚举字段state。
执行update tb set state = t2 where state = t1; update 的结果为1时表示获得执行，为0则不需执行。
3、spring cloud 中，可根据注册中心中的节点，仅有一
				分布式定时任务保证单例
是否要保证单例，其实看你具体的业务需求，如果重复执行不影响你的业务逻辑，那其实业务上是可以容忍的，但是技术上分析，重复执行定时任务，必定会占用和损耗计算机的资源。如果我一定要保证单例，有哪些方案呢？
1，使用分布式锁
分布式锁的方案很常见，一般也用redis锁或者zk锁，我个人推荐zk锁，因为任务的执行时间一般过长，有时候因为服务器的自身情况（或繁忙或空闲），所以会导致redis的过期时间不好评估，所以无疑增加了有可能重复跑任务的风险。
另外，每个服务器时间的机器时间是不统一的，所以
将带有定时任务的项目部署在单台测试环境上，完全没问题。生产上是两台集群服务器，项目部署上去发现定时任务的模块同时在两台机器上各执行了一遍，这将会导致其他意外的发生。
解决方案----redis分布式锁
使用redis分布式锁，为定时任务唯一指定的key加锁，并设置锁超时时间。当触发定时任务时，一台服务的任务进入切面，通过setNX(key,value)方法为唯一的key加锁，如果当前key不存在，将放入缓存，并返回true,通过expire(key,second)设置锁超时时间，结束后跳出执
				首先说下情况，我们平常开发SpringCloud微服务的时候，若要确保高可用，同一服务都会部署多台实例，然后注册到Eureka上。
一般我们会把所有定时任务写到一个服务里，那平常单实例的时候，都可以正常执行。如果该定时任务服务部署多个实例，如何确保只在一个服务实例里执行任务呢？
个人总结了下，可以有以下解决思路。
使用分布式锁
借助分布式锁，确保多个实例里的task只有竞争到锁的实例任务才执行。比如，redis的分不式锁。这种方式不好的地方是需要修改逻辑代码，增加了对redis的依赖。
				原文链接https://zhuanlan.zhihu.com/p/97068262  https://blog.csdn.net/J_Shine/article/details/80406743
1.使用redis分布式锁，为定时任务唯一指定的key加锁，并设置锁超时时间。当触发定时任务时，通过setNX(key,value)方法为唯一的key加锁，如果当前key不存在，将放入缓...
				一、大致介绍
1、因网友提到有没有采用注解式配置的Quartz例子，因此本人就贴上了这样一个样例；
2、至于如何修改定时任务的 cronExpression 表达式值的话，大家可以参照之前的（第 010 篇）样子看看如何修改；
3、注意：配置文件中的 mysql 数据库链接配置大家就各自配置自己的哈；
二、实现步骤
2.1 添加 maven 引用包
&lt;?xml version="1.0" ...
	Timer和ScheduledThreadPoolExucutor区别
	Timer是基于绝对时间，ScheduledThreadPoolExucutor基于相对时间
		Timer是单线程，ScheduledThreadPoolExucutor是多线程
		Timer运行发
				单点模式：javaee项目部署在一台tomcat上，所有的请求，都由这一台机器处理，问题很大。
1.并发处理能力因为单点服务器的性能有限制，所以单台tomcat的最大连接数有限。
2.容错率低，一旦服务器故障，项目无法正常运行。
3.单独的服务器计算能力低，无法完成复杂的海量数据计算。
集群：多台服务器集中，实现相同的项目。每台服务器存在的作用缓解高并发，发生故障转移服务到另外的空闲服务器上。