提示:本文中若出现个人观点不对处请指正,谢谢!
目录
2. 配置application.yml文件连接到redis
3. 编写RestController测试类TestMyLock
一、Redisson读写锁
- 先有写锁时,不会立刻给数据加读锁,需要等写锁释放后,才能加读锁。
- 先有读锁时,写锁也需要等待读锁的释放,才能加写锁。
- 同时访问读锁时,会同时加锁成功,相当不加锁并发读数据。
只要有写锁的存在,都必须等待,写锁是一个排它锁,只能有一个写锁存在,读锁是一个共享锁,可以有多个读锁同时存在。
二、示例代码
1. 引入 Maven 依赖
创建一个基础的springboot项目,引入maven依赖。
<?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>
<groupId>com</groupId>
<artifactId>redissondemo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>redissondemo</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<spring-boot.version>2.3.7.RELEASE</spring-boot.version>
</properties>
<dependencies>
<!-- 引入redisson依赖 -->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.13.4</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.3.7.RELEASE</version>
<configuration>
<mainClass>com.redissondemo.RedissondemoApplication</mainClass>
</configuration>
<executions>
<execution>
<id>repackage</id>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
2. 配置application.yml文件连接到redis
# 应用服务 WEB 访问端口
server:
port: 8080
# 应用名称
spring:
application:
name: redissondemo
# redis 配置
redis:
# redis数据库索引(默认0)
#database: 0
# redis 服务器地址(IP地址)
host: 127.0.0.1
# redis 服务器端口
port: 6379
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线程的写锁才加锁成功执行。说明:写锁互斥,是一个排它锁。需要等待上一个锁释放。