1. 客户端抢到分布式锁之后开始执行任务，执行完毕后再释放分布式锁。
2. 持锁后因客户端异常未能把锁释放，会导致锁成为永恒锁。
3. 为了避免这种情况，在创建锁的时候给锁指定一个过期时间。
4. 到期之后锁会被自动删除掉，这个角度看是对锁资源的一种保护。
5. 重点：但若锁过期被删除后，任务还没结束怎么办？
6. 可以通过在一个额外的线程中主动推迟分布式锁的过期时间，下文也用续期一词来表述；避免当任务还没执行完，锁就被删除了。
7. 但当分布式锁很多的情况下，每个锁都配置一个线程着实浪费，所以是否可以用线程池里的定时任务呢？

在《【自省】使用Executors.xxx违反阿里Java代码规范，那还不写定时任务了？》 中仍然通过【自省】的方式讨论了也可以使用 ScheduledExecutorService#scheduleAtFixedRate来实现定时任务，它的运行机制大概是这样：

• 如果上一个任务的执行时间大于等待时间，任务结束后，下一个任务马上执行。
• 如果上一个任务的执行时间小于等待时间，任务结束后，下一个任务在（间隔时间-执行时间）后开始执行。

二、理还乱?

用 ScheduledExecutorService#scheduleAtFixedRate逻辑看很简单，也很清晰，但任何事情都有两面性，把任务丢给线程池的方式，实现起来自然简单清晰，但肯定也有弊端。如果要把锁的功能做的健壮，总要从不断地自我质疑、自我反思中，理顺思路，寻找答案，我认为这属于自省式学习，以后也想尝试这种模式，一起再看看有啥问题：

• 问题：锁主动释放的时候，续期的任务要关闭嘛？
• 是的，当锁被用户主动关闭的时候，主动续期的任务是要主动取消掉的。
• 问题：如果我不主动取消呢？
• 对于不主动续期的锁，抢锁后配置一个合适的过期时间，到期之后锁自然会被释放；这种情况下，客户端本就没有续期任务需要取消。但如果有额外的线程|线程池在定时续期的话，锁用完了需要被释放掉，任务一定要主动取消掉。
• 问题：可万一忘记了呢？
• 有加锁解锁的代码模板，按照模板来；获取锁之后，在finally中执行释放锁的操作。

boolean lockResult = lockInstance.tryLock()；

if(lockResult){
    //do work
}finally{
    lockInstance.unLock();
}

public interface Future { boolean cancel(boolean mayInterruptIfRunning); ... V get() throws InterruptedException, ExecutionException; ... } 复制代码

public static void testCancel() throws InterruptedException {
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);

    System.out.println(" start : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleAtFixedRate(() -> {
        System.out.println("  work : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    }, 5, 5, TimeUnit.SECONDS);

    TimeUnit.SECONDS.sleep(15);
    scheduledFuture.cancel(true);
    System.out.println("cancel : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    TimeUnit.SECONDS.sleep(30);
}

 start : 2022-12-10T19:24:31.508
  work : 2022-12-10T19:24:36.538
  work : 2022-12-10T19:24:41.539
  work : 2022-12-10T19:24:46.541
cancel : 2022-12-10T19:24:46.541 //成功取消

• 问题：cancel 里都做了什么呢？
• 看源码可知，其内有两层核心逻辑：
• 尝试取消正在执行的任务
• 避免任务再被定时执行

三、新的思考

问题：cancel的参数mayInterruptIfRunning 是什么意思？

从父类cancel方法的注释中可以寻找到答案，如果是 true 的话，即代表尝试通过中断的方式来停止任务

If the task has already started, then the mayInterruptIfRunning parameter determines whether the thread executing this task should be interrupted in an attempt to stop the task.

问题：那就是说也可能抛出 InterruptedException 了？

public static void testExceptionCatch() throws InterruptedException {
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
    ScheduledFuture<?> scheduledFuture = null;
    System.out.println(" start : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    try {
        scheduledFuture = scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("  work : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //throw new RuntimeException("");
        }, 5, 5, TimeUnit.SECONDS);
    }catch (Exception exp){
        exp.printStackTrace();
    }
    TimeUnit.SECONDS.sleep(15);
    scheduledFuture.cancel(true);
    System.out.println("cancel : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    TimeUnit.SECONDS.sleep(30);
}

结果中的信息 java.lang.InterruptedException: sleep interrupted 可以明确是任务内的逻辑是可通过中断机制实现的。

start : 2022-12-10T20:10:31.248
  work : 2022-12-10T20:10:36.276
  work : 2022-12-10T20:10:41.272
  work : 2022-12-10T20:10:46.277
cancel : 2022-12-10T20:10:46.277
java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at java.lang.Thread.sleep(Thread.java:340)
        at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
        at com.wushiyii.lock.ScheduleTest.lambda$testExceptionCatch$1(ScheduleTest.java:39)
        at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
        at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:308)
        at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:180)
        at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:294)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
        at java.lang.Thread.run(Thread.java:748)

问题：之前实例中取消任务时，外部也无异常信息，线程池内部留着这个异常干嘛了呢？

直接抛出异常试试看

public static void testExceptionCatch() throws InterruptedException {
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
    ScheduledFuture<?> scheduledFuture = null;
    System.out.println(" start : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    try {
        scheduledFuture = scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("  work : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
            throw new RuntimeException("just throw ");
            //throw new RuntimeException("");
        }, 5, 5, TimeUnit.SECONDS);
    }catch (Exception exp){
        exp.printStackTrace();
    }
    TimeUnit.SECONDS.sleep(15);
    scheduledFuture.cancel(true);
    System.out.println("cancel : " + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    TimeUnit.SECONDS.sleep(30);
}

仔细观察能看出，结果变的有意思了，work只执行了一次，前文中的执行结果中work都执行了3次，这里却只执行了一次。

 start : 2022-12-10T20:16:53.285
  work : 2022-12-10T20:16:58.307
cancel : 2022-12-10T20:17:08.305

问题：任务内抛出异常能导致定时任务失去定时执行的能力？

是的，使用scheduleAtFixedRate有以下几个情况必须注意：

1. 任务逻辑中未捕获的异常能导致本该定时执行的任务，后续不再执行。
2. 任务逻辑中未捕获的异常不会外抛，外部感知不到。
3. 任务逻辑中的异常，需在任务逻辑内捕获并记录，否则无处可知。