Spring Boot：使用Jedis实现分布式锁

在单机应用中通过使用​​synchronized​​​关键字、​​JUC​​​的​​Lock​​来实现线程安全是没问题的，但在分布式环境中就有可能出现问题，因为这些同步机制、锁是不能跨机器的，所以这里介绍的分布式锁就很有必要。

首先创建两个​​Spring Boot​​项目。

​​pom.xml​​（两个项目都一样）:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.kaven</groupId>
    <artifactId>distributelock</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <name>distributelock</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

​​Jedis​​组件（两个项目都一样）：

package com.kaven.distributelock.component;

import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;

@Component
public class JedisComponent {

    @Bean
    public Jedis jedis(){
        return new Jedis("localhost",6379);
    }
}

项目一接口：

package com.kaven.distributelock.controller;

import com.kaven.distributelock.lock.JedisLock;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

@RestController
public class NumberController {

    private AtomicInteger count = new AtomicInteger(0);

    @Resource
    private Jedis jedis;

    @PutMapping("/number")
    public synchronized void subNumber() throws InterruptedException {
        Integer number = Integer.parseInt(jedis.get("number"));
        Thread.sleep(400);
        number-=1;
        jedis.set("number" , number.toString());
        count.addAndGet(1);
        System.out.println(count.get());
    }
}

项目二接口：

package com.kaven.distributelock.controller;

import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

import javax.annotation.Resource;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;

@RestController
public class NumberController {

    private AtomicInteger count = new AtomicInteger(0);

    @Resource
    private Jedis jedis;

    @PutMapping("/number")
    public synchronized void subNumber() throws InterruptedException {
        Integer number = Integer.parseInt(jedis.get("number"));
        Thread.sleep(1000);
        number-=1;
        jedis.set("number" , number.toString());
        count.addAndGet(1);
        System.out.println(count.get());
    }
}

启动类（两个项目都一样）：

package com.kaven.distributelock;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DistributeLockApplication {

    public static void main(String[] args) {
        SpringApplication.run(DistributeLockApplication.class, args);
    }
}

项目一运行在​​8080​​​端口，项目二运行在​​8081​​端口。测试：

从上面几张图可以得知，项目一接口会将​​number​​​减​​100​​​次，而项目二接口会将​​number​​​减​​50​​​次，并且都执行成功了，理想情况下​​redis​​​里面的​​number​​​应该为​​0​​​，但实际情况却为​​86​​​，如下图所示，所以​​synchronized​​关键字在分布式环境下是不能保障数据同步的（只能单机应用场景的锁，是不能保障分布式环境下数据同步）。

接下来使用​​Jedis​​实现分布式锁（两个项目都一样）：

package com.kaven.distributelock.lock;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;

import java.util.Collections;

public class JedisLock {

    private static final String LOCK_SUCCESS = "OK";
    private static final Long RELEASE_SUCCESS = 1L;

    /**
     * 尝试获取分布式锁
     * @param jedis Redis客户端
     * @param lockKey 锁
     * @param requestId 请求标识
     * @param millisecondsToExpire 超期时间
     * @return 是否获取成功
     */
    public static boolean tryGetDistributedLock(Jedis jedis, String lockKey, String requestId, long millisecondsToExpire) {

        String result = jedis.set(lockKey,requestId, SetParams.setParams().nx().px(millisecondsToExpire));

        if (LOCK_SUCCESS.equals(result)) {
            return true;
        }
        return false;
    }

    /**
     * 释放分布式锁
     * @param jedis Redis客户端
     * @param lockKey 锁
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public static boolean releaseDistributedLock(Jedis jedis, String lockKey, String requestId) {

        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = jedis.eval（script, Collections.singletonList(lockKey), Collections.singletonList(requestId));

        if (RELEASE_SUCCESS.equals(result)) {
            return true;
        }
        return false;
    }
}

项目一接口：

package com.kaven.distributelock.controller;

import com.kaven.distributelock.lock.JedisLock;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

@RestController
public class NumberController {

    private AtomicInteger count = new AtomicInteger(0);

    @Resource
    private Jedis jedis;

    @PutMapping("/number")
    public void subNumber() throws InterruptedException {
        String requestId = UUID.randomUUID().toString();
        String LOCKKEY = "LOCKKEY";
        if(JedisLock.tryGetDistributedLock(jedis , LOCKKEY , requestId , 3000)){
            Integer number = Integer.parseInt(jedis.get("number"));
            Thread.sleep(400);
            number-=1;
            jedis.set("number" , number.toString());
            count.addAndGet(1);
            System.out.println(count.get());
            JedisLock.releaseDistributedLock(jedis , LOCKKEY , requestId);
        }
    }
}

项目二接口：

package com.kaven.distributelock.controller;

import com.kaven.distributelock.lock.JedisLock;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

@RestController
public class NumberController {

    private AtomicInteger count = new AtomicInteger(0);

    @Resource
    private Jedis jedis;

    @PutMapping("/number")
    public void subNumber() throws InterruptedException {
        String requestId = UUID.randomUUID().toString();
        String LOCKKEY = "LOCKKEY";
        if(JedisLock.tryGetDistributedLock(jedis , LOCKKEY , requestId , 3000)){
            Integer number = Integer.parseInt(jedis.get("number"));
            Thread.sleep(1000);
            number-=1;
            jedis.set("number" , number.toString());
            count.addAndGet(1);
            System.out.println(count.get());
            JedisLock.releaseDistributedLock(jedis , LOCKKEY , requestId);
        }
    }
}

将​​redis​​​里面的​​number​​​变量设置成​​3000​​​（字符串），因为没有获取到锁的话，代码就直接跑完了，所以这里让测试次数多一些，项目一接口请求​​2000​​​次，项目二接口请求​​1000​​次（因为获取到锁只是少部分）。

同时点击测试。

项目一接口获取到锁​​34​​次。

项目二接口获取到锁​​218​​次。

结果很显然是正确的（​​34+218=3000-2748​​​）。​​Spring Boot​​​使用​​Jedis​​实现分布式锁就介绍到这里，写博客是博主记录自己的学习过程，如果有错误，请指正，谢谢！