基于mysql数据库做分布式锁的基本实现

基于redis作为工具做分布式锁

推荐文章：Java分布式锁看这篇就够了

【原理】

思路：利用主键唯一的特性，如果有多个请求同时提交到数据库的话，数据库会保证只有一个操作可以成功，那么我们就可以认为操作成功的那个线程获得了该方法的锁，当方法执行完毕之后，想要释放锁的话，删除这条数据库记录即可。

【实现】

创建task_lock表，注意key作为唯一主键

基于数据库 乐观锁的 分布式锁工具类 实现如下

/**
 * 基于数据库 乐观锁的 分布式锁
 *
 * 利用主键唯一的特性，如果有多个请求同时提交到数据库的话，
 * 数据库会保证只有一个操作可以成功，那么我们就可以认为操作成功的那个线程获得了该方法的锁，
 * 当方法执行完毕之后，想要释放锁的话，删除这条数据库记录即可。
 * Created by xjb on 2019/6/24
 */
@Component
public class SynTaskLockUtils {
    private static Logger logger = LoggerFactory.getLogger(SynTaskLockUtils.class);

    @Autowired
    TaskLockMapper taskLockMapper;

    //每个小时第52分钟执行一次
    @Scheduled(cron = "0 52 * * * ?")
    private void checkSynTaskKeyIsExpire() {
        logger.info("=========开始检查数据库分布式锁的过期时间=======");
        List<TaskLock> taskLocks = taskLockMapper.findAll();
        //筛选出过期的key
        List<TaskLock> taskLockList = taskLocks.stream().
                filter(taskLock -> new Date().getTime() - taskLock.getUtime().getTime()
                        - taskLock.getTimeout() * 1000 > 0).collect(Collectors.toList());
        taskLockList.forEach(taskLock -> {
            taskLockMapper.deleteByPrimaryKey(taskLock.getKey());
        });
        logger.info("=========trs_task_lock 删除{}条 过期的key=======",taskLockList.size());
    }

    /**
     * 获取分布式锁
     * 根据插入语句中的主键冲突，相同主键的多次插入操作，只会有一次成功，成功的就获得分布式锁执行任务的权利
     * @param key
     * @param ip
     * @param desc
     * @param timeout 单位秒
     * @return
     */
    public boolean tryLock(String key, String ip, String desc, int timeout) {
        TaskLock taskLock = new TaskLock();
        taskLock.setKey(key);
        taskLock.setTimeout(timeout);
        taskLock.setIp(ip);
        taskLock.setDescription(desc);
        int sum = 0;
        try {
            sum = taskLockMapper.insertSelective(taskLock);
        } catch (Exception e) {
            logger.info("{} 其他机器已经在执行", key);

        }
        return sum == 1;

    }

    /**
     * 删除分布式锁
     *
     * @param redisKey
     * @return
     */
    public boolean del(String redisKey) {
        int sum = taskLockMapper.deleteByPrimaryKey(redisKey);
        return sum == 1;
    }

    /**
     * 获得key中对象
     * @param redisKey
     * @return
     */
    public TaskLock get(String redisKey) {
        return taskLockMapper.selectByPrimaryKey(redisKey);
    }

    /**
     *
     * @param key
     * @param value
     * @param ip
     */
    public void set(String key, String value,String ip) {
        TaskLock taskLock = new TaskLock();
        taskLock.setKey(key);
        taskLock.setTimeout(-1);
        taskLock.setIp(ip);
        taskLock.setDescription(value);
        taskLockMapper.insertOrUpdate(taskLock);
    }

    public boolean hasKey(String queryEndTimeRedisKey) {
        return taskLockMapper.queryCount(queryEndTimeRedisKey)==1;
    }
}

TaskLock 实体类

/**
 * 分布式锁
 * 基于mysql数据库做的分布式锁 类redis的  key-value
 *
 */
public class TaskLock {
    /**
     * 键名  key-value的 key
     */
    private String key;
    /**
     * 过期时间 避免死锁
     */
    private Integer timeout;
    /**
     * 运行机器ip
     */
    private String ip;
    /**
     * 描述 key-value的 value
     */
    private String description;


    /**
     * 修改时间
     */
    private Date utime;

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key == null ? null : key.trim();
    }

    public Integer getTimeout() {
        return timeout;
    }

    public void setTimeout(Integer timeout) {
        this.timeout = timeout;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip == null ? null : ip.trim();
    }

    public String getDesc() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description == null ? null : description.trim();
    }



    public Date getUtime() {
        return utime;
    }

    public void setUtime(Date utime) {
        this.utime = utime;
    }
}

TaskLockMapper.java

public interface TaskLockMapper {
    int deleteByPrimaryKey(String key);

    int insertSelective(TaskLock record);

    TaskLock selectByPrimaryKey(String key);

    List<TaskLock> findAll();

    int queryCount(String key);

    void insertOrUpdate(TaskLock taskLock);
}

TaskLockMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xjb.data.mapper.cluster.TaskLockMapper">
    <resultMap id="BaseResultMap" type="com.xjb.data.lock.TaskLock">
        <id column="key" property="key" jdbcType="VARCHAR"/>
        <result column="timeout" property="timeout" jdbcType="INTEGER"/>
        <result column="ip" property="ip" jdbcType="VARCHAR"/>
        <result column="description" property="description" jdbcType="VARCHAR"/>

        <result column="utime" property="utime" jdbcType="TIMESTAMP"/>
    </resultMap>
    <sql id="Base_Column_List">
    key, timeout, ip, description,  utime
  </sql>
    <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String">
        select
        <include refid="Base_Column_List"/>
        from trs_task_lock
        where key = #{key,jdbcType=VARCHAR}
    </select>
    <delete id="deleteByPrimaryKey" parameterType="java.lang.String">
    delete from trs_task_lock
    where key = #{key,jdbcType=VARCHAR}
  </delete>

    <insert id="insertSelective" parameterType="com.xjb.data.lock.TaskLock">
        insert into trs_task_lock
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="key != null">
                key,
            </if>
            <if test="timeout != null">
                timeout,
            </if>
            <if test="ip != null">
                ip,
            </if>
            <if test="description != null">
                description,
            </if>

            <if test="utime != null">
                utime,
            </if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
            <if test="key != null">
                #{key,jdbcType=VARCHAR},
            </if>
            <if test="timeout != null">
                #{timeout,jdbcType=INTEGER},
            </if>
            <if test="ip != null">
                #{ip,jdbcType=VARCHAR},
            </if>
            <if test="description != null">
                #{description,jdbcType=VARCHAR},
            </if>

            <if test="utime != null">
                #{utime,jdbcType=TIMESTAMP},
            </if>
        </trim>
    </insert>

    <select id="findAll" resultMap="BaseResultMap">
        select * from trs_task_lock where timeout  <![CDATA[ > ]]>   0
    </select>

    <select id="queryCount" resultType="java.lang.Integer" parameterType="java.lang.String">
        select count(*) from trs_task_lock where key=#{key}
    </select>
    <insert id="insertOrUpdate">
        insert into trs_task_lock (
        key,
        timeout,
        ip,
        description
        )
        values
            (
            #{key,jdbcType=VARCHAR},
            #{timeout,jdbcType=VARCHAR},
            #{ip,jdbcType=VARCHAR},
            #{description,jdbcType=VARCHAR}
            )
        ON CONFLICT(key)
        do UPDATE
        set
        key=excluded.key,
        timeout=excluded.timeout,
        ip=excluded.ip,
        description=excluded.description
    </insert>
</mapper>

测试代码：

@Component
public class Task2 {
    private static Logger logger = LoggerFactory.getLogger(Task2.class);
    @Autowired
    SynTaskLockUtils synTaskLockUtils;

    String redisKey = "java-Task-isRun";

    //单位为秒  默认十分钟
    private int redis_default_expire_time = 60 * 3;


    @Scheduled(cron = "0 */1 * * * ?")
    public void run() throws InterruptedException {


        //-------------上分布式锁开始-----------------

        InetAddress addr = null;
        try {
            addr = InetAddress.getLocalHost();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        //获取本机ip
        String ip = addr.getHostAddress();
        //默认上锁时间为五小时
        //此key存放的值为任务执行的ip，
        // redis_default_expire_time 不能设置为永久，避免死锁
        boolean lock = synTaskLockUtils.tryLock(redisKey, ip, "1", redis_default_expire_time);
        logger.info("============本次聚类定时任务开始==============");
        if (lock) {
            logger.info("============获得分布式锁成功=======================");
            //TODO 开始执行任务 执行结束后需要释放锁
            ccc();
            synTaskLockUtils.del(redisKey);
            logger.info("============释放分布式锁成功=======================");

        } else {
            logger.info("============获得分布式锁失败=======================");
            ip =  synTaskLockUtils.get(redisKey).getIp();
            logger.info("============{}机器上占用分布式锁，聚类任务正在执行=======================", ip);
            logger.info("============本次聚类定时任务结束==============");
            return;
        }
    }

    public void ccc() throws InterruptedException {

        System.out.println("执行中");
        Thread.sleep(1000 * 60 * 2);
        System.out.println("执行结束");

    }
}