Redis分布式锁详解
2024-05-16 17:37:07
Redis分布式锁详解
- 1. 分布式所概述
- 1.1 分布式锁
- 2. 缓存数据库Redis
- 2.1 redis简介
- 2.2 Springboot整合Redis两种方式
- 3. 实现验证
- 3.1 环境准备
- 3.2 项目概述
- 3.3 环境准备
- 3.4 实现验证
- 3.4.1 pom.xml
- 3.4.2 application.properties
- 3.4.3 RedisApplication
- 3.4.4 RedisConfig
- 3.4.5 RedissonConfig
- 3.4.6 Goods
- 3.4.7 Response
- 3.4.8 RedisLock
- 3.4.9 RedissonLock
- 3.4.10 RedisUtil
- 3.4.11 ThreadPool
- 3.4.12 RedisController
- 3.4.13 RedissonController
1. 分布式所概述
1.1 分布式锁
学习分布式锁之前一直在想，在单机环境下，那些多线程相关的技术synchronized，volatile，lock，ReentrantLock，ReentrantReadWriteLock，countdownLatch，CyclicBarrier,Semaphore，在单机环境下通过标识，锁计数器来控制访问临界资源的同步性，如今分布式微服务横行，很少碰到单机环境下的并发，这些究竟还有没有用，看完分布式锁觉着也说得通吧，首先技术的演进迭代也不是一蹴而就的，没有单机的演进哪来的分布式微服务，其次思想原理都是相同的，尤其是这次单机版锁与分布式锁，只不过一个是在同一jvm下实现的，一个放到了第三方实现的，底层实现都是一样的。
这是之前写的单机版的并发编程，Java JUC并发编程详解：
https://blog.csdn.net/m0_37583655/article/details/119831421
作为新时代的农民工，希望跟大家一起开心的造轮子，不足之处，敬请指点。
2. 缓存数据库Redis
2.1 redis简介
Redis是基于内存的，Key-Value形式的非关系型数据库。
这是之前写的redis相关技术，
https://blog.csdn.net/m0_37583655/article/details/118696330
2.2 Springboot整合Redis两种方式
首先我们要知道，Springboot整合Redis有两种方式，分别是Jedis和RedisTemplate，这两者有何区别？
Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。其实在Springboot的官网上我们也能看到，官方现在推荐的是SpringDataRedis形式，相对于Jedis来说可以方便地更换Redis的Java客户端，其比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。
3. 实现验证
上文概念梳理完毕，开始我们的造轮子之路！！！
3.1 环境准备
就不废话了，这是下载安装教程，超详细。
https://www.redis.com.cn/redis-installation.html
3.2 项目概述
项目验证了通过RedisTemplate实现缓存的操作以及redis实现的分布式锁的几种方案，以及通过Redisson实现的几种分布式锁操作。
3.3 环境准备
jdk：1.8
Redis-x64-3.0.504
springboot：2.5.4
spring-boot-starter-data-redis：2.5.4
redisson：3.6.1
3.4 实现验证
3.4.1 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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.5.4</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.zrj</groupId><artifactId>redis</artifactId><version>0.0.1-SNAPSHOT</version><name>redis</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><!-- springboot整合redis --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!-- redisson --><dependency><groupId>org.redisson</groupId><artifactId>redisson</artifactId><version>3.16.1</version></dependency><!--常用工具--><dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>30.1.1-jre</version></dependency><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.6.3</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.72</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>3.4.2 application.properties
# redis配置
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接超时时间（毫秒）
spring.redis.timeout=10000ms#连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1ms
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=03.4.3 RedisApplication
package com.zrj.redis;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;/*** Redis** @author zrj* @since 2021/8/28*/
@SpringBootApplication
public class RedisApplication {public static void main(String[] args) {SpringApplication.run(RedisApplication.class, args);}}3.4.4 RedisConfig
package com.zrj.redis.config;import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
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.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;/*** redis配置** @author zrj* @since 2021/8/27**/
@Configuration
public class RedisConfig {@Bean@ConditionalOnMissingBean(name = "redisTemplate")public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);ObjectMapper om = new ObjectMapper();// 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和publicom.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);// 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jackson2JsonRedisSerializer.setObjectMapper(om);// 配置RedisTemplateRedisTemplate<String, Object> template = new RedisTemplate<>();// 配置连接工厂template.setConnectionFactory(redisConnectionFactory);// key采用序列化方式template.setKeySerializer(jackson2JsonRedisSerializer);// value序列化方式采用jacksontemplate.setValueSerializer(jackson2JsonRedisSerializer);// hash的key也采用的序列化方式template.setHashKeySerializer(jackson2JsonRedisSerializer);// hash的value序列化方式采用jacksontemplate.setHashValueSerializer(jackson2JsonRedisSerializer);template.afterPropertiesSet();return template;}@Bean@ConditionalOnMissingBean(StringRedisTemplate.class)public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {StringRedisTemplate template = new StringRedisTemplate();template.setConnectionFactory(redisConnectionFactory);return template;}
}3.4.5 RedissonConfig
package com.zrj.redis.config;import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.redisson.config.Config;import java.io.IOException;/*** Redisson配置** @author zrj* @since 2021/8/27**/
@Configuration
public class RedissonConfig {/*** RedissonClient** @return* @throws IOException*/@Bean(destroyMethod = "shutdown") // 服务停止后调用 shutdown 方法。public RedissonClient redisson() throws IOException {// 1.创建配置Config config = new Config();// 集群模式// config.useClusterServers().addNodeAddress("127.0.0.1:7004", "127.0.0.1:7001");// 2.根据 Config 创建出 RedissonClient 示例。config.useSingleServer().setAddress("redis://127.0.0.1:6379");return Redisson.create(config);}
}3.4.6 Goods
package com.zrj.redis.entity;import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;import java.io.Serializable;/*** @author zrj* @since 2021/8/27**/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Goods implements Serializable {private static final long serialVersionUID = -2063354304693750063L;private String name;private double price;private String brand;private String Category;
}3.4.7 Response
package com.zrj.redis.entity;import java.io.Serializable;/*** 结果集** @author Jerry* @since 2021/8/7**/
final public class Response<T extends Serializable> implements Serializable {private static final long serialVersionUID = 1L;private boolean success = true;private String code;private String message;private T data;public Response() {super();}public Response(String code, String message) {this(true, code, message);}public Response(boolean success, String code, String message) {this(success, code, message, null, null);}public Response(boolean success, String code, String message, T data) {this(success, code, message, data, null);}public Response(boolean success, String code, String message, T data, Throwable cause) {this.success = success;this.code = code;this.message = message;this.data = data;}public static <T extends Serializable> Response<T> success(String code, String message, T data) {Response rest = new Response();rest.setCode(code);rest.setMessage(message);rest.setData(data);rest.setSuccess(true);return rest;}public static <T extends Serializable> Response<T> success(String message, T data) {Response rest = new Response();rest.setCode("200");rest.setMessage(message);rest.setData(data);rest.setSuccess(true);return rest;}public static <T extends Serializable> Response<T> success(T data) {Response rest = new Response();rest.setCode("200");rest.setMessage("success");rest.setData(data);rest.setSuccess(true);return rest;}public static <T extends Serializable> Response<T> fail(String code, String message) {Response<T> rest = new Response<T>();rest.setCode(code);rest.setMessage(message);rest.setSuccess(false);return rest;}public boolean isSuccess() {return success;}public void setSuccess(boolean success) {this.success = success;}public String getCode() {return code;}public void setCode(String code) {this.code = code;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}public T getData() {return data;}public void setData(T data) {this.data = data;}
}
3.4.8 RedisLock
package com.zrj.redis.utils;import cn.hutool.core.lang.UUID;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;import javax.annotation.Resource;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;/*** redis分布式锁** @author zrj* @since 2021/8/27**/
@Slf4j
public class RedisLock {@Resourceprivate StringRedisTemplate redisTemplate;/*** 青铜方案* 执行流程：抢锁成功，执行业务，释放锁* 问题：死锁问题*/@SneakyThrowspublic void redisLockRronze() {// 1.先抢占锁Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "123");if (lock) {// 2.抢占成功，执行业务log.info("[青铜方案]抢占成功，执行业务");Thread.sleep(1000);// 3.解锁redisTemplate.delete("lock");return;} else {// 4.休眠一段时间Thread.sleep(1000);// 5.抢占失败，等待锁释放return;}}/*** 白银方案* 设置超时时间，超时释放锁，避免死锁* 因为占锁和设置过期时间是分两步执行的，所以如果在这两步之间发生了异常，则锁的过期时间根本就没有设置成功。*/@SneakyThrowspublic void redisLockSilver() {// 1.先抢占锁Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "123");if (lock) {// 2.在 10s 以后，自动清理 lockredisTemplate.expire("lock", 10, TimeUnit.SECONDS);// 3.抢占成功，执行业务log.info("[白银方案]抢占成功，执行业务");Thread.sleep(1000);// 4.解锁redisTemplate.delete("lock");return;}}/*** 黄金方案* 将两步放在一步中执行：占锁+设置锁过期时间。*/@SneakyThrowspublic void redisLockGold() {// 1.先抢占锁Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "123", 10, TimeUnit.SECONDS);if (lock) {// 2.在 10s 以后，自动清理 lockredisTemplate.expire("lock", 10, TimeUnit.SECONDS);// 3.抢占成功，执行业务log.info("[黄金方案]抢占成功，执行业务");Thread.sleep(1000);// 4.解锁redisTemplate.delete("lock");return;}}/*** 铂金方案*/@SneakyThrowspublic void redisLockPlatinum() {// 1.生成唯一 idString uuid = UUID.randomUUID().toString();// 2. 抢占锁Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 10, TimeUnit.SECONDS);if (lock) {System.out.println("抢占成功：" + uuid);// 3.抢占成功，执行业务log.info("[铂金方案]抢占成功，执行业务");Thread.sleep(1000);// 4.获取当前锁的值String lockValue = redisTemplate.opsForValue().get("lock");// 5.如果锁的值和设置的值相等，则清理自己的锁if (uuid.equals(lockValue)) {System.out.println("清理锁：" + lockValue);redisTemplate.delete("lock");}} else {System.out.println("抢占失败，等待锁释放");// 4.休眠一段时间Thread.sleep(1000);// 5.抢占失败，等待锁释放return;}}/*** 钻石方案* 分两步：先定义脚本；用 redisTemplate.execute 方法执行脚本。* 而这段 Redis 脚本是由 Redis 内嵌的 Lua 环境执行的，所以又称作 Lua 脚本。*/@SneakyThrowspublic void redisLockDiamond() {// 1.生成唯一 idString uuid = UUID.randomUUID().toString();// 2. 抢占锁Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 10, TimeUnit.SECONDS);if (lock) {System.out.println("抢占成功：" + uuid);// 3.抢占成功，执行业务log.info("[钻石方案]抢占成功，执行业务");Thread.sleep(1000);// 4.获取当前锁的值String lockValue = redisTemplate.opsForValue().get("lock");// 5.脚本解锁，如果锁的值和设置的值相等，则清理自己的锁String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList("lock"), uuid);} else {System.out.println("抢占失败，等待锁释放");// 4.休眠一段时间Thread.sleep(1000);// 5.抢占失败，等待锁释放return;}}}3.4.9 RedissonLock
package com.zrj.redis.utils;import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RReadWriteLock;
import org.redisson.api.RSemaphore;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;/*** Redisson分布式锁** @author zrj* @since 2021/8/27**/
@Slf4j
@Component
public class RedissonLock {@Resourceprivate RedissonClient redissonClient;/*** 分布式可重入锁* 1.可重入锁是阻塞的吗？* Redisson 的可重入锁（lock）是阻塞其他线程的，需要等待其他线程释放的。* <p>* 2.服务停了，锁会释放吗？* 会的， Redisson 在停机后，占用的锁会自动释放，默认30秒* <p>* 3.看门狗原理** @param* @return java.lang.String*/public String distributedRedissonLock() {// 1.获取锁，只要锁的名字一样，获取到的锁就是同一把锁。RLock lock = redissonClient.getLock("lock");// 2.加锁lock.lock();// 手动设置过期时间，则按照设置时间自动释放，但是执行业务的时间一定要小于锁的自动过期时间，否则就会报错。//lock.lock(15, TimeUnit.SECONDS);try {System.out.println("加锁成功，执行后续代码。线程 ID：" + Thread.currentThread().getId());Thread.sleep(10000);} catch (Exception e) {System.err.println("系统异常：" + e);} finally {// 3.解锁lock.unlock();System.out.println("释放锁成功。线程 ID：" + Thread.currentThread().getId());}return Thread.currentThread().getId() + " lock ok";}/*** 分布式读写锁* 读锁 + 读锁：相当于没加锁，可以并发读。* 读锁 + 写锁：写锁需要等待读锁释放锁。* 写锁 + 写锁：互斥，需要等待对方的锁释放。* 写锁 + 读锁：读锁需要等待写锁释放。* <p>* 获取锁的三种方式：* 1.直接获取读锁或者写锁* 2.设置超时时间，超时自动释放锁* 3.增加尝试获取锁，即自旋次数** @return*/public String distributedReadWriteLock() {RReadWriteLock rwlock = null;try {// 获取指定的可重入读写锁rwlock = redissonClient.getReadWriteLock("RWLock");// 1. 获取读锁，获取写锁rwlock.readLock().lock();rwlock.writeLock().lock();// 2. 10秒钟以后自动解锁，无需调用unlock方法手动解锁rwlock.readLock().lock(10, TimeUnit.SECONDS);rwlock.writeLock().lock(10, TimeUnit.SECONDS);// 3. 尝试加锁，最多等待100秒，上锁以后10秒自动解锁boolean res1 = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);boolean res2 = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);} catch (Exception e) {System.out.println("系统异常：" + e);} finally {// 解锁读锁或者写锁rwlock.readLock().unlock();rwlock.writeLock().unlock();}return Thread.currentThread().getId() + " lock ok";}/*** 分布式信号量** @return*/public String distributedSemaphore() {RSemaphore park = null;try {// 获取信号量（停车场）park = redissonClient.getSemaphore("park");// 获取一个信号（停车位）park.acquire();} catch (Exception e) {System.out.println("系统异常：" + e);} finally {// 释放一个信号（停车位）park.release();}return Thread.currentThread().getId() + " lock ok";}
}3.4.10 RedisUtil
package com.zrj.redis.utils;import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;/*** redis工具类** @author zrj* @since 2021/8/27**/
@Component
public class RedisUtil {@Resourceprivate RedisTemplate<String, Object> redisTemplate;/*** 指定缓存失效时间** @param key* @param time 时间(秒)* @return object*/public boolean expire(String key, long time) {try {if (time > 0) {redisTemplate.expire(key, time, TimeUnit.SECONDS);}return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 根据key 获取过期时间** @param key* @return 时间(秒) 返回0代表为永久有效*/public long getExpire(String key) {return redisTemplate.getExpire(key, TimeUnit.SECONDS);}/*** @param key* @return true 存在 false不存在*/public boolean hasKey(String key) {try {return redisTemplate.hasKey(key);} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 删除键值** @param key 可以传一个值 或多个*/@SuppressWarnings("unchecked")public void del(String... key) {if (key != null && key.length > 0) {if (key.length == 1) {redisTemplate.delete(key[0]);} else {redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));}}}/*** 获取键值** @param key* @return object*/public Object get(String key) {return key == null ? null : redisTemplate.opsForValue().get(key);}/*** 设置键值** @param key* @param value* @return true成功 false失败*/public boolean set(String key, Object value) {try {redisTemplate.opsForValue().set(key, value);return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 设置键值同时指定过期时间** @param key* @param value* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期* @return true成功 false 失败*/public boolean set(String key, Object value, long time) {try {if (time > 0) {redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);} else {set(key, value);}return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 键值递增** @param key* @param delta 要增加几(大于0)* @return long*/public long incr(String key, long delta) {if (delta < 0) {throw new RuntimeException("递增因子必须大于0");}return redisTemplate.opsForValue().increment(key, delta);}/*** 键值递减** @param key* @param delta 要减少几(小于0)* @return long*/public long decr(String key, long delta) {if (delta < 0) {throw new RuntimeException("递减因子必须大于0");}return redisTemplate.opsForValue().increment(key, -delta);}/*** 获取HashGet** @param key* @param item* @return Object*/public Object hget(String key, String item) {return redisTemplate.opsForHash().get(key, item);}/*** 设置HashGet** @param key* @return Map*/public Map<Object, Object> hmget(String key) {return redisTemplate.opsForHash().entries(key);}/*** 设置多个HashGet** @param key* @param map* @return boolean*/public boolean hmset(String key, Map<String, Object> map) {try {redisTemplate.opsForHash().putAll(key, map);return true;} catch (Exception e) {System.err.println("系统异常：" + e);return false;}}/*** 设置多个HashGet时指定过期时间** @param key* @param map* @param time 时间(秒)* @return boolean*/public boolean hmset(String key, Map<String, Object> map, long time) {try {redisTemplate.opsForHash().putAll(key, map);if (time > 0) {expire(key, time);}return true;} catch (Exception e) {System.err.println("系统异常：" + e);return false;}}/*** 向一张hash表中放入数据,如果不存在将创建** @param key* @param item* @param value* @return true 成功 false失败*/public boolean hset(String key, String item, Object value) {try {redisTemplate.opsForHash().put(key, item, value);return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 向一张hash表中放入数据,如果不存在将创建** @param key* @param item* @param value* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间* @return true 成功 false失败*/public boolean hset(String key, String item, Object value, long time) {try {redisTemplate.opsForHash().put(key, item, value);if (time > 0) {expire(key, time);}return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 删除hash表中的值** @param key* @param item*/public void hdel(String key, Object... item) {redisTemplate.opsForHash().delete(key, item);}/*** 判断hash表中是否存在item** @param key* @param item* @return true 存在 false不存在*/public boolean hHasKey(String key, String item) {return redisTemplate.opsForHash().hasKey(key, item);}/*** hash递增 如果不存在,就会创建一个 并把新增后的值返回** @param key* @param item* @param by 要增加的值(大于0)* @return object*/public double hincr(String key, String item, double by) {return redisTemplate.opsForHash().increment(key, item, by);}/*** hash递减** @param key* @param item* @param by 要减少的值(小于0)* @return object*/public double hdecr(String key, String item, double by) {return redisTemplate.opsForHash().increment(key, item, -by);}/*** 获取set的内容** @param key* @return object*/public Set<Object> sGet(String key) {try {return redisTemplate.opsForSet().members(key);} catch (Exception e) {System.out.println("系统异常：" + e);return null;}}/*** 判断set中是否存在某个值** @param key* @param value* @return object*/public boolean sHasKey(String key, Object value) {try {return redisTemplate.opsForSet().isMember(key, value);} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 设置set** @param key* @param values* @return object long*/public long sSet(String key, Object... values) {try {return redisTemplate.opsForSet().add(key, values);} catch (Exception e) {System.out.println("系统异常：" + e);return 0;}}/*** 设置set同时指定过期时间** @param key* @param time 时间(秒)* @param values* @return object*/public long sSetAndTime(String key, long time, Object... values) {try {Long count = redisTemplate.opsForSet().add(key, values);if (time > 0) {expire(key, time);}return count;} catch (Exception e) {System.out.println("系统异常：" + e);return 0;}}/*** 获取set的元素个数** @param key* @return object*/public long sGetSetSize(String key) {try {return redisTemplate.opsForSet().size(key);} catch (Exception e) {System.out.println("系统异常：" + e);return 0;}}/*** 从set中移除元素** @param key* @param values* @return object*/public long setRemove(String key, Object... values) {try {Long count = redisTemplate.opsForSet().remove(key, values);return count;} catch (Exception e) {System.out.println("系统异常：" + e);return 0;}}/*** 获取List的内容** @param key* @param start 开始索引* @param end 结束索引 0 到 -1代表所有值* @return object*/public List<Object> lGet(String key, long start, long end) {try {return redisTemplate.opsForList().range(key, start, end);} catch (Exception e) {System.out.println("系统异常：" + e);return null;}}/*** 获取list的长度** @param key* @return object*/public long lGetListSize(String key) {try {return redisTemplate.opsForList().size(key);} catch (Exception e) {System.out.println("系统异常：" + e);return 0;}}/*** 通过索引 获取list中的值** @param key* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推* @return object*/public Object lGetIndex(String key, long index) {try {return redisTemplate.opsForList().index(key, index);} catch (Exception e) {System.out.println("系统异常：" + e);return null;}}/*** 设置List** @param key* @param value* @return object*/public boolean lSet(String key, Object value) {try {redisTemplate.opsForList().rightPush(key, value);return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 设置List** @param key* @param value* @param time 时间(秒)* @return object*/public boolean lSet(String key, Object value, long time) {try {redisTemplate.opsForList().rightPush(key, value);if (time > 0) {expire(key, time);}return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 设置List** @param key* @param value* @return object*/public boolean lSet(String key, List<Object> value) {try {redisTemplate.opsForList().rightPushAll(key, value);return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 设置List同时指定过期时间** @param key* @param value* @param time 时间(秒)* @return object*/public boolean lSet(String key, List<Object> value, long time) {try {redisTemplate.opsForList().rightPushAll(key, value);if (time > 0) {expire(key, time);}return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 根据索引修改list中的某条数据** @param key* @param index* @param value* @return object*/public boolean lUpdateIndex(String key, long index, Object value) {try {redisTemplate.opsForList().set(key, index, value);return true;} catch (Exception e) {System.out.println("系统异常：" + e);return false;}}/*** 移除N个值为value** @param key* @param count* @param value* @return 移除的个数*/public long lRemove(String key, long count, Object value) {try {Long remove = redisTemplate.opsForList().remove(key, count, value);return remove;} catch (Exception e) {System.out.println("系统异常：" + e);return 0;}}
}3.4.11 ThreadPool
package com.zrj.redis.utils;import com.google.common.util.concurrent.ThreadFactoryBuilder;import java.util.concurrent.*;/*** 线程池** @author zrj* @since 2021/8/28**/
public class ThreadPool {//线程池的核心线程数private static int corePoolSize = 30;//能容纳的最大线程数private static int maximumPoolSize = 200;//空闲线程存活时间private static long keepAliveTime = 0L;//空闲线程存活时间 单位private static TimeUnit unit = TimeUnit.MILLISECONDS;//创建线程的工厂类,自定义线程名称private static String threadName = "thread-local-pool-%d";private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat(threadName).build();//存放提交但未执行任务的队列private static BlockingQueue<Runnable> threadFactory = new LinkedBlockingQueue<>(1024);//等待队列满后的拒绝策略private static RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();// 定义线程池private static ExecutorService pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, threadFactory, namedThreadFactory, handler);/*** 获取线程池** @param* @return java.util.concurrent.ExecutorService*/public static ExecutorService getPool() {return pool;}
}3.4.12 RedisController
package com.zrj.redis.controller;import com.zrj.redis.entity.Goods;
import com.zrj.redis.entity.Response;
import com.zrj.redis.utils.RedisUtil;
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;
import java.util.*;/*** 缓存控制器* Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。* 其实在SpringBoot的官网上我们也能看到，官方现在推荐的是SpringDataRedis形式，* 相对于Jedis来说可以方便地更换Redis的Java客户端，其比Jedis多了自动管理连接池的特性，* 方便与其他Spring框架进行搭配使用如：SpringCache。** @author zrj* @since 2021/8/27**/
@RestController
@RequestMapping("/redis")
public class RedisController {@Resourceprivate RedisUtil redisUtil;/*** 字符串（String）二进制安全的字符串*/@GetMapping("/getStr")public Response getStr() {String phoneKey = "string_phone_key";String phoneValue = "hello honor";redisUtil.set(phoneKey, phoneValue);String hello = (String) redisUtil.get(phoneKey);return Response.success("字符串查询成功", hello);}/*** 对象*/@GetMapping("/getObj")public Response getObj() {String goodsKey = "goods_key";Goods build = Goods.builder().name("手机").price(666).brand("诺基亚").build();redisUtil.set(goodsKey, build);Goods goods = (Goods) redisUtil.get(goodsKey);return Response.success("对象查询成功", goods);}/*** 列表（Lists）：按照插入顺序排列的字符串元素的集合。从根本上说它们是 Linked Lists。*/@GetMapping("/getList")public Response getList() {String phoneKey = "list_phone_key";LinkedList<String> linkedList = new LinkedList<>();linkedList.add("honor");linkedList.add("real");redisUtil.set(phoneKey, linkedList);LinkedList hello = (LinkedList) redisUtil.get(phoneKey);return Response.success("列表查询成功", hello);}/*** 集合（Sets）：唯一、无序的字符串元素的集合。*/@GetMapping("/getSets")public Response getSets() {String phoneKey = "set_phone_key";Set<String> set = new HashSet<>();set.add("apollo");set.add("real");set.add("real");redisUtil.set(phoneKey, set);HashSet hello = (HashSet) redisUtil.get(phoneKey);return Response.success("集合查询成功", hello);}/*** 有序集合（Sorted sets）： 类似于集合，但每个字符串元素都与一个称为score的浮点数值相关联。* 元素总是按分数排序，因此与集合不同，可以检索一系列元素（例如，您可能会问：给出前10个或后10个）。*/@GetMapping("/getSortedSets")public Response getSortedSets() {String phoneKey = "sorted_phone_key";Set<String> set = new HashSet<>();set.add("dell");set.add("real");set.add("apollo");redisUtil.set(phoneKey, set);HashSet hello = (HashSet) redisUtil.get(phoneKey);return Response.success("有序集合查询成功", hello);}/*** 哈希（Hashes）： 它是由字段和值组成的map。字段和值都是字符串。这和Ruby或Python的hashes非常相似。*/@GetMapping("/getHashes")public Response getHashes() {String phoneKey = "hashes_phone_key";Map<String, Object> hashMap = new HashMap<>();hashMap.put("honor", "998");hashMap.put("real", "997");hashMap.put("apollo", "996");redisUtil.set(phoneKey, hashMap);HashMap hello = (HashMap) redisUtil.get(phoneKey);return Response.success("哈希查询成功", hello);}}3.4.13 RedissonController
package com.zrj.redis.controller;import com.zrj.redis.entity.Response;
import com.zrj.redis.utils.RedissonLock;
import com.zrj.redis.utils.ThreadPool;
import org.redisson.api.RedissonClient;
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;/*** RedissonClient** @author zrj* @since 2021/8/27**/
@RestController
@RequestMapping("/redisson")
public class RedissonController {@Resourceprivate RedissonLock redissonLock;/*** 测试服务*/@GetMapping("/redissonLock")public Response redissonLock() {for (int i = 0; i < 10; i++) {int finalI = i;ThreadPool.getPool().execute(()->{String result = redissonLock.distributedRedissonLock();System.out.println("第"+ finalI +"个线程进入: "+result);});}return Response.success("分布式可重入锁加锁成功", null);}}Redis分布式锁详解相关推荐
- SpringCloud Alibaba 之 Config配置中心,Redis分布式锁详解
目录 1.服务配置中心 1.1 服务配置中心介绍 1.2 Nacos Config 实践 1.2.1 Nacos config 入门案例 1.2.2 Nacos 配置动态刷新 1.2.3 配置共享 ...
- Redis缓存雪崩、穿透、击穿，布隆过滤器，分布式锁详解
缓存雪崩 在某一个时间存在大量的缓存key失效 解决办法 1.有效期一直---->给每一个数据加上水机有效期 2.redis挂掉了----->使用redis集群,分摊key的存储 引出re ...
- Redis的分布式锁详解
一.什么是分布式锁: 1.什么是分布式锁: 分布式锁,即分布式系统中的锁.在单体应用中我们通过锁解决的是控制共享资源访问的问题,而分布式锁,就是解决了分布式系统中控制共享资源访问的问题.与单体应用不同 ...
- 实战：分布式锁详解与代码
什么是锁? 锁是一种常用的并发控制机制,用于保证一项资源在任何时候只能被一个线程使用,如果其他线程也要使用同样的资源,必须排队等待上一个线程使用完. 锁的示意图,如下所示: 什么是分布式锁? 上面说的 ...
- 分布式锁详解及实现案例
前言 随着互联网的发展,人们网上购物已然成为常态,特别是双十一和618等大型的购物节,网站的并发数量也急剧上升,因此我们后台的框架也逐渐从以前的单机版升级到现在的分布式集群.这一切的演变最终目的都是为 ...
- redis 分布式缓存 详解
1.Redis概述 1.1.NoSQL NoSQL(Not Only SQL),意即不仅仅是SQL, 泛指非关系型的数据库. 1.2.Redis安装 首先需要从Redis官网上下载Redis的源码包, ...
- 干货，springboot自定义注解实现分布式锁详解
背景 在互联网的很多场景下,会产生资源竞争,如果是单机环境,简单加个锁就能解决问题:但是在集群环境下(分布式环境),多个客户端在一个很短的时间内竞争同一服务端资源(如抢购场景),或者同一客户端重复提交 ...
- 并发场景下的幂等问题——分布式锁详解
简介:本文从钉钉实人认证场景的一例数据重复问题出发,分析了其原因是因为并发导致幂等失效,引出幂等的概念.针对并发场景下的幂等问题,提出了一种实现幂等可行的方法论,结合通讯录加人业务场景对数据库幂等问题 ...
- java分布式锁详解
一.什么是分布式锁 分布式锁是一种在分布式系统中,用来保护共享资源的一种机制,当多个线程或进程同时访问共享资源时,可以通过分布式锁来保护,保证共享资源只能被一个线程或进程访问,以实现共享资源的安全访问 ...
最新文章
- Grunt-几个常用的任务配置，加载，执行的写法
- 使用Hystrix实现自动降级与依赖隔离[微服务]
- PL/SQL-2 复合数据类型
- QT导入libcurl
- 在matlab中输出、读取多个文件
- Random Forest随机森林概述
- Bootstrap 分页导航的对齐方式
- chrome应用程序无法启动因为并行配置不正确_Win8打不开软件提示并行配置不正确的解决方法...
- 易宝典文章——玩转Office 365中的Exchange Online服务 之二十八 怎样过滤病毒***邮件...
- cxonev4验证用户_欧姆龙编程组态软件Omron CX-ONE V4.50 简体中文版
- 数据库系统工程师真题及详解（2015~2021）
- DIY 3.5毫米/MMCX接口的耳机线（无麦）
- 全网最细最全Appium自动化测试 iOS入门教程，App自动化测试教程，精细整理
- 数值分析--python--LU分解法
- BMP(DIB)图片格式
- 黑鲨给电脑重装系统的详细步骤
- Servlet生命周期详解
- Windows 使用命令行修改密码
- Hibernate的Disjunction和Conjunction
- uniapp 视频video 播放 白屏 android