redis实现分布式锁实例详解
作者：swadian2008
这篇文章主要为大家详细介绍了redis实现分布式锁实例，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助
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中导入依赖，请注意版本。
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.springlock.task</groupId>
<artifactId>springlock.task</artifactId>
<version>1.0-SNAPSHOT</version>
<!--导入SpringBoot的父工程 把系统中的版本号做了一些定义！ -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.3.RELEASE</version>
</parent>
<dependencies>
<!--导入SpringBoot的Web场景启动器 Web相关的包导入！-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--导入MyBatis的场景启动器-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.28</version>
</dependency>
<!--SpringBoot单元测试-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--导入Lombok依赖-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--Spring Data Redis 的启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
</dependencies>
<build>
<!--编译的时候同时也把包下面的xml同时编译进去-->
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
</resource>
</resources>
</build>
</project>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<String,Object> redisTemplate(JedisConnectionFactory factory){
RedisTemplate<String, Object> 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<Goods> 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<ContextRefreshedEvent> {
@Resource
GoodsMapper goodsMapper;
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
System.out.println("Web项目启动,ApplicationListener监听器触发...");
List<Goods> 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) {
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<Object> results = transaction.exec();//提交redis事务
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<String, Object> 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聚合报告
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容!