redis实现分布式锁实例分析

本文小编为大家详细介绍“redis实现分布式锁实例分析”，内容详细，步骤清晰，细节处理妥当，希望这篇“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>**@SpringBootApplicationpublic 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@Configurationpublic class RedisConfig {        @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;    }        @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;    }        @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@AllArgsConstructorpublic 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;@Mapperpublic interface GoodsMapper {        @Update("update t_goods set goods_stock=#{goods_stock} where goods_id=#{goods_id}")    Integer updateGoodsStock(Goods goods);        @Select("select * from t_goods")    List<Goods> findGoods();        @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;@Slf4j@Configurationpublic 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);    }        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;    }        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@Servicepublic 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聚合报告

读到这里，这篇“redis实现分布式锁实例分析”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注编程网精选频道。