redis实现分布式锁实例详解-eolink官网

redis实现分布式锁实例详解

目录1、业务场景引入2、基础环境准备2.1.准备库存数据库2.2.创建SpringBoot工程，pom.xml中导入依赖，请注意版本。2.3.application.properties配置文件2.4.SpringBoot启动类2.5.添加Redis的配置类2.6.pojo层2.7.mapper层2.8.SpringBoot监听Web启动事件，加载商品数据到Redis中3、Redis实现分布式锁3.1分布式锁的实现类3.2分布式锁的业务代码4、分布式锁测试总结

1、业务场景引入

模拟一个电商系统，服务器分布式部署，系统中有一个用户下订单的接口，用户下订单之前需要获取分布式锁，然后去检查一下库存，确保库存足够了才会给用户下单，然后释放锁。

由于系统有一定的并发，所以会预先将商品的库存保存在redis中，用户下单的时候会更新redis的库存。

2、基础环境准备

2.1.准备库存数据库

-- ----------------------------

-- Table structure for t_goods

-- ----------------------------

DROP TABLE IF EXISTS `t_goods`;

CREATE TABLE `t_goods` (

`goods_id` int(11) NOT NULL AUTO_INCREMENT,

`goods_name` varchar(255) DEFAULT NULL,

`goods_price` decimal(10,2) DEFAULT NULL,

`goods_stock` int(11) DEFAULT NULL,

`goods_img` varchar(255) DEFAULT NULL,

PRIMARY KEY (`goods_id`)

) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------

-- Records of t_goods

-- ----------------------------

INSERT INTO `t_goods` VALUES ('1', 'iphone8', '6999.00', '5000', 'img/iphone.jpg');

INSERT INTO `t_goods` VALUES ('2', '小米9', '3000.00', '5000', 'img/rongyao.jpg');

INSERT INTO `t_goods` VALUES ('3', '华为p30', '4000.00', '5000', 'img/huawei.jpg');

2.2.创建SpringBoot工程，pom.xml中导入依赖，请注意版本。

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

4.0.0

com.springlock.task

springlock.task

1.0-SNAPSHOT

org.springframework.boot

spring-boot-starter-parent

2.1.3.RELEASE

org.springframework.boot

spring-boot-starter-web

org.mybatis.spring.boot

mybatis-spring-boot-starter

2.0.0

com.alibaba

druid-spring-boot-starter

1.1.10

mysql

mysql-connector-java

5.1.28

org.springframework.boot

spring-boot-starter-test

test

org.projectlombok

lombok

org.springframework.boot

spring-boot-starter-data-redis

redis.clients

jedis

2.9.0

src/main/java

**/*.xml

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

4.0.0

com.springlock.task

springlock.task

1.0-SNAPSHOT

org.springframework.boot

spring-boot-starter-parent

2.1.3.RELEASE

org.springframework.boot

spring-boot-starter-web

org.mybatis.spring.boot

mybatis-spring-boot-starter

2.0.0

com.alibaba

druid-spring-boot-starter

1.1.10

mysql

mysql-connector-java

5.1.28

org.springframework.boot

spring-boot-starter-test

test

org.projectlombok

lombok

org.springframework.boot

spring-boot-starter-data-redis

redis.clients

jedis

2.9.0

src/main/java

**/*.xml

2.3.application.properties配置文件

# SpringBoot有默认的配置，我们可以覆盖默认的配置

server.port=8888

# 配置数据的连接信息

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/redislock?useUnicode=true&characterEncoding=utf-8

spring.datasource.username=root

spring.datasource.password=root

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# reids配置

spring.redis.jedis.pool.max-idle=10

spring.redis.jedis.pool.min-idle=5

spring.redis.jedis.pool.maxTotal=15

spring.redis.hostName=192.168.3.28

spring.redis.port=6379

2.4.SpringBoot启动类

/**

* @author swadian

* @date 2022/3/4

* @Version 1.0

* @describetion

@SpringBootApplication

public class SpringLockApplicationApp {

public static void main(String[] args) {

SpringApplication.run(SpringLockApplicationApp.class,args);

}

2.5.添加Redis的配置类

import com.fasterxml.jackson.annotation.jsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import lombok.extern.slf4j.Slf4j;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.JedisPoolConfig;

@Slf4j

@Configuration

public class RedisConfig {

/**

* 1.创建JedisPoolConfig对象。在该对象中完成一些链接池配置

* @ConfigurationProperties:会将前缀相同的内容创建一个实体。

@Bean

@ConfigurationProperties(prefix="spring.redis.jedis.pool")

public JedisPoolConfig jedisPoolConfig(){

JedisPoolConfig config = new JedisPoolConfig();

log.info("JedisPool默认参数-最大空闲数:{},最小空闲数:{},最大链接数:{}",config.getMaxIdle(),config.getMinIdle(),config.getMaxTotal());

return config;

}

/**

* 2.创建JedisConnectionFactory：配置redis链接信息

@Bean

@ConfigurationProperties(prefix="spring.redis")

public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig config){

log.info("redis初始化配置-最大空闲数:{},最小空闲数:{},最大链接数:{}",config.getMaxIdle(),config.getMinIdle(),config.getMaxTotal());

JedisConnectionFactory factory = new JedisConnectionFactory();

//关联链接池的配置对象

factory.setPoolConfig(config);

return factory;

}

/**

* 3.创建RedisTemplate:用于执行Redis操作的方法

@Bean

public RedisTemplate redisTemplate(JedisConnectionFactory factory){

RedisTemplate template = new RedisTemplate<>();

//关联

template.setConnectionFactory(factory);

//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）

Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

ObjectMapper om = new ObjectMapper();

//指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public

om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

//指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常

om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

jacksonSeial.setObjectMapper(om);

//使用StringRedisSerializer来序列化和反序列化redis的key值

template.setKeySerializer(new StringRedisSerializer());

//值采用json序列化

template.setValueSerializer(jacksonSeial);

//设置hash key 和value序列化模式

template.setHashKeySerializer(new StringRedisSerializer());

template.setHashValueSerializer(jacksonSeial);

return template;

}

2.6.pojo层

import lombok.AllArgsConstructor;

import lombok.Data;

import lombok.NoArgsConstructor;

@Data

@NoArgsConstructor

@AllArgsConstructor

public class Goods {

private String goods_id;

private String goods_name;

private Double goods_price;

private Long goods_stock;

private String goods_img;

}

2.7.mapper层

import com.springlock.pojo.Goods;

import org.apache.ibatis.annotations.Mapper;

import org.apache.ibatis.annotations.Select;

import org.apache.ibatis.annotations.Update;

import java.util.List;

@Mapper

public interface GoodsMapper {

/**

* 01-更新商品库存

* @param goods

* @return

@Update("update t_goods set goods_stock=#{goods_stock} where goods_id=#{goods_id}")

Integer updateGoodsStock(Goods goods);

/**

* 02-加载商品信息

* @return

@Select("select * from t_goods")

List findGoods();

/**

* 03-根据ID查询

* @param goodsId

* @return

@Select("select * from t_goods where goods_id=#{goods_id}")

Goods findGoodsById(String goodsId);

}

2.8.SpringBoot监听Web启动事件，加载商品数据到Redis中

import com.springlock.mapper.GoodsMapper;

import com.springlock.pojo.Goods;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.ApplicationListener;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.event.ContextRefreshedEvent;

import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;

import java.util.List;

/**

* @author swadian

* @date 2022/3/4

* @Version 1.0

* @describetion ApplicationListener监听器，项目启动时出发

@Slf4j

@Configuration

public class ApplicationStartListener implements ApplicationListener {

@Resource

GoodsMapper goodsMapper;

@Autowired

private RedisTemplate redisTemplate;

@Override

public void onApplicationEvent(ContextRefreshedEvent event) {

System.out.println("Web项目启动,ApplicationListener监听器触发...");

List goodsList = goodsMapper.findGoods();

for (Goods goods : goodsList) {

redisTemplate.boundHashOps("goods_info").put(goods.getGoods_id(), goods.getGoods_stock());

log.info("缓存商品详情:{}",goods);

}

3、Redis实现分布式锁

3.1 分布式锁的实现类

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

import redis.clients.jedis.Transaction;

import redis.clients.jedis.exceptions.JedisException;

import java.util.List;

import java.util.UUID;

public class DistributedLock {

//redis连接池

private static JedisPool jedisPool;

static {

JedisPoolConfig config = new JedisPoolConfig();

// 设置最大连接数

config.setMaxTotal(200);

// 设置最大空闲数

config.setMaxIdle(8);

// 设置最大等待时间

config.setMaxWaitMillis(1000 * 100);

// 在borrow一个jedis实例时，是否需要验证，若为true，则所有jedis实例均是可用的

config.setTestOnBorrow(true);

jedisPool = new JedisPool(config, "192.168.3.28", 6379, 3000);

}

/**

* 加锁

* @param lockName 锁的key

* @param acquireTimeout 获取锁的超时时间

* @param timeout 锁的超时时间

* @return 锁标识

* Redis Setnx（SET if Not eXists）命令在指定的 key 不存在时，为 key 设置指定的值。

* 设置成功，返回 1 。设置失败，返回 0 。

public String lockWithTimeout(String lockName, long acquireTimeout, long timeout) {

Jedis conn = null;

String retIdentifier = null;

try {

// 获取连接

conn = jedisPool.getResource();

// value值->随机生成一个String

String identifier = UUID.randomUUID().toString();

// key值->即锁名

String lockKey = "lock:" + lockName;

// 超时时间->上锁后超过此时间则自动释放锁毫秒转成->秒

int lockExpire = (int) (timeout / 1000);

// 获取锁的超时时间->超过这个时间则放弃获取锁

long end = System.currentTimeMillis() + acquireTimeout;

while (System.currentTimeMillis() < end) { //在获取锁时间内

if (conn.setnx(lockKey, identifier) == 1) {//设置锁成功

conn.expire(lockKey, lockExpire);

// 返回value值，用于释放锁时间确认

retIdentifier = identifier;

return retIdentifier;

}

// ttl以秒为单位返回 key 的剩余过期时间，返回-1代表key没有设置超时时间，为key设置一个超时时间

if (conn.ttl(lockKey) == -1) {

XnQlcG conn.expire(lockKey, lockExpire);

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

}

} catch (JedisException e) {

e.printStackTrace();

} finally {

if (conn != null) {

conn.close();

}

return retIdentifier;

}

/**

* 释放锁

* @param lockName 锁的key

* @param identifier 释放锁的标识

* @return

public boolean releaseLock(String lockName, String identifier) {

Jedis conn = null;

String lockKey = "lock:" + lockName;

boolean retFlag = false;

try {

conn = jedisPool.getResource();

while (true) {

// 监视lock，准备开始redis事务

conn.watch(lockKey);

// 通过前面返回的value值判断是不是该锁，若是该锁，则删除，释放锁

if (identifier.equals(conn.get(lockKey))) {

Transaction transaction = conn.multi();//开启redis事务

transaction.del(lockKey);

List

if (results == null) {//提交失败

continue;//继续循环

}

retFlag = true;//提交成功

}

conn.unwatch();//解除监控

break;

}

} catch (JedisException e) {

e.printStackTrace();

} finally {

if (conn != null) {

conn.close();

}

return retFlag;

}

3.2 分布式锁的业务代码

service业务逻辑层

public interface SkillService {

Integer seckill(String goodsId,Long goodsStock);

}

service业务逻辑层实现层

import com.springlock.lock.DistributedLock;

import com.springlock.mapper.GoodsMapper;

import com.springlock.pojo.Goods;

import com.springlock.service.SkillService;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Slf4j

@Service

public class SkillServiceImpl implements SkillService {

private final DistributedLock lock = new DistributedLock();

private final static String LOCK_NAME = "goods_stock_resource";

@Resource

GoodsMapper goodsMapper;

@Autowired

private RedisTemplate redisTemplate;

@Override

public Integer seckill(String goodsId, Long goodsQuantity) {

// 加锁，返回锁的value值，供释放锁时候进行判断

String identifier = lock.lockWithTimeout(LOCK_NAME, 5000, 1000);

Integer goods_stock = (Integer) redisTemplate.boundHashOps("goods_info").get(goodsId);

if (goods_stock > 0 && goods_stock >= goodsQuantity) {

//1.查询数据库对象

Goods goods = goodsMapper.findGoodsById(goodsId);

//2.更新数据库中库存数量

goods.setGoods_stock(goods.getGoods_stock() - goodsQuantity);

goodsMapper.updateGoodsStock(goods);

//3.同步Redis中商品库存

redisTemplate.boundHashOps("goods_info").put(goods.getGoods_id(), goods.getGoods_stock());

log.info("商品Id:{},在Redis中剩余库存数量:{}", goodsId, goods.getGoods_stock());

//释放锁

lock.releaseLock(LOCK_NAME, identifier);

return 1;

} else {

log.info("商品Id:{},库存不足！,库存数：{},购买量：{}", goodsId, goods_stock, goodsQuantity);

//释放锁

lock.releaseLock(LOCK_NAME, identifier);

return -1;

}

controller层

import com.springlock.service.SkillService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Scope;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController

@Scope("prototype") //prototype 多实例，singleton单实例

public class SkillController {

@Autowired

SkillService skillService;

@RequestMapping("/skill")

public String skill() {

Integer count = skillService.seckill("1", 1L);

return count > 0 ? "下单成功" + count : "下单失败" + count;

}

4、分布式锁测试

把SpringBoot工程启动两台服务器，端口分别为8888、9999。启动8888端口后，修改配置文件端口为9999，启动另一个应用

然后使用jmeter进行并发测试，开两个线程组，分别代表两台服务器下单，1秒钟起20个线程，循环25次，总共下单1000次。

查看控制台输出：

注意：该锁在并发量太高的情况下，会出现一部分失败率。手动写的程序，因为操作的非原子性，会存在并发问题。该锁的实现只是为了演示原理，并不适用于生产。

jmeter聚合报告

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!

springcloud如何使用Feign后台内部传递MultipartFile

278 2022-08-23

redis实现分布式锁实例详解

基于feign传参MultipartFile问题解决

Feign远程调用Multipartfile参数处理

springcloud如何使用Feign后台内部传递MultipartFile

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！