使用场景
日常开发场景中在redis做缓存的时候,有一个必须要考虑的问题,就是数据库内容和redis库里应该保持一致(双写一致性),要不然就会有脏数据或者其他的问题。
解决方案
解决方案一般有两个大方向,
1.系统追求强一致性,那就需要加锁,可以使用今天这篇文章讲解的Redission的读写锁。
2.不太注重强一致性的话,数据可以有一定的延时(符合大部分系统使用情况),可以使用延时双删,canal组件,mq传输等等方案。
今天就写了个Redission分布式锁的入门使用记录。
步骤
一、Redisson读写锁
先有写锁时,不会立刻给数据加读锁,需要等写锁释放后,才能加读锁。
先有读锁时,写锁也需要等待读锁的释放,才能加写锁。
同时访问读锁时,会同时加锁成功,相当不加锁并发读数据。
只要有写锁的存在,都必须等待,写锁是一个排它锁,只能有一个写锁存在,读锁是一个共享锁,可以有多个读锁同时存在。
二、示例代码
1. 引入 Maven 依赖
引入redission的依赖。
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.8.2</version>
</dependency>
2. 配置application.yml文件连接到redis
redis:
host: 192.168.22.88
port: 6379
timeout: 86400
password: 123456
jedis:
pool:
max-active: 8
max-wait: 10000
max-idle: 8
min-idle: 0
time-between-eviction-runs: 1000
3. 编写RestController测试类TestMyLock
package com.redissondemo.controller;
import org.redisson.api.RLock;
import org.redisson.api.RReadWriteLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 2022年7月30日23:27:20
*/
@RestController
@RequestMapping(path = "/mylock")
public class TestMyLock {
@Autowired
private RedissonClient redisson;
/**
* 写锁,变更图书信息
* 2022年8月13日15:56:42
* @param bookId
* @return
*/
@GetMapping("/upBook")
public String updateBook(Long bookId){
if(bookId == null || bookId<=0){
return "error";
}
//图书ID做为锁名称
String lockkey=bookId.toString();
//获取读写锁
RReadWriteLock lock = redisson.getReadWriteLock(lockkey);
System.out.println("获得:writeLock---getReadWriteLock====");
//获得写锁
RLock rLock = lock.writeLock();
System.out.println("获得:writeLock---");
//加锁
rLock.lock();
try {
System.out.println("lock()加锁成功,更新图书信息--------Thread.sleep(10000)---------线程ID" + Thread.currentThread().getId());
Thread.sleep(10000);
} catch (Exception e) {
e.printStackTrace();
} finally {
//解锁
rLock.unlock();
System.out.println("更新图书信息完毕,finally解锁-----------------线程ID" + Thread.currentThread().getId());
}
return "book更新成功!...";
}
/**
* 读锁,读取图书信息
* 2022年8月13日15:57:11
* @param bookId
* @return
*/
@GetMapping("getBook")
public String getBook(Long bookId){
if(bookId == null || bookId<=0){
return "error";
}
//图书ID做为锁名称
String lockkey=bookId.toString();
//获取读写锁
RReadWriteLock lock = redisson.getReadWriteLock(lockkey);
System.out.println("获得:readLock---读锁----.......getReadWriteLock********");
//获得读锁
RLock rLock = lock.readLock();
System.out.println("获得:readLock---读锁----.......");
//加锁
rLock.lock();
try {
System.out.println("lock()加锁成功,读取图书-..........-----==Thread.sleep(6000)==========线程ID" + Thread.currentThread().getId());
Thread.sleep(6000);
} catch (Exception e) {
e.printStackTrace();
} finally {
rLock.unlock();
System.out.println("读取图书完毕!------finally解锁===-线程ID" + Thread.currentThread().getId());
}
return "BOOK...读取成功!。。。。。。";
}
}
三、启动项目测试
复制工程到两个不同目录,分别启动服务端口8080和8081的两个实例。(注意启动redis服务)
(1)先访问:127.0.0.1:8080/mylock/upBook?bookId=1(写锁)
再访问:127.0.0.1:8080/mylock/getBook?bookId=1(读锁)
如上图运行结果可以看出:写锁存在时,读锁需要等待写锁释放后才能加锁执行。
(2)先访问:127.0.0.1:8080/mylock/getBook?bookId=1(读锁)
再访问:127.0.0.1:8080/mylock/upBook?bookId=1(写锁)
如上图运行结果可以看出:读锁存在时,写锁需要等待读锁释放后才能加锁执行。
(3)先访问:127.0.0.1:8080/mylock/upBook?bookId=1(写锁)
再访问:127.0.0.1:8080/mylock/getBook?bookId=1(读锁)和127.0.0.1:8081/mylock/getBook?bookId=1
如上图运行结果(第一个图8080服务实例,第二个图8081服务实例):先访问一个写锁,在几乎同时访问两个读锁,两个读锁都在写锁释放后几乎同时加锁成功执行。说明:多个读锁代码可以并发执行,是一个共享锁。
(4)先访问:127.0.0.1:8080/mylock/upBook?bookId=1(写锁)
再访问:127.0.0.1:8080/mylock/upBook?bookId=1(写锁)
如上图运行结果:82线程的写锁释放后,83线程的写锁才加锁成功执行。说明:写锁互斥,是一个排它锁。需要等待上一个锁释放。