Redis解读（3）：Redis分布式锁、消息队列、操作位图进阶应用
Redis 做分布式锁
分布式锁也算是 Redis 比较常见的使用场景
问题场景：
例如一个简单的用户操作，一个线城去修改用户的状态，首先从数据库中读出用户的状态，然后
在内存中进行修改，修改完成后，再存回去。在单线程中，这个操作没有问题，但是在多线程
中，由于读取、修改、存 这是三个操作，不是原子操作，所以在多线程中，这样会出问题。
对于这种问题，我们可以使用分布式锁来限制程序的并发执行。
1.基本用法
分布式锁实现的思路很简单，就是进来一个线城先占位，当别的线城进来操作时，发现已经有人占位
了，就会放弃或者稍后再试。
在 Redis 中，占位一般使用 setnx 指令，先进来的线城先占位，线城的操作执行完成后，再调用 del 指
令释放位子。
根据上面的思路，我们写出的代码如下：
package org.taoguoguo.distributed.lock;
import org.taoguoguo.redis.Redis;
/**
* @author taoguoguo
* @description LockTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-11 16:19
*/
public class LockTest {
public static void main(String[] args) {
Redis redis = new Redis();
redis.execute(jedis -> {
Long setnx = jedis.setnx("lockName", "lockValue");
if(1 == setnx){
//没有线程占位,执行业务代码
jedis.set("name","taoguoguo");
System.out.println(jedis.get("name"));
//释放资源
jedis.del("lockName");
}else{
//有线程占位，停止/暂缓 操作
}
});
}
}
上面的代码存在一个小小问题：如果代码业务执行的过程中抛异常或者挂了，这样会导致 del 指令没有
被调用，这样，lockName 无法释放，后面来的请求全部堵塞在这里，锁也永远得不到释放。
要解决这个问题，我们可以给锁添加一个过期时间，确保锁在一定的时间之后，能够得到释放。改进后
的代码如下:
package org.taoguoguo.distributed.lock;
import org.taoguoguo.redis.Redis;
/**
* @author taoguoguo
* @description LockTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-11 16:19
*/
public class LockTest {
public static void main(String[] args) {
Redis redis = new Redis();
redis.execute(jedis -> {
Long setnx = jedis.setnx("lockName", "lockValue");
if(1 == setnx){
//给锁添加一个过期时间，防止应用在运行过程中抛出异常导致锁无法及时得到释放
jedis.expire("lockName",5);
//没有线程占位,执行业务代码
jedis.set("name","taoguoguo");
System.out.println(jedis.get("name"));
//释放资源
jedis.del("lockName");
}else{
//有线程占位，停止/暂缓 操作
}
});
}
}
这样改造之后，还有一个问题，就是在获取锁和设置过期时间之间如果如果服务器突然挂掉了，这个时
候锁被占用，无法及时得到释放，也会造成死锁，因为获取锁和设置过期时间是两个操作，不具备原子
性。
为了解决这个问题，从 Redis2.8 开始，setnx 和 expire 可以通过一个命令一起来执行了，我们对上述
代码再做改进：
package org.taoguoguo.distributed.lock;
import org.taoguoguo.redis.Redis;
import redis.clients.jedis.params.SetParams;
/**
* @author taoguoguo
* @description LockTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-11 16:19
*/
public class LockTest {
public static void main(String[] args) {
Redis redis = new Redis();
redis.execute(jedis -> {
String set = jedis.set("lockName", "lockValue", new SetParams().nx().ex(5));
if(set != null && "OK".equals(set)){
//没有线程占位,执行业务代码
jedis.set("name","taoguoguo");
System.out.println(jedis.get("name"));
//释放资源
jedis.del("lockName");
}else{
//有线程占位，停止/暂缓 操作
}
});
}
}
2.解决超时问题
问题场景：
为了防止业务代码在执行的时候抛出异常，我们给每一个锁添加了一个超时时间，超时之后，锁会被自
动释放，但是这也带来了一个新的问题：如果要执行的业务非常耗时，可能会出现紊乱。举个例子：第
一个线程首先获取到锁，然后开始执行业务代码，但是业务代码比较耗时，执行了 8 秒，这样，会在第
一个线程的任务还未执行成功锁就会被释放了，此时第二个线程会获取到锁开始执行，在第二个线程刚
执行了 3 秒，第一个线程也执行完了，此时第一个线程会释放锁，但是注意，它释放的第二个线程的
锁，释放之后，第三个线程进来。
对于这个问题，我们可以从两个角度入手：
- 尽量避免在获取锁之后，执行耗时操作。
- 可以在锁上面做文章，将锁的 value 设置为一个随机字符串，每次释放锁的时候，都去比较随机
字符串是否一致，如果一致，再去释放，否则，不释放。
对于第二种方案，由于释放锁的时候，要去查看锁的 value，第二个比较 value 的值是否正确，第三步
释放锁，有三个步骤，很明显三个步骤不具备原子性，为了解决这个问题，我们得引入 Lua 脚本。
Lua 脚本的优势：
-
使用方便，Redis 中内置了对 Lua 脚本的支持。
-
Lua 脚本可以在 Redis 服务端原子的执行多个 Redis 命令。
-
由于网络在很大程度上会影响到 Redis 性能，而使用 Lua 脚本可以让多个命令一次执行，可以有
效解决网络给 Redis 带来的性能问题。
在 Redis 中，使用 Lua 脚本，大致上两种思路：
- 提前在 Redis 服务端写好 Lua 脚本，然后在 Java 客户端去调用脚本（推荐）。
- 可以直接在 Java 端去写 Lua 脚本，写好之后，需要执行时，每次将脚本发送到 Redis 上去执行。
首先在 Redis 服务端创建 Lua 脚本，内容如下：
if redis.call("get",KEYS[1])==ARGV[1] then
return redis.call("del",KEYS[1])
else
return 0
end
接下来，可以给 Lua 脚本求一个 SHA1 和，命令如下：
cat releasewherevalueequal.lua | redis-cli -a 123456 script load --pipe
script load 这个命令会在 Redis 服务器中缓存 Lua 脚本，并返回脚本内容的 SHA1 校验和，然后在 Java 端调用时，传入 SHA1 校验和作为参数，这样 Redis 服务端就知道执行哪个脚本了。
接下来，在 Java 端调用这个脚本。
package org.taoguoguo.redis;
import redis.clients.jedis.params.SetParams;
import java.util.Arrays;
import java.util.UUID;
/**
* @author taoguoguo
* @description LuaTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-11 17:56
*/
public class LuaTest {
public static void main(String[] args) {
Redis redis = new Redis();
for (int i=0; i<10; i++){
redis.execute(jedis -> {
//1.先获取一个随机字符串
String value = UUID.randomUUID().toString();
//2.获取锁
String lock = jedis.set("lockName", value, new SetParams().nx().ex(5));
//3.判断是否成功拿到锁
if (lock != null && "OK".equals(lock)) {
//4.具体的业务操作
jedis.set("site", "https://www.cnblogs.com/doondo");
String site = jedis.get("site");
System.out.println(site);
//5.释放锁
jedis.evalsha("b8059ba43af6ffe8bed3db65bac35d452f8115d8", Arrays.asList("lockName"), Arrays.asList(value));
} else {
System.out.println("没拿到锁");
}
});
}
}
}
Redis 做消息队列
我们平时说到消息队列，一般都是指 RabbitMQ、RocketMQ、ActiveMQ 以及大数据里边的 Kafka，
这些是我们比较常见的消息中间件，也是非常专业的消息中间件，作为专业的中间件，它里边提供了许
多功能。
但是，当我们需要使用消息中间件的时候，并非每次都需要非常专业的消息中间件，假如我们只有一个
消息队列，只有一个消费者，那就没有必要去使用上面这些专业的消息中间件，这种情况我们可以直接
使用 Redis 来做消息队列。
Redis 的消息队列不是特别专业，他没有很多高级特性，适用简单的场景，如果对于消息可靠性有着极
高的追求，那么不适合使用 Redis 做消息队列。
1.消息队列
Redis 做消息队列，使用它里边的 List 数据结构就可以实现，我们可以使用 lpush/rpush 操作来实现入
队，然后使用 lpop/rpop 来实现出队。
回顾一下：
在客户端（例如 Java 端），我们会维护一个死循环来不停的从队列中读取消息，并处理，如果队列中
有消息，则直接获取到，如果没有消息，就会陷入死循环，直到下一次有消息进入，这种死循环会造成
大量的资源浪费，这个时候，我们可以使用之前讲的 blpop/brpop 。
2.延迟消息队列
延迟队列可以通过 zset 来实现，因为 zset 中有一个 score，我们可以把时间作为 score，将 value 存到
redis 中，然后通过轮询的方式，去不断的读取消息出来。
首先，如果消息是一个字符串，直接发送即可，如果是一个对象，则需要对对象进行序列化，这里我们
使用 JSON 来实现序列化和反序列化。
所以，首先在项目中，添加 JSON 依赖：
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.3</version>
</dependency>
接下来，构造一个消息对象：
package org.taoguoguo.message;
/**
* @author taoguoguo
* @description RedisMessage 消息对象
* @website https://www.cnblogs.com/doondo
* @create 2021-04-12 20:33
*/
public class RedisMessage {
//消息ID
private String id;
//消息体
private Object data;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
@Override
public String toString() {
return "RedisMessage{" +
"id='" + id + '\'' +
", data=" + data +
'}';
}
}
接下来封装一个消息队列：
package org.taoguoguo.message;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import redis.clients.jedis.Jedis;
import java.util.Date;
import java.util.Set;
import java.util.UUID;
/**
* @author taoguoguo
* @description DelayMessageQueue 延迟消息队列
* @website https://www.cnblogs.com/doondo
* @create 2021-04-12 20:35
*/
public class DelayMessageQueue {
private Jedis jedis;
//消息队列队列名
private String queue;
public DelayMessageQueue(Jedis jedis, String queue) {
this.jedis = jedis;
this.queue = queue;
}
/**
* 消息入队
* @param data 要发送的消息
*/
public void queue(Object data){
try {
//1.构造一个Redis消息对象
RedisMessage message = new RedisMessage();
message.setId(UUID.randomUUID().toString());
message.setData(data);
//2.序列化
String jsonMessage = new ObjectMapper().writeValueAsString(message);
System.out.println("Redis Message publish: " + new Date());
//消息发送，score 延迟 5 秒
jedis.zadd(queue, System.currentTimeMillis()+5000,jsonMessage);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
/**
* 消息消费
*/
public void loop(){
//当前线程未被打断 一直监听
while (!Thread.interrupted()){
//读取 score 在 0 到当前时间戳之间的消息 一次读取一条，偏移量为0
Set<String> messageSet = jedis.zrangeByScore(queue, 0, System.currentTimeMillis(), 0, 1);
if(messageSet.isEmpty()){
try {
//如果消息是空的，则休息 500 毫秒然后继续
Thread.sleep(500);
} catch (InterruptedException e) {
//如果抛出异常 退出循环
break;
}
continue;
}
//如果读取到了消息，则直接读取出来
String messageStr = messageSet.iterator().next();
if(jedis.zrem(queue,messageStr) > 0){
//消息存在，并且消费成功
try {
RedisMessage redisMessage = new ObjectMapper().readValue(messageStr, RedisMessage.class);
System.out.println("Redis Message receive: " + new Date() + redisMessage);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
}
}
}
测试：
package org.taoguoguo.message;
import org.taoguoguo.redis.Redis;
/**
* @author taoguoguo
* @description DelayMessageTest
* @website https://www.cnblogs.com/doondo
* @create 2021-04-12 21:20
*/
public class DelayMessageTest {
public static void main(String[] args) {
Redis redis = new Redis();
redis.execute(jedis -> {
//构造一个消息队列
DelayMessageQueue queue = new DelayMessageQueue(jedis, "taoguoguo-delay-queue");
//构造消息生产者
Thread producer = new Thread(){
@Override
public void run() {
for(int i=0;i<5;i++){
queue.queue("https://www.cnblogs.com/doondo>>>>>"+i);
}
}
};
//构造消息消费者
Thread consumer = new Thread(){
@Override
public void run() {
queue.loop();
}
};
//启动
producer.start();
consumer.start();
//消费完成后，停止程序，时间大于消费时间
try {
Thread.sleep(10000);
consumer.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
Redis操作位图
1.基本介绍
用户一年的签到记录，如果你用 string 类型来存储，那你需要 365 个 key/value，操作起来麻烦。通过位图可以有效的简化这个操作。
它的统计很简单：01111000111
每天的记录占一个位，365 天就是 365 个位，大概 46 个字节，这样可以有效的节省存储空间，如果有一天想要统计用户一共签到了多少天，统计 1 的个数即可。
对于位图的操作，可以直接操作对应的字符串（get/set），可以直接操作位（getbit/setbit）
2.基本操作
2.1零存整取
存的时候操作的是位，获取的时候是获取整个字符串
例如存储一个 Java 字符串：
| 字符 | ASCII | 二进制 |
|---|---|---|
| J | 74 | 01001010 |
| a | 97 | 01100001 |
| v | 118 | 01110110 |
2.2整存零取
存一个字符串进去，但是通过位操作获取字符串。
3.统计
例如签到记录：01111000111
1 表示签到的天，0 表示没签到，统计总的签到天数：可以使用 bitcount。
bitcount 中，可以统计的起始位置，但是注意，这个起始位置是指字符的起始位置而不是 bit 的起始位置。
除了 bitcount 之外，还有一个 bitpos。bitpos 可以用来统计在指定范围内出现的第一个 1 或者 0 的位置，这个命令中的起始和结束位置都是字符索引，不是 bit 索引，一定要注意。
4.Bit 批处理
在 Redis 3.2 之后，新加了一个功能叫做 bitfiled ，可以对 bit 进行批量操作。
例如：
BITFIELD name get u4 0
表示获取 name 中的位，从 0 开始获取，获取 4 个位，返回一个无符号数字。
- u 表示无符号数字
- i 表示有符号数字，有符号的话，第一个符号就表示符号位，1 表示是一个负数。
BITFIELD 也可以一次执行多个操作。
GET（对于结果不太明白的，学习一下计算机中 位与字节、以及进制之间的关系）
可以一次性进行多个GET
SET:
用无符号的 98 转成的 8 位二进制数字，代替从第 8 位开始接下来的 8 位数字。
INCRBY：
对置顶范围进行自增操作，自增操作可能会出现溢出，既可能是向上溢出，也可能是向下溢出。Redis 中对于溢出的处理方案是折返。8 位无符号数 255 加 1 溢出变为 0；8 位有符号数 127，加 1 变为 - 128。
也可以修改默认的溢出策略，可以改为 fail ，表示执行失败。
BITFIELD name overflow fail incrby u2 6 1
sat 表示留在在最大/最小值。
BITFIELD name overflow sat incrby u2 6 1
