SpringBoot整合redisson实现分布式锁

SpringBoot整合redisson实现分布式锁

本文主要通过 SpringBoot 整合 redisson 来实现分布式锁，并结合 demo 测试结果。

1、pom依赖

<?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.5.4</version>
        <relativePath/>
    </parent>
	
    <groupId>com.example</groupId>
    <artifactId>springboot-redission</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-redission</name>
    <description>springboot-redission</description>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!-- redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.10.6</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

    </dependencies>

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

</project>

2、配置信息

spring:
  # redis
  redis:
    host: 127.0.0.1
    port: 6379
    jedis:
      pool:
        # 连接池最大连接数（使用负值表示没有限制）
        max-active: 100
        # 连接池中的最小空闲连接
        max-idle: 10
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
      # 连接超时时间（毫秒）
      timeout: 5000
      # 默认是索引为0的数据库
      database: 0

3、配置类

package com.example.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

/**
 * redisson配置
 */

@Configuration
public class RedissonConfig {

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

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

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

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        //单节点
        config.useSingleServer().setAddress("redis://" + host + ":" + port);
        if (StringUtils.isEmpty(password)) {
            config.useSingleServer().setPassword(null);
        } else {
            config.useSingleServer().setPassword(password);
        }
        return Redisson.create(config);
    }
}

4、Redisson 工具类

package com.example.utils;

import org.redisson.api.RCountDownLatch;
import org.redisson.api.RLock;
import org.redisson.api.RSemaphore;

import java.util.concurrent.TimeUnit;

public interface DistributedLocker {

    RLock lock(String lockKey);

    RLock lock(String lockKey, int timeout);

    RLock lock(String lockKey, TimeUnit unit, int timeout);

    boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime);

    void unlock(String lockKey);

    void unlock(RLock lock);

    RCountDownLatch getCountDownLatch(String name);

    RSemaphore getSemaphore(String name);
}

package com.example.utils;

import org.redisson.api.RCountDownLatch;
import org.redisson.api.RLock;
import org.redisson.api.RSemaphore;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class RedisDistributedLocker implements DistributedLocker {

    @Autowired
    private RedissonClient redissonClient;

    @Override
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    @Override
    public RLock lock(String lockKey, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
        return lock;
    }

    @Override
    public RLock lock(String lockKey, TimeUnit unit ,int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }

    @Override
    public boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }

    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    @Override
    public void unlock(RLock lock) {
        lock.unlock();
    }

    @Override
    public RCountDownLatch getCountDownLatch(String name) {
        return redissonClient.getCountDownLatch(name);
    }

    @Override
    public RSemaphore getSemaphore(String name) {
        return redissonClient.getSemaphore(name);
    }
}

package com.example.utils;

import org.redisson.api.RCountDownLatch;
import org.redisson.api.RLock;
import org.redisson.api.RSemaphore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * redis分布式锁帮助类
 *
 * @author gourd
 */
@Component
public class RedisLockUtil {

    @Autowired
    private DistributedLocker distributedLocker;

    /**
     * 加锁
     *
     * @param lockKey
     * @return
     */
    public  RLock lock(String lockKey) {
        return distributedLocker.lock(lockKey);
    }

    /**
     * 释放锁
     *
     * @param lockKey
     */
    public  void unlock(String lockKey) {
        distributedLocker.unlock(lockKey);
    }

    /**
     * 释放锁
     *
     * @param lock
     */
    public  void unlock(RLock lock) {
        distributedLocker.unlock(lock);
    }

    /**
     * 带超时的锁
     *
     * @param lockKey
     * @param timeout 超时时间   单位：秒
     */
    public  RLock lock(String lockKey, int timeout) {
        return distributedLocker.lock(lockKey, timeout);
    }

    /**
     * 带超时的锁
     *
     * @param lockKey
     * @param unit    时间单位
     * @param timeout 超时时间
     */
    public  RLock lock(String lockKey, int timeout, TimeUnit unit) {
        return distributedLocker.lock(lockKey, unit, timeout);
    }

    /**
     * 尝试获取锁
     *
     * @param lockKey
     * @param waitTime  最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @return
     */
    public  boolean tryLock(String lockKey, int waitTime, int leaseTime) {
        return distributedLocker.tryLock(lockKey, TimeUnit.SECONDS, waitTime, leaseTime);
    }

    /**
     * 尝试获取锁
     *
     * @param lockKey
     * @param unit      时间单位
     * @param waitTime  最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @return
     */
    public  boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
        return distributedLocker.tryLock(lockKey, unit, waitTime, leaseTime);
    }

    /**
     * 获取计数器
     *
     * @param name
     * @return
     */
    public  RCountDownLatch getCountDownLatch(String name) {
        return distributedLocker.getCountDownLatch(name);
    }

    /**
     * 获取信号量
     *
     * @param name
     * @return
     */
    public  RSemaphore getSemaphore(String name) {
        return distributedLocker.getSemaphore(name);
    }
}

5、启动类

package com.example;

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

@SpringBootApplication
public class SpringbootRedissionApplication {

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

}

6、测试

模拟并发测试

package com.example.controller;

import com.example.utils.RedisLockUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * redis分布式锁控制器
 */

@RestController
@RequestMapping("/redisson")
@Slf4j
public class RedissonLockController {

    @Autowired
    private RedisLockUtil redisLockUtil;

    /**
     * 锁测试共享变量
     */
    private Integer lockCount = 10;

    /**
     * 无锁测试共享变量
     */
    private Integer count = 10;

    /**
     * 模拟线程数
     */
    private static int threadNum = 10;

    /**
     * 模拟并发测试加锁和不加锁
     *
     * @return
     */
    @GetMapping("/test")
    public void lock() {
        // 计数器
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < threadNum; i++) {
            MyRunnable myRunnable = new MyRunnable(countDownLatch);
            Thread myThread = new Thread(myRunnable);
            myThread.start();
        }
        // 释放所有线程
        countDownLatch.countDown();
    }

    /**
     * 加锁测试
     */
    private void testLockCount() {
        String lockKey = "lock-test";
        try {
            // 加锁，设置超时时间2s
            redisLockUtil.lock(lockKey, 2, TimeUnit.SECONDS);
            lockCount--;
            log.info("lockCount值：" + lockCount);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            // 释放锁
            redisLockUtil.unlock(lockKey);
        }
    }

    /**
     * 无锁测试
     */
    private void testCount() {
        count--;
        log.info("count值：" + count);
    }


    public class MyRunnable implements Runnable {
        /**
         * 计数器
         */
        final CountDownLatch countDownLatch;

        public MyRunnable(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                // 阻塞当前线程，直到计时器的值为0
                countDownLatch.await();
            } catch (InterruptedException e) {
                log.error(e.getMessage(), e);
            }
            // 无锁操作
            testCount();
            // 加锁操作
            testLockCount();
        }

    }
}

调用接口后打印值：http://localhost:8080/redisson/test

2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-15] c.e.controller.RedissonLockController    : count值：4
2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-14] c.e.controller.RedissonLockController    : count值：5
2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-18] c.e.controller.RedissonLockController    : count值：6
2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-11] c.e.controller.RedissonLockController    : count值：7
2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-16] c.e.controller.RedissonLockController    : count值：1
2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-12] c.e.controller.RedissonLockController    : count值：5
2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-13] c.e.controller.RedissonLockController    : count值：4
2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-19] c.e.controller.RedissonLockController    : count值：2
2022-08-16 19:52:02.956  INFO 13112 --- [      Thread-20] c.e.controller.RedissonLockController    : count值：0
2022-08-16 19:52:02.955  INFO 13112 --- [      Thread-17] c.e.controller.RedissonLockController    : count值：3
2022-08-16 19:52:03.074  INFO 13112 --- [      Thread-11] c.e.controller.RedissonLockController    : lockCount值：9
2022-08-16 19:52:03.100  INFO 13112 --- [      Thread-12] c.e.controller.RedissonLockController    : lockCount值：8
2022-08-16 19:52:03.106  INFO 13112 --- [      Thread-17] c.e.controller.RedissonLockController    : lockCount值：7
2022-08-16 19:52:03.116  INFO 13112 --- [      Thread-13] c.e.controller.RedissonLockController    : lockCount值：6
2022-08-16 19:52:03.139  INFO 13112 --- [      Thread-14] c.e.controller.RedissonLockController    : lockCount值：5
2022-08-16 19:52:03.149  INFO 13112 --- [      Thread-19] c.e.controller.RedissonLockController    : lockCount值：4
2022-08-16 19:52:03.157  INFO 13112 --- [      Thread-16] c.e.controller.RedissonLockController    : lockCount值：3
2022-08-16 19:52:03.163  INFO 13112 --- [      Thread-18] c.e.controller.RedissonLockController    : lockCount值：2
2022-08-16 19:52:03.168  INFO 13112 --- [      Thread-20] c.e.controller.RedissonLockController    : lockCount值：1
2022-08-16 19:52:03.179  INFO 13112 --- [      Thread-15] c.e.controller.RedissonLockController    : lockCount值：0

测试结果：

根据打印结果可以明显看到，未加锁的 count-- 后值是乱序的，而加锁后的结果和我们预期的一样。

由于条件问题没办法测试分布式的并发，只能模拟单服务的这种并发，但是原理是一样，希望对大家有帮助。