本文小编为大家详细介绍“redis实现分布式锁实例分析”，内容详细，步骤清晰，细节处理妥当，希望这篇“redis实现分布式锁实例分析”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。
模拟一个电商系统，服务器分布式部署，系统中有一个用户下订单的接口，用户下订单之前需要获取分布式锁，然后去检查一下库存，确保库存足够了才会给用户下单，然后释放锁。
由于系统有一定的并发，所以会预先将商品的库存保存在redis中，用户下单的时候会更新redis的库存。
-- ----------------------------
-- 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');<?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>
# 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
/**
* @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);
}
}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;
}
}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;
}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);
}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);
}
}
}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;
}
}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;
}
}把SpringBoot工程启动两台服务器，端口分别为8888、9999。启动8888端口后，修改配置文件端口为9999，启动另一个应用
然后使用jmeter进行并发测试，开两个线程组，分别代表两台服务器下单，1秒钟起20个线程，循环25次，总共下单1000次。
查看控制台输出：
注意：该锁在并发量太高的情况下，会出现一部分失败率。手动写的程序，因为操作的非原子性，会存在并发问题。该锁的实现只是为了演示原理，并不适用于生产。
jmeter聚合报告
读到这里，这篇“redis实现分布式锁实例分析”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
