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);
    }
}

项目一运行在

端口，项目二运行在

端口。测试：

从上面几张图可以得知，项目一接口会将

number

减

次，而项目二接口会将

number

减

次，并且都执行成功了，理想情况下

redis

里面的

number

应该为

，但实际情况却为

，如下图所示，所以

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

变量设置成

（字符串），因为没有获取到锁的话，代码就直接跑完了，所以这里让测试次数多一些，项目一接口请求

次，项目二接口请求

次（因为获取到锁只是少部分）。

同时点击测试。

项目一接口获取到锁

次。

项目二接口获取到锁

次。

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

继续阅读

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

express 搭建后台构建工程目录结构

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method