Redisson分布式锁实现

底层原理：

// 大致逻辑，如下图
1.尝试获取锁
2.若获取到锁，则去执行业务逻辑，最终释放锁unlock.
3.若没有获取到锁,则首先会订阅锁状态变更的消息.
4.接着遍历
5.首先会再次尝试获取锁，若得到锁，走2的逻辑.
6.若还是没有得到锁，此时会有锁剩余过期时间，然后对该线程进行阻塞（阻塞时间为ttl）
7.但是在阻塞期间，锁可能提前释放了，所以释放锁的逻辑中会发布一个消息，提醒订阅的线程可以去再次争抢锁，不用等到ttl过去.

过期时间自动延时

如果持有锁的线程执行业务时间非常久，超过了过期时间，这样就有问题了，所以redisson还为我们提供了自动延时的功能。
当线程加锁成功后，会异步起一个线程延长锁时间

看门狗失效情况:

1：如果lock() 和 tryLock() 方法设置锁时长 看门狗就会失效

        不设置时长:默认锁时长30s, 没10s自动续期到30s,需要手动结束释放锁

        (leaseTime 参数传入:-1)  

2：如果本地调试过程中方法断点时间过长,会认为服务宕机,看门狗机制线程也就没有了,就不会自动延长key的过期时间

引入maven依赖

  <dependency>
      <groupId>org.redisson</groupId>
      <artifactId>redisson</artifactId>
      <version>3.14.1</version>
</dependency>
 

Redisson客户端注册为Spring Bean

@Configuration
public class RedissonConfig {
	// 配置redis信息
    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.database}")
    private int database;

    @Value("${spring.redis.port}")
    private String port;

    @Value("${spring.redis.password}")
    private String password;

	//  Redisson客户端注册到Spring管理
    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://"+host+":"+port).setDatabase(database);
        if (StringUtils.isNotBlank(password)){
            config.useSingleServer().setPassword(password);
        }
        config.setCodec(new StringCodec());
        return Redisson.create(config);
    }
}

工具类:

DistributedLock 接口

package com.yunxin.core.utils.infra.support.lock;

import java.util.concurrent.TimeUnit;

/**
 * 分布式锁
 *
 * @author zero°
 * @since 2023-05-25
 */
public interface DistributedLock {

    /**
     * 加锁，不等待，锁持有时间为leaseTime
     *
     * @param leaseTime leaseTime
     * @param unit      unit
     */
    void lock(long leaseTime, TimeUnit unit);

    /**
     * 尝试加锁，等待时间为waitTime，锁持有时间为leaseTime
     *
     * @param waitTime  waitTime
     * @param leaseTime leaseTime
     * @param unit      unit
     * @return get lock or not
     */
    boolean tryLock(long waitTime, long leaseTime, TimeUnit unit);

    /**
     * 解锁
     */
    void unlock();

    /**
     * 是否持有锁
     *
     * @return hold lock or not
     */
    boolean isLock();

    /**
     * 锁是否被当前线程持有
     *
     * @return hold lock or not
     */
    boolean isHeldByCurrentThread();
}

DistributedLock实现类:

package com.yunxin.core.utils.infra.support.lock;


import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

import java.util.concurrent.TimeUnit;

/**
 * @author zero°
 * @since 2023-05-25
 */
@Slf4j
public class RedissonDistributedLock implements DistributedLock {

    private final RedissonClient redissonClient;
    private final String lockPath;
    private final RLock internalLock;

    RedissonDistributedLock(RedissonClient redissonClient, String lockPath) {
        this.redissonClient = redissonClient;
        this.lockPath = lockPath;
        this.internalLock = initInternalLock();
    }

    private RLock initInternalLock() {
        return redissonClient.getLock(lockPath);
    }

    @Override
    public boolean isLock() {
        return internalLock.isLocked();
    }

    @Override
    public boolean isHeldByCurrentThread() {
        return internalLock.isHeldByCurrentThread();
    }

    @Override
    public void lock(long leaseTime, TimeUnit unit) {
        internalLock.lock(leaseTime, unit);
    }

    @Override
    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) {
        try {
            return internalLock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new IllegalStateException(String.format("Acquire lock fail by thread interrupted,path:%s", lockPath), e);
        }
    }

    @Override
    public void unlock() {
        try {
            internalLock.unlock();
        } catch (IllegalMonitorStateException ex) {
            log.warn("Unlock path:{} error for thread status change in concurrency", lockPath, ex);
        }
    }
}

DistributedLockFactory接口:

package com.yunxin.core.utils.infra.support.lock;

/**
 * 分布式锁工厂
 *
 * @author zero°
 * @since 2023-05-25
 */
public interface DistributedLockFactory {

    /**
     * 获取分布式锁
     *
     * @param lockKey lockKey
     * @return DistributedLock
     */
    DistributedLock provideDistributedLock(String lockKey);
}

DistributedLockFactory实现类:

package com.yunxin.core.utils.infra.support.lock;


import lombok.RequiredArgsConstructor;
import org.redisson.api.RedissonClient;

/**
 * 分布式锁工厂 - Redisson实现
 *
 * @author zero°
 * @since 2023-05-25
 */
@RequiredArgsConstructor
public class RedissonDistributedLockFactory implements DistributedLockFactory {

    private static final String DISTRIBUTED_LOCK_PATH_PREFIX = "dl:";

    private final RedissonClient redissonClient;

    @Override
    public DistributedLock provideDistributedLock(String lockKey) {
        String lockPath = DISTRIBUTED_LOCK_PATH_PREFIX + lockKey;
        return new RedissonDistributedLock(redissonClient, lockPath);
    }
}

锁的key 枚举:

package com.yunxin.core.utils.infra.support.lock;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

import java.util.concurrent.TimeUnit;

/**
 * @author xiaoqi
 * @since 2024-03-26
 */
@RequiredArgsConstructor
@Getter
public enum TaskLockKey {

    /**
     * 任务执行
     */
    teamTask_LOCK_KEY("team:task:lock:", 3L, 30L, TimeUnit.SECONDS),//获取锁等待1秒 非手动释放锁的情况下获取锁时常为15秒
    sendMage_LOCK_KEY("send:mage:task:lock:", 3L, 600L, TimeUnit.SECONDS),
    //test_LOCK_KEY("send:mage:task:lock:", 1L, 20L, TimeUnit.SECONDS),

    ;

    private final String prefix;
    private final long waitTime;
    private final long releaseTime;
    private final TimeUnit timeUnit;
}

调用:

package com.yunxin.admin.system.api.system.task;

import com.yunxin.core.utils.infra.support.lock.DistributedLock;
import com.yunxin.core.utils.infra.support.lock.DistributedLockFactory;
import com.yunxin.core.utils.infra.support.lock.TaskLockKey;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.net.InetAddress;

@Component
@Slf4j
@RequiredArgsConstructor
public class TeamTask {
    private final DistributedLockFactory distributedLockFactory;

    @Scheduled(cron = "0/10 * * * * *")
    @Transactional(rollbackFor = Exception.class)
    public void teamTask() {
        try {
            TaskLockKey taskLockKey = TaskLockKey.teamTask_LOCK_KEY;
            DistributedLock lock = distributedLockFactory.provideDistributedLock(taskLockKey.getPrefix());
            boolean tryLock = lock.tryLock(taskLockKey.getWaitTime(), taskLockKey.getReleaseTime(), taskLockKey.getTimeUnit());
            String hostAddress = InetAddress.getLocalHost().getHostAddress();
            if (tryLock){
                try {
	       //业务逻辑写在这里面



                }finally {
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            }else {
                log.info("ip:{},执行TeamTask任务失败,获取锁失败......", hostAddress);
            }
        }catch (Exception e) {
            log.error("执行TeamTask任务异常", e);
        }
    }
}