springboot整合redisson实现分布式锁

1、为什么要用分布式锁？

在一些高并发的场景中，比如秒杀，抢票，抢购这些场景，都存在对核心资源，商品库存的争夺，控制不好，库存数量可能被减少到负数，出现超卖的情况，或者 产生唯一的一个递增ID，由于web应用部署在多个机器上，简单的同步加锁是无法实现的，给数据库加锁的话，对于高并发，1000/s的并发，数据库可能由行锁变成表锁，性能下降会厉害。这个时候就需要用分布式锁了实现分布式锁的方式很多，我们今天就用redis的分布式锁，redisson也是官方比较推荐的。当然我们其实也可以自己用redis的setntx,delete方式自己写一个。

2、分布式锁的实现方式

大概有三种：

1. 基于关系型数据库（基于mysql数据库的分布式锁）
2. 基于缓存（本文讲解了基于redis的redisson实现分布式锁）
3. 基于zookeeper（基于zookeeper实现分布式锁）

大部分网站使用的是基于缓存的，有更好的性能，而缓存一般是以集群方式部署，保证了高可用性。

3、原理

在Redisson中，使用key来作为是否上锁的标志，当通过getLock(String key)方法获得相应的锁之后，这个key即作为一个锁存储到Redis集群中，在接下来如果有其他的线程尝试获取名为key的锁时，便会向集群中进行查询，如果能够查到这个锁并发现相应的value的值不为0，则表示已经有其他线程申请了这个锁同时还没有释放，则当前线程进入阻塞，否则由当前线程获取这个锁并将value值加一，如果是可重入锁的话，则当前线程每获得一个自身线程的锁，就将value的值加一，而每释放一个锁则将value值减一，直到减至0，完全释放这个锁。因为底层是基于分布式的Redis集群，所以Redisson实现了分布式的锁机制。

4、实现

4.1、pom引入

        <!--redisson-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.5.0</version>
        </dependency>

4.2、redisson配置

spring
  redis:
    database: 1 
    host: 127.0.0.1
    port: 6379
    #password: 12345678

redisson:
  address: redis://127.0.0.1:6379
  #password: web2017

4.2、redisson操作锁的工具

package com.example.mybatiesplus.utils;

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

import java.util.concurrent.TimeUnit;

/**
 * @DESCRIPTION redisson操作锁的工具
 * @Author lst
 * @Date 2020-05-22 15:00
 */
@Component
public class RedissonUtil {

    @Autowired
    private RedissonClient redissonClient; // RedissonClient已经由配置类生成，这里自动装配即可

    /**
      * 锁住不设置超时时间(拿不到lock就不罢休，不然线程就一直block)
      * @author lst
      * @date 2020-5-24 16:23
      * @param lockKey
      * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    /**
      * leaseTime为加锁时间，单位为秒
      * @author lst
      * @date 2020-5-24 16:23
      * @param lockKey
      * @param leaseTime
      * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
        return null;
    }

    /**
      * timeout为加锁时间，时间单位由unit确定
      * @author lst
      * @date 2020-5-24 16:24
      * @param lockKey
      * @param unit
      * @param timeout
      * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey, TimeUnit unit, long timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }

    /**
      * 尝试获取锁
      * @author lst
      * @date 2020-5-24 16:24
      * @param lockKey
      * @param unit
      * @param waitTime
      * @param leaseTime
      * @return boolean
     */
    public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
      * 通过lockKey解锁
      * @author lst
      * @date 2020-5-24 16:24
      * @param lockKey
      * @return void
     */
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    /**
      * 直接通过锁解锁
      * @author lst
      * @date 2020-5-24 16:25
      * @param lock
      * @return void
     */
    public void unlock(RLock lock) {
        lock.unlock();
    }
}

4.3、redisson基本配置类

@Configuration
public class RedissonConfig {
	
	@Value("${redisson.address}")
	private String addressUrl;
	
	@Bean
	public RedissonClient getRedisson() throws Exception{
		RedissonClient redisson = null;
		Config config = new Config();
		config.useSingleServer()
			  .setAddress(addressUrl);
		redisson = Redisson.create(config);
		
		System.out.println(redisson.getConfig().toJSON().toString());
		return redisson;
	}
	
	
}

4.3、接下来，写一个测试类

package com.example.mybatiesplus.controller;

import com.example.mybatiesplus.result.BaseResponse;
import com.example.mybatiesplus.result.ResultGenerator;
import com.example.mybatiesplus.utils.RedissonUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
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.TimeUnit;

/**
 * @DESCRIPTION 测试类
 * @Author lst
 * @Date 2020-05-24
 */
@RestController
@RequestMapping("/test")
@Api(value = "TestController", tags = "测试类")
@Slf4j
public class TestController {

    public final static String REDISSON_KEY = "redisson_key";

    @Autowired
    private RedissonUtil redissonUtil;

    /**
      * 通过redisson高并发测试
      * @author lst
      * @date 2020-5-24 16:29
      * @param
      * @return com.example.mybatiesplus.result.BaseResponse
     */
    @GetMapping(value = "/redisson", produces = "application/json; charset=utf-8")
    @ApiOperation(value = "通过redisson高并发测试", notes = "通过redisson高并发测试", code = 200, produces = "application/json")
    public BaseResponse redisson() {
        try{
            log.info("============={} 线程访问开始============",Thread.currentThread().getName());
            //TODO 尝试获取锁，等待3秒，自己获得锁后一直不解锁则5秒后自动解锁
            boolean lock = redissonUtil.tryLock(REDISSON_KEY, TimeUnit.SECONDS, 3L, 5L);
            if (lock) {
                log.info("线程:{}，获取到了锁",Thread.currentThread().getName());
                //TODO 获得锁之后可以进行相应的处理  睡一会
                Thread.sleep(100);
                log.info("======获得锁后进行相应的操作======" + Thread.currentThread().getName());
                //redissonUtil.unlock(REDISSON_KEY);
                log.info("=============================" + Thread.currentThread().getName());
            }
        }catch (Exception e){
            log.info("错误信息：{}",e.toString());
            log.info("线程：{} 获取锁失败",Thread.currentThread().getName());
        }
        return ResultGenerator.genSuccessResult();
    }
}

4.4、使用jmeter测试

第一步：创建线程组

第二步：添加http请求，设置并发数（先测试100）

第二步：添加接口信息

4.5、测试数据

在redissonUtil.unlock(REDISSON_KEY);锁未释放的测试下，可能看到后台日志只有线程26获取到了锁。

将redissonUtil.unlock(REDISSON_KEY);释放开在测试，只要某个抢到锁的线程执行完毕并且释放了锁资源，其他的线程很快就会获取到锁。