Redisson分布式锁原理解析

前言

首先Redis执行命令是单线程的，所以可以利用Redis实现分布式锁，而对于Redis单线程的问题，是其线程模型的问题，本篇重点是对目前流行的工具Redisson怎么去实现的分布式锁进行深入理解；开始之前，我们可以下你思考一个问题，Redisson的实现方式有何不同？为什么？

使用

引入依赖

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

添加配置

    @Autowiredprivate RedisProperties redisProperties;@Beanpublic RedissonClient redisClient() {Config config = new Config();config.setTransportMode(TransportMode.NIO);SingleServerConfig singleServerConfig = config.useSingleServer();singleServerConfig.setAddress(String.format("redis://%s:%s", redisProperties.getHost(), redisProperties.getPort()));singleServerConfig.setPassword(redisProperties.getPassword());return Redisson.create(config);}

加锁

private final RedissonClient redissonClient;public void lock() throws Exception {RLock lock = redissonClient.getLock(PRODUCT_LOCK_KEY + id);if (lock.tryLock(100, TimeUnit.MILLISECONDS)) {// 业务} else {// 业务}
}

如上使用是最简单的方式，Redission它底层封装了很多逻辑，但如果说要redis客户端实现，你要怎么实现？

Redis中本就有支持分布式锁的命令：setnx，对应RedisTemplate中，使用如下：

redisTemplate.opsForValue().setIfAbsent("lockkey", "", 1, TimeUnit.SECONDS);

使用Redis实现分布式锁需要注意的是不要产生死锁，所以使用Redis实现分布式锁有两种方式：

  1. setnx命令
  2. lua脚本

两种方式都是一个操作完成key，value的设置以及过期时间的设置，你是否有相关，他们的实现是否都一样，或者说，这个实现可以有其他实现方式？

源码

原理

  1. lua脚本保证多个命令的原子性；
  2. 采用hash数据结构，key为锁的名称，field是线程对应的名称，也因为这个数据结构，也支持可重入锁；
  3. 定时延时的操作避免死锁（看门狗）；

lock()

我们先看lock()方法，tryLock()和lock()底层是一样的，所以我们只看lock方法；

   @Overridepublic void lock() {try {lock(-1, null, false);} catch (InterruptedException e) {throw new IllegalStateException();}}

位置：org.redisson.RedissonLock#lock(long, java.util.concurrent.TimeUnit, boolean)

传参是：(-1, null, false)

image-20240402175531643

/**
leaseTime： 过期时间
unit：过期时间单位
interruptibly： 信号量，是否打断线程
*/
private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {// 取线程ID，后面作为锁的一个标志long threadId = Thread.currentThread().getId();// 加锁// 两个步骤：// 1. 利用lua脚本设置锁与过期时间（原子操作），过期时间lockWatchdogTimeout = 30 * 1000 = 30秒// 2. 执行过期时间刷新（这里的刷新时利用回调的方式 + 延迟执行实现的定时任务），lockWatchdogTimeout/3 = 10秒Long ttl = tryAcquire(-1, leaseTime, unit, threadId);// lua脚本中，加锁成功返回nil，对应redis中是null，加锁失败，则返回的是已存在的锁的过期时间// 所以这里返回null，就是加锁成功了，就不再往下走了if (ttl == null) {return;}// 加锁成功的在上面就已经结束了，所以下面的都是加锁失败时走的// 这里它订阅了一个channel，参数threadId无用，别被误导了，它订阅的名称时固定的// 为什么这里要订阅？可以思考一下CompletableFuture<RedissonLockEntry> future = subscribe(threadId);// 检查是否超时pubSub.timeout(future);RedissonLockEntry entry;// 这里的interruptibly应该时程序一次时，是否结束，而不是一直在执行中if (interruptibly) {entry = commandExecutor.getInterrupted(future);} else {entry = commandExecutor.get(future);}try {// 这里就是一个自旋 + 加锁while (true) {// 每次循环都进行加锁操作ttl = tryAcquire(-1, leaseTime, unit, threadId);// 同样，如果这里时null，那么就是加锁成功了if (ttl == null) {break;}// 加锁失败：返回了锁的过期时间if (ttl >= 0) {try {// 信号量 + unsafe.park // 信号量：本地更改线程共享变量状态达到加锁的目的// unsafe.park：利用park方法将加锁失败（信号量更改失败）的线程进行挂起// 为什么要挂起，这个问题应该不用多说entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);} catch (InterruptedException e) {if (interruptibly) {throw e;}entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);}} else {// 这个分支时ttl < 0，也就是过期时间为负数，也就是锁失效了// 对本地加锁，之后在下一次循环redis加锁if (interruptibly) {entry.getLatch().acquire();} else {entry.getLatch().acquireUninterruptibly();}}}} finally {unsubscribe(future, threadId);}
//        get(lockAsync(leaseTime, unit));}

上面的步骤就是Redisson大致逻辑：

  1. lua脚本加锁，记录线程id，防止非本线程解锁
  2. 成功则退出
  3. 添加订阅对应的channel（这里的订阅是异步的）
    1. 唤醒：当收到channel的通知后，也就是上一个锁解锁了
    2. 从第6步醒来
  4. 自旋
  5. lua脚本加锁（与第一步一样），存在订阅后，上一个锁解锁了，就不用再挂起线程
  6. 失败挂起：unsafe.park
  7. 加锁成功后，取消订阅

lua脚本加锁

image-20240402175746999image-20240402175814387

image-20240403103101607

简单说一下这个脚本做了什么（lua脚本类似js）：

redis.call是调用redis命令，第一个参数是redis的命令，第二个参数是参数；

它先是exists判断了key，以及hash数据结构了的field是否存在，

如果存在，对field递增，为什么要递增？思考一下；并设置过期时间，返回返回nil；

如果不存在，调用redis命令pttl，获取key的过期时间，并返回；

那如果我们自己写lua脚本呢？

redis 2.6之后支持lua脚本，一个脚本，执行这个脚本是原子性的，所以脚本里的多个命令是原子性的。

如果说要执行批量的命令，可以使用piple，但是管道的话，它并不是原子性的，他只是一次性把批量的命令发给了redis。

LUA脚本格式：

eval "脚本 KEYS[1...N] ARGV[1...N]" count key[1...N] argv[1...N]

KEYS[1…N]：key的展位符，多个时，序号递增，从1开始

ARGV[1…N]：value的展位符，多个时，序号递增，从1开始

count：是对应key输入的个数

key[1…N]：对应KEYS[0…N]的key

argv[1…N]：对应ARGV[0…N]的value

这里就大概简单的说明了一下，使得看本篇的朋友能够理解，详细的还请百度；

看门狗

使用过Redisson的朋友应该都听过“看门狗”，为什么Redisson加锁要看门狗呢？

如果我们使用lock()方法，不设置过期时间，那么应该是永不过期；

好，如果说，加锁成功，在解锁时出了意外，如服务异常退出，或宕机，导致没有解锁，那么这个锁就需要人工干预了，这是有问题的。

所以，在Redisson中，它并不是永不过期，当我们使用lock()方法时，它的参数时-1，但在最终执行lua脚本时传入了默认参数：

位置：org.redisson.RedissonLock#tryAcquireAsync

image-20240402205409341

过期时间时：internalLockLeaseTime；

image-20240402205832964image-20240402205846003

image-20240402205902393

可以看到在初始化时，它便赋予了该值一个默认的30秒；

它并没有将锁设置为无限时间，而是30秒，又怎么保证锁的有效？

所以它还有一个续约的操作，对未使用unlock的锁进行时间延迟，这一操作是为了保证未来某一时刻如果出现服务或其他问题导致解锁失败，产生死锁这样的一个情况。

来看代码：

 private RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {RFuture<Long> ttlRemainingFuture;// leaseTime=-1表示永不过期if (leaseTime > 0) {// 对应方法：tryLock(过期时间, 时间单位)ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);} else {// 对应方法：lock()// 注意它达到参数是：internalLockLeaseTime，上面说了他是30秒// internalLockLeaseTime = lockWatchdogTimeout = 30 * 1000;ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);}// 这里是上面ttlRemainingFuture回调结果处理，// 如果出现异常，就unlock解锁CompletionStage<Long> s = handleNoSync(threadId, ttlRemainingFuture);ttlRemainingFuture = new CompletableFutureWrapper<>(s);
// 这里是定时刷新任务CompletionStage<Long> f = ttlRemainingFuture.thenApply(ttlRemaining -> {// 执行成功返回的时null，所以这里以null为加锁成功的标志if (ttlRemaining == null) {if (leaseTime > 0) {internalLockLeaseTime = unit.toMillis(leaseTime);} else {scheduleExpirationRenewal(threadId);}}return ttlRemaining;});return new CompletableFutureWrapper<>(f);}

image-20240403105722608

image-20240403105635897

handleNoSync它只是针对异常做了处理，正常情况下只是进行了封装，而unlocakInnerAysnc也是在异常时的一个回调；

return是结果封装；

image-20240403105756315

再回到刷新的部分：

它是在加锁完后的一个回调方法，ttlRemaining它就是上面执行的结果，null或者是过期时间，

image-20240403110155068

 private RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {RFuture<Long> ttlRemainingFuture;// leaseTime=-1表示永不过期if (leaseTime > 0) {// 对应方法：tryLock(过期时间, 时间单位)ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);} else {// 对应方法：lock()// 注意它达到参数是：internalLockLeaseTime，上面说了他是30秒// internalLockLeaseTime = lockWatchdogTimeout = 30 * 1000;ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);}// 这里是上面ttlRemainingFuture回调结果处理，// 如果出现异常，就unlock解锁CompletionStage<Long> s = handleNoSync(threadId, ttlRemainingFuture);ttlRemainingFuture = new CompletableFutureWrapper<>(s);
// 这里是定时刷新任务CompletionStage<Long> f = ttlRemainingFuture.thenApply(ttlRemaining -> {// 执行成功返回的时null，所以这里以null为加锁成功的标志if (ttlRemaining == null) {if (leaseTime > 0) {// leaseTime > 0 表示加锁时设置了过期时间// 而ternalLockLeaseTime存在默认值，这里就是取消了默认值internalLockLeaseTime = unit.toMillis(leaseTime);} else {// 那，这里执行 过期时间的定时刷新scheduleExpirationRenewal(threadId);}}return ttlRemaining;});return new CompletableFutureWrapper<>(f);}

image-20240403144946555

过期时间刷新的步骤：

  1. 创建ExpirationEntry，可以看作时一个上下文对象，他是延时的标识
  2. 原子操作，添加上下文ExpirationEntry
  3. 设置当前线程id到上下文
  4. 创建Timeout延时任务，延时10秒
  5. 延时任务执行（异步）：
    1. 根据客户端id和锁获取上下文
    2. 通过上下文获取到线程id
    3. 异步执行延时lua脚本
    4. 执行回调：成功，回调本身，回调第四步，失败，移除上下文，取消延时
 protected void scheduleExpirationRenewal(long threadId) {// 1. 创建ExpirationEntry，可以看作时一个上下文对象，他是延时的标识ExpirationEntry entry = new ExpirationEntry();// 2. 原子操作，添加上下文ExpirationEntry// 要进行过期时间刷新，就要先添加这个对象，可以理解为一个刷新的标志ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry);// 3. 设置当前线程id到上下文if (oldEntry != null) {// 不为空，说明这个对象已经存在，已经有其他线程执行了过期刷新oldEntry.addThreadId(threadId);} else {// 为空，则是不存在该映射对象（锁不存在）entry.addThreadId(threadId);try {// 执行过期时间刷新// 4. 创建Timeout延时任务，延时10秒// 5. 延时任务执行（异步）：//    5.1 根据客户端id和锁获取上下文//    5.2 通过上下文获取到线程id//    5.3 异步执行延时lua脚本//    5.4 执行回调：成功，回调本身，回调第四步，失败，移除上下文，取消延时renewExpiration();} finally {if (Thread.currentThread().isInterrupted()) {cancelExpirationRenewal(threadId);}}}}

下面我们进入renewExpiration方法：

 private void renewExpiration() {// EXPIRATION_RENEWAL_MAP 在上一层方法中添加了刷新的上下文标志ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());if (ee == null) {// 如果这里为null，就说明已经有其他线程移除了，那么就是不需要刷新，锁不存在了return;}// 4. 创建Timeout延时任务，延时10秒// 注意这里的时间： internalLockLeaseTime / 3// 之前说过：internalLockLeaseTime = lockWatchdogTimeout = 30 * 1000;// 所以这里是延迟10秒Timeout task = getServiceManager().newTimeout(new TimerTask() {// 5. 延时任务执行（异步）@Overridepublic void run(Timeout timeout) throws Exception {// 5.1 根据客户端id和锁获取上下文// entryName是客户端id+线程id// 每次执行都要检查，刷新的标志存在，就说明锁还在，需要执行ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());if (ent == null) {return;}// 5.2 通过上下文获取到线程idLong threadId = ent.getFirstThreadId();if (threadId == null) {return;}// 5.3 异步执行延时lua脚本CompletionStage<Boolean> future = renewExpirationAsync(threadId);// 当延时完成后，执行这个方法，也是个回调future.whenComplete((res, e) -> {if (e != null) {log.error("Can't update lock {} expiration", getRawName(), e);// 异常时，移除刷新的标志// 也是避免死锁的一个方式EXPIRATION_RENEWAL_MAP.remove(getEntryName());return;}// 5.4 成功：回调本身，回调第四步，失败：移除上下文，取消延时if (res) {// 延时成功，回调当前这个方法，以实现定时任务renewExpiration();} else {// 没有成功，也是移除刷新的标志// 这里没有成功的情况，是锁已经不存在了，对应的定时任务就应该停止；// 两个步骤：// 1. task.cancel()：通过上下文获取到任务，然后取消// 2. EXPIRATION_RENEWAL_MAP.remove(getEntryName());cancelExpirationRenewal(null);}});}}, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);// 将定时任务放到entry中，也就是放到了定时任务的上下文中// 在下一次时，通过上下文获取到这个定时任务ee.setTimeout(task);}

其实他延时的逻辑也是一个lua脚本：

image-20240403154502286

漏了一点：

由Redisson实现JDK的Timeout类，加回调完成的一个定时任务；当当前任务执行完后，又执行本身方法，创建一个延迟任务，也就实现了一个定时任务

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/849584.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

什么情况下要配置DNS服务

什么情况下要配置DNS服务

什么是DNS 一、DNS就是域名解析 我们上网的方式通常都由ip地址组成&#xff0c;但是为了有个规范&#xff0c;而且我们也不可能去记住那么多一串Ip数字&#xff0c;首先域名就会比ip好记很多&#xff0c;其次固定性&#xff0c;一旦服务器换了&#xff0c;只要重新绑定域名对…
阅读更多...
Mac - Node/Java 配置安装全流程

Mac - Node/Java 配置安装全流程

Mac - Node/Java 配置安装全流程 一. Git 安装二. Java 相关安装2.1 jenv 版本控制工具2.2 JDK1.8 和 JDK21的安装2.3 maven 安装 三. Node 相关安装3.1 nvm 版本控制工具3.2 Node 版本安装 一. Git 安装 1.我们首先安装一下Homebrew&#xff0c;这个工具很有用&#xff0c;能…
阅读更多...
LLM的基础模型7：Positional Encoding

LLM的基础模型7：Positional Encoding

大模型技术论文不断&#xff0c;每个月总会新增上千篇。本专栏精选论文重点解读&#xff0c;主题还是围绕着行业实践和工程量产。若在某个环节出现卡点&#xff0c;可以回到大模型必备腔调或者LLM背后的基础模型新阅读。而最新科技&#xff08;Mamba,xLSTM,KAN&#xff09;则提…
阅读更多...
单列集合.java

单列集合.java

单列集合 为了存储不同类型的多个对象&#xff0c;Java提供了一些特殊系列的类&#xff0c;这些类可以存储任意类型的对象&#xff0c;并且存储的长度可变&#xff0c;这些类统称为集合。可以简单的理解为一个长度可变&#xff0c;可以存储不同数据类型的动态数组。集合都位于j…
阅读更多...
【UML用户指南】-10-对高级结构建模-高级类

【UML用户指南】-10-对高级结构建模-高级类

目录 1、类目 2、高级类 3、可见性 4、实例范围和静态范围 5、抽象元素、叶子元素和多态性元素 6、多重性 7、属性 8、操作 9、模板类 10、标准元素 1、类目 类目 &#xff08;classifier&#xff09;是描述结构特征和行为特征的机制。类目包括类、关联、接口、数据类…
阅读更多...
常见硬件工程师面试题（一）

常见硬件工程师面试题（一）

大家好&#xff0c;我是山羊君Goat。 对于硬件工程师&#xff0c;学习的东西主要和电路硬件相关&#xff0c;所以在硬件工程师的面试中&#xff0c;对于经验是十分看重的&#xff0c;像PCB设计&#xff0c;电路设计原理&#xff0c;模拟电路&#xff0c;数字电路等等相关的知识…
阅读更多...
数据库设计步骤、E-R图转关系模式、E-R图的画法

数据库设计步骤、E-R图转关系模式、E-R图的画法

一、数据库设计步骤 ①需求分析阶段 准确了解与分析用户需求。 ②概念结构设计阶段 通过对用户需求进行综合、归纳与抽象&#xff0c;形成一个独立于具体数据库管理系统的概念模型。 ③逻辑结构设计阶段 将概念结构转换为某个数据库管理系统所支持的数据模型&am…
阅读更多...
“安全生产月”专题报道：AI智能监控技术如何助力安全生产

“安全生产月”专题报道：AI智能监控技术如何助力安全生产

今年6月是第23个全国“安全生产月”&#xff0c;6月16日为全国“安全宣传咨询日”。今年全国“安全生产月”活动主题为“人人讲安全、个个会应急——畅通生命通道”。近日&#xff0c;国务院安委会办公室、应急管理部对开展好2024年全国“安全生产月”活动作出安排部署。 随着科…
阅读更多...
SpringBoot的maven项目自定义打包结构

SpringBoot的maven项目自定义打包结构

文章目录 1. 背景2. 自定义打包结构3. 打包结果 1. 背景 加入新团队&#xff0c;发现项目打包后只有一个大大的jar包&#xff0c;每次修改了一个模块的代码&#xff0c;都要整个上传。效率低还浪费流量呢&#xff0c;哈哈。假如每次修改一个模块的一点代码&#xff0c;单独打包…
阅读更多...
RLHF（从人类反馈中进行强化学习）详解（三）

RLHF（从人类反馈中进行强化学习）详解（三）

在经过了前两节的内容学习之后&#xff0c;我们对于RLHF&#xff08;从人类反馈中进行强化学习&#xff09;有了比较深入的认知&#xff0c;并且初步了解了RLHF中偏好数据集的引入&#xff0c;奖励模型的设置以及baseLLM的训练过程。在本节的学习中&#xff0c;我们将深入LLM的…
阅读更多...
【ssh命令】ssh登录远程服务器

【ssh命令】ssh登录远程服务器

命令格式&#xff1a;ssh 用户名主机IP # 使用非默认端口: -p 端口号 ssh changxianrui192.168.100.100 -p 1022 # 使用默认端口 22 ssh changxianrui192.168.100.100 然后输入密码&#xff0c;就可以登录进去了。
阅读更多...
Java使用GDAL来解析KMZ及KML实战

Java使用GDAL来解析KMZ及KML实战

目录 前言 一、在GQIS中浏览数据 1、关于空间参考 2、属性表格 二、GDAL的相关驱动及解析实战 1、GDAL中的KMZ驱动 2、GDAL实际解析 三、数据解析成果 1、KML解析结果 2、KMZ文件入库 四、总结 前言 在前面的博客中讲过纯Java实现Google地图的KMZ和KML文件的解析&…
阅读更多...
问题：歌剧序曲是用什么曲式写成？ #学习方法#其他#经验分享

问题：歌剧序曲是用什么曲式写成？ #学习方法#其他#经验分享

问题&#xff1a;歌剧序曲是用什么曲式写成&#xff1f; A、贝多芬 B、海顿 C、肖邦 D、莫扎特 参考答案如图所示
阅读更多...
天诚公租房、人才公寓NB-IOT人脸物联网智能门锁解决方案

天诚公租房、人才公寓NB-IOT人脸物联网智能门锁解决方案

近期&#xff0c;全国已有超70城推出商品房“以旧换新”。各地商品房“以旧换新”主要采取国企收购、市场联动、税费补贴三种模式&#xff0c;二手房和新房市场交易活跃度均有提升。 一、人才公寓掀起建设浪潮 事实上&#xff0c;旧房被收购后将被纳入保障性租赁住房&#xf…
阅读更多...
【MySQL数据库】my.ini文件参数中文注释

【MySQL数据库】my.ini文件参数中文注释

&#x1f60e; 作者介绍&#xff1a;我是程序员洲洲&#xff0c;一个热爱写作的非著名程序员。CSDN全栈优质领域创作者、华为云博客社区云享专家、阿里云博客社区专家博主。 &#x1f913; 同时欢迎大家关注其他专栏&#xff0c;我将分享Web前后端开发、人工智能、机器学习、深…
阅读更多...
【调试笔记-20240606-Linux-为 OpenWrt 的 nginx 服务器添加Shell CGI 支持】

【调试笔记-20240606-Linux-为 OpenWrt 的 nginx 服务器添加Shell CGI 支持】

调试笔记-系列文章目录 调试笔记-20240606-Linux-为 OpenWrt 的 nginx 服务器添加Shell CGI 支持 文章目录 调试笔记-系列文章目录调试笔记-20240606-Linux-为 OpenWrt 的 nginx 服务器添加Shell CGI 支持 前言一、调试环境操作系统&#xff1a;Windows 10 专业版调试环境调试…
阅读更多...
片机+ISD1760智能家用语音唤醒系统设计

片机+ISD1760智能家用语音唤醒系统设计

在节奏过快的生活中，人们承受的精神和心理压力十分巨大,这就使得现代人都希望在当代繁忙而枯燥的工作和学习中能身心愉悦的生活。随着信息化发展水平的逐步提高，智能化系统越来越受到人们的重视。市场上普遍的闹钟只是一种到了人们设定的时间就被令人烦躁的声音而吵醒的机械化…
阅读更多...
【Redis】Redis主从复制（一）————主从搭建

【Redis】Redis主从复制（一）————主从搭建

目录 背景主从复制主从复制的工作流程主从复制的优点 配置 redis 主从结构复制配置文件&#xff0c;修改配置主从结构启动 redis 服务备注 查看复制状态 背景 单节点服务器的问题问题&#xff1a; 可用性&#xff1a;如果这个机器挂了&#xff0c;意味着服务就中断了.性能&am…
阅读更多...
重回1990短视频全集：成都鼎茂宏升文化传媒公司

重回1990短视频全集：成都鼎茂宏升文化传媒公司

重回1990短视频全集&#xff1a;时光之旅的温情回顾 在数字技术的浪潮中&#xff0c;短视频以其独特的魅力迅速崛起&#xff0c;成为我们记录生活、分享故事的新方式。而当我们回望过去&#xff0c;那些充满怀旧情怀的年份总是让人心生感慨。今天&#xff0c;就让我们一起踏上…
阅读更多...
JavaScrip轮播图

JavaScrip轮播图

前言 在网页设计中&#xff0c;轮播图&#xff08;Carousel&#xff09;已经成为一种常见的元素&#xff0c;用于展示一系列的图片或内容卡片。它们不仅能够吸引用户的注意力&#xff0c;还能节省空间&#xff0c;使得用户可以在有限的空间内获得更多的信息。今天&#xff0c;我…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023