Redis缓存优化、本地锁及分布式锁的入门使用思想实现

Redis缓存优化、本地锁及分布式锁的入门使用思想实现

1、依赖启动器引入

<!-- redis -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- spring2.X集成redis所需common-pool2-->
<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-pool2</artifactId>
   <version>2.6.0</version>
</dependency>

2、操作Redis序列化配置类

万能是配置类，只要使用redis作为缓存的都可以实体下面的配置类

序列化与默认序列化的区别

数据结构	KEY或VALUE序列化设置	具体的序列化类	序列化前	序列化后
Key / Value	ValueSerializer	StringRedisSerializer	test_value111	test_value111
	ValueSerializer	Jackson2JsonRedisSerializer	test_value111	“test_value111”
	ValueSerializer	JdkSerializationRedisSerializer	test_value111	???

package com.zcl.gmall.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author: xiao_zhong
 * @description: Redis配置类
 * @date: 2022/11/16 9:55
 * @param: null
 * @return:
 */
@Configuration
@EnableCaching
public class RedisConfig {
    
    
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    
    
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        //  设置redis的连接池工厂。
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //  设置序列化的(在查看redis数据的时候不会出现乱码)。
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        //  将Redis 中 string ，hash 数据类型，自动序列化！
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        //  设置数据类型是Hash 的 序列化！
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

3、配置Redis的连接信息

spring: 
	redis:
    host: xxx.xxx.xxx.xxx
    port: 6379
    database: 0
    timeout: 1800000
    password:
    lettuce:
      pool:
        max-active: 20 #最大连接数
        max-wait: -1    #最大阻塞等待时间(负数表示没限制)
        max-idle: 5    #最大空闲
        min-idle: 0     #最小空闲

4、定义操作Redis的Key常量

redis的key是不能进行重复的，否则数据会覆盖，同时也不会通过硬编码的形式写死在储存的key位置上，这样不便于后面的维护，一般都是通过定义枚举、接口、静态类进行统一的描述key的使用，这样在后面需要进行key重新定义的时候就可以一处修改处处生效

package com.zcl.gmall.common.constant;

public class RedisConst {
    
    
    /**单位：秒 尝试获取锁的最大等待时间*/
    public static final long SKULOCK_EXPIRE_PX1 = 1;
    /**单位：秒 锁的持有时间*/
    public static final long SKULOCK_EXPIRE_PX2 = 1;
    /**锁的后缀*/
    public static final String SKULOCK_SUFFIX = ":lock";
}

5、本地锁和分布式锁的基本思路流程图

5.1、本地锁

5.2、分布式锁

6、本地锁实现案例

6.1、定义Redis中的初始化数据

6.2、控制器编写

package com.zcl.gmall.product.controller;

import com.zcl.gmall.product.service.TestService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @Author: zcl
 * @description: 测试Redis分布式锁控制器
 * @DATE: 2022/12/8 10:21 星期四
 * @Version 1.0
 */
@RestController
@RequestMapping("/admin/product/test")
public class TestRedisController {
    
    

    /**
     * 描述：注入业务接口
     */
    @Resource
    private TestService testService;

    /**
     * @author: mac
     * @description: 测试本地锁
     * @date: 2022/12/8 10:23
     * @param:
     * @return: java.lang.String
     */
    @GetMapping("/testLock")
    public String testLock() {
    
    
        return testService.testLock();
    }
}

6.3、业务接口实现

package com.zcl.gmall.product.service.impl;

import com.zcl.gmall.product.service.TestService;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;

/**
 * @Author: zcl
 * @description: 测试Redis测试接口实现类
 * @DATE: 2022/12/8 10:25 星期四
 * @Version 1.0
 */
@Service
public class TestServiceImpl implements TestService {
    
    

    /**
     * 描述：注入redis的操作模板接口
     */
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * @author: mac
     * @description: 测试本地锁的局限性
     * @date: 2022/12/8 10:26
     * @param:
     * @return: java.lang.String
     */
    @Override
    public String testLock() {
    
    
        /**
         * 实现步骤：
         * 1、从redis中获取数据
         * 2、对num数据进行+1操作
         * 3、设置新的num到redis中
         */

        String numValue = stringRedisTemplate.opsForValue().get("num");
        if (StringUtils.isEmpty(numValue)) {
    
    
            return "0";
        }
        Integer num = Integer.parseInt(numValue);
        stringRedisTemplate.opsForValue().set("num", String.valueOf(++num));
        return String.valueOf(num);
    }
}

6.4、访问测试

1、单点访问

不是高并发访问，访问一次处理一次，再次查看Redis中储存的num是否也等于12
注意：这里是点击了12次所以返回的也就是12

2、ab高并发测试

mac是自带ab压测，但是默认的有并发数限制需要重新安装

3、压测结果：

当没有个业务接口加锁的时候，修改的num数据是不到5000的，也就是不能保证数据的唯一性存在很大的问题
如何加锁，只需要在业务接口实现类上添加synchronized关键字进行修饰即可添加上本地锁，再次通过上面的压测命令就可以得到redis中的num=5000，保证了数据的唯一性

4、集群测试本地锁思路

1. 复制多个服务修改启动端口号进行启动
2. 服务注册到nacos
3. 创建网关服务并设置对应的请求断言，网关默认是80直接访问会负载均衡到测试服务
4. 再次通过ab压测查看最后的redis中的num数据

分布式本地锁的局限性：
1、synchronized本地锁由jvm进行管理
2、搭建了集群模式就是三个不同的jvm管理synchronized本地锁
3、本地锁只能锁住同一工程内的资源，在分布式系统里面都存在局限性

7、Redis分布式锁案例

先完成三个微服务的穿件以及网关模块的搭建，能够正常访问到请求再进行下面的操作

为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：

- 互斥性。在任意时刻，只有一个客户端能持有锁。

- 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。

- 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

- 加锁和解锁必须具有原子性

7.1、setnx占坑思想实现

1、创建控制器

/**
* @author: mac
* @description: redis的setnx占坑思想
* @date: 2022/12/8 14:46
* @param:
* @return: java.lang.String
*/
@GetMapping("/testLock2")
public String testLock2() {
    
    
    return testService.testLock2();
}

2、业务接口实现

下面的业务接口实现了较为完善的redis分布式锁处理，通过使用uuId和lua脚本保证了删除锁的原子性

/**
 * @author: mac
 * @description: redis占坑思想实现
 * @date: 2022/12/8 14:47
 * @param:
 * @return: java.lang.String
 */
@Override
public String testLock2() {
    
    
    String uuId = UUID.randomUUID().toString().replaceAll("-", "");
    /**
     * 实现步骤：
     * 1、获取锁
     * 2、判断锁
     * 3、释放锁
     */
    Integer num = null;
    // 设置过期时间，注意【过期时间需要根据业务的执行速度最终计算获得否则就会乱释放锁】
    // 场景：7秒执行完的业务所的过期时间设置3秒，往后想想就知道锁会被释放错
    Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuId, 3, TimeUnit.SECONDS);
    if (lock) {
    
    
        String numValue = stringRedisTemplate.opsForValue().get("num");
        if (StringUtils.isEmpty(numValue)) {
    
    
            return "0";
        }
        num = Integer.parseInt(numValue);
        stringRedisTemplate.opsForValue().set("num", String.valueOf(++num));

        // 定义lua脚本
        final String lu = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
                "then\n" +
                "    return redis.call(\"del\",KEYS[1])\n" +
                "else\n" +
                "    return 0\n" +
                "end";

        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        // 设置lua脚本
        redisScript.setScriptText(lu);
        // 设置返回值类型
        redisScript.setResultType(Long.class);
        // 通过lua脚本进行删除，只要当key的值域uuId的值一致时才会进行删除(反之误删除，lua保证原子性)
        stringRedisTemplate.execute(redisScript, Arrays.asList("lock"), uuId);
    } else {
    
    
        try {
    
    
            // 没有获取到锁就自旋
            Thread.sleep(100);
            testLock2();
        } catch (InterruptedException e) {
    
    
            throw new RuntimeException(e);
        }
    }
    return String.valueOf(num);
}

3、ab测试

重新启动三个集群微服务，通过ab进行压测网关然后负载均衡到各个微服务端口集合完成测试，当查询查看redis中的num=5000时，说明上面的setnx占坑实现的分布式锁是可以正常的使用的

7.2、redisson解决分布式锁

官网文档地址：https://github.com/redisson/redisson/wiki/8.-distributed-locks-and-synchronizers/#81-lock

加锁和释放锁的方法

RLock lock = redisson.getLock("myLock");

// traditional lock method
lock.lock();

// or acquire lock and automatically unlock it after 10 seconds
lock.lock(10, TimeUnit.SECONDS);

// or wait for lock aquisition up to 100 seconds 
// and automatically unlock it after 10 seconds
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
    
    
   try {
    
    
     ...
   } finally {
    
    
       lock.unlock();
   }
}

1、引入依赖

<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.18.0</version>
</dependency>  

2、搭建配置类

package com.zcl.gmall.common.config;

import lombok.Data;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

/**
 * @author: xiao_zhong
 * @description: redisson配置信息
 * @date: 2022/11/16 19:05
 * @param: null
 * @return:
 */
@Data
@Configuration
@ConfigurationProperties("spring.redis")
public class RedissonConfig {
    
    
    /**连接主机IP*/
    private String host;
    /**地址*/
    private String addresses;
    /**连接密码*/
    private String password;
    /**连接端口号*/
    private String port;
    /**连接超时时间*/
    private int timeout = 3000;
    /**连接池大小*/
    private int connectionPoolSize = 64;
    /**最小空闲大小*/
    private int connectionMinimumIdleSize=10;
    /**ping连接间隔*/
    private int pingConnectionInterval = 60000;
    private static String ADDRESS_PREFIX = "redis://";

    /**
     * @author: xiao_zhong
     * @description: 自动装配
     * @date: 2022/11/16 19:05
     * @param:
     * @return: org.redisson.api.RedissonClient
     */
    @Bean
    RedissonClient redissonSingle() {
    
    
        Config config = new Config();
        if(StringUtils.isEmpty(host)){
    
    
            throw new RuntimeException("host is  empty");
        }
        SingleServerConfig serverConfig = config.useSingleServer()
                // redis://127.0.0.1:7181
                .setAddress(ADDRESS_PREFIX + this.host + ":" + port)
                .setTimeout(this.timeout)
                .setPingConnectionInterval(pingConnectionInterval)
                .setConnectionPoolSize(this.connectionPoolSize)
                .setConnectionMinimumIdleSize(this.connectionMinimumIdleSize)
                ;
        if(!StringUtils.isEmpty(this.password)) {
    
    
            serverConfig.setPassword(this.password);
        }
        return Redisson.create(config);
    }
}

3、创建控制器

    /**
     * @author: mac
     * @description: redisson解决分布式锁
     * @date: 2022/12/8 18:18
     * @param:
     * @return: java.lang.String
     */
    @GetMapping("testLock3")
    public String testLock3() {
    
    
        return testService.testLock3();
    }

4、业务接口实现【可重入锁】

/**
 * @author: xiao_zhong
 * @description: redisson测试分布式锁
 * @date: 2022/11/16 19:10
 * @param:
 * @return: void
 */
@Override
public void testLock3() {
    
    
    // 1、定义缓存的key
    String skuKey = "sku:" + 1317 + "info";
    // 2、获取锁
    RLock lock = redissonClient.getLock(skuKey);
    try {
    
    
        // 3、加锁一
        // lock.lock();
        // 加锁二：设置超时时间
        // 加锁以后10秒钟自动解锁,无需调用unlock方法手动解锁
        // lock.lock(7,TimeUnit.SECONDS);
        // 加锁三：尝试加锁，最多等待100秒，上锁以后10秒自动解锁
        boolean tryLock = lock.tryLock(100, 10, TimeUnit.SECONDS);
        if(tryLock){
    
    
            // 4、查询redis中的num数据++
            String num = stringRedisTemplate.opsForValue().get("num");
            if(StringUtils.isBlank(num)){
    
    
                return;
            }
            int val = Integer.parseInt(num);
            // 5、设置数据添加
            stringRedisTemplate.opsForValue().set("num",String.valueOf(++val));
        }else {
    
    
            Thread.sleep(50);
            testLock3();
        }

    } catch (InterruptedException e) {
    
    
        throw new RuntimeException(e);
    }finally {
    
    
        // 6、释放锁
        lock.unlock();
    }
}

7.3、redisson（ReadWriteLock）读写锁操作

1、创建控制器

/**
 * 注入测试业务接口
 */
@Autowired
private TestService testService;

/**
 * @author: xiao_zhong
 * @description: 写锁测试
 * @date: 2022/11/16 20:04
 * @param:
 * @return: java.lang.String
 */
@GetMapping("/write")
public String write(){
    
    
    return testService.writeLock4();
}

/**
 * @author: xiao_zhong
 * @description: 读锁测试
 * @date: 2022/11/16 20:04
 * @param:
 * @return: java.lang.String
 */
@GetMapping("/read")
public String read(){
    
    
    return testService.readLock4();
}

2、业务接口实现类编写

 	/**
     * @author: mac
     * @description: 写锁测试
     * @date: 2022/12/8 19:06
     * @param:
     * @return: java.lang.String
     */
    @Override
    public String writeLock4() {
    
    
        // 1、初始化获取锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWriteLock");
        // 2、获取读锁
        RLock rLock = readWriteLock.writeLock();
        // 3、写锁
        rLock.lock(10, TimeUnit.SECONDS);
        // 4、写入redis
        stringRedisTemplate.opsForValue().set("msg", String.valueOf(System.currentTimeMillis()));
        // 5、释放锁
        // rLock.unlock();
        return "写入一条数据到redis中";
    }

    /**
     * @author: mac
     * @description: 读锁测试
     * @date: 2022/12/8 19:06
     * @param:
     * @return: java.lang.String
     */
    @Override
    public String readLock4() {
    
    
        // 1、初始化获取锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWriteLock");
        // 2、获取读锁
        RLock rLock = readWriteLock.readLock();
        // 3、写锁
        rLock.lock(10, TimeUnit.SECONDS);
        // 4、写入redis
        String msg = stringRedisTemplate.opsForValue().get("msg");
        // 5、释放锁
        // rLock.unlock();
        return msg;
    }

3、读写锁测试互斥性

同时将【读和写】的业务代码统一修改加锁的时间为rLock.lock(10,TimeUnit.SECONDS);,并且将释放锁的代码rLock.unlock();注释掉

说明：互斥说明，就是在请求的时候需要等待上面所设置的10秒过期时间才能真正访问到数据，否则浏览器一直在转圈等待

操作1	操作2	是否互斥	等待时间
读	读	不互斥	无
写	读	互斥	10s
读	写	互斥	10s
写	写	互斥	10s

解决：只要涉及到写，就必须互斥

说明：如果上面的知识点有不妥或描述有误的地方请留言或私信交流更正