Redisson 源码解析 - 分布式锁实现过程

news2024/9/28 1:26:51

一、Redisson 分布式锁源码解析

Redisson是架设在Redis基础上的一个Java驻内存数据网格。在基于NIO的Netty框架上，充分的利用了Redis键值数据库提供的一系列优势，在Java实用工具包中常用接口的基础上，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。

其中比较具体特色的就是 Redisson 对分布式锁的支持，不仅简化了分布式锁的应用过程还支持 Fair Lock、MultiLock、RedLock、ReadWriteLock 等锁的实现。本文就 Redisson 分布式锁的加锁和解锁过程的源码进行大致的解析。

下面是Redisson 源码地址：

https://github.com/redisson/redisson

如果对 Redisson 的使用还不了解的小伙伴可以先看下下面这篇文章：

https://xiaobichao.blog.csdn.net/article/details/112726748

Redisson 中的分布式锁在使用起来非常简便，例如：

public class TestLock {

    @Resource
    RedissonClient redissonClient;

    @Test
    public void test() {
        RLock lock = null;
        try {
            // 获取可重入锁
            lock = redissonClient.getLock("redislock");
            // 获取锁，如果获取不到会等待
            lock.lock();
            Thread.sleep(30000000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            if (lock != null) {
                // 释放锁
                lock.unlock();
            }
        }
    }

    @Test
    public void test1() {
        RLock lock = null;
        try {
            // 获取可重入锁
            lock = redissonClient.getLock("redislock");
            // 尝试获取锁，返回获取锁的状态
            Boolean isLock = lock.tryLock();
            Thread.sleep(30000000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            if (lock != null) {
                // 释放锁
                lock.unlock();
            }
        }
    }
}

下面分别从 lock、tryLock、unlock 、三个地方进行源码的解析。

二、lock 获取锁和看门狗机制

先看下 redissonClient.getLock 方法，它默认创建了一个 RedissonLock 对象，并将锁的key传递进来：

在这里插入图片描述

而 RedissonLock 对象又继承至RedissonBaseLock 类：

在这里插入图片描述

因此我们下面大多的源码分析都基于这两个类进行。

首先进到 RedissonLock 类下的 lock() 方法中：

在这里插入图片描述

这里主要又调用了 lock(long leaseTime, TimeUnit unit, boolean interruptibly) 方法，注意如果没有指定过期时间默认为 -1 ，下面看到 lock(long leaseTime, TimeUnit unit, boolean interruptibly) 方法中：

private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
    // 当前线程ID
    long threadId = Thread.currentThread().getId();
    // 尝试获取锁，如果已经有锁的话返回锁的剩余时间
    Long ttl = tryAcquire(-1, leaseTime, unit, threadId);
    // 获取锁成功
    if (ttl == null) {
        return;
    }
    // 如果获取锁失败，订阅当前线程，以便后续获取锁时得到通知。
    CompletableFuture<RedissonLockEntry> future = subscribe(threadId);
    //设置超时处理，当订阅的future完成时，触发超时处理。
    pubSub.timeout(future);
    //定义一个RedissonLockEntry对象，用于表示当前线程在分布式锁中的状态。
    RedissonLockEntry entry;
    if (interruptibly) {
        // 可中断
        entry = commandExecutor.getInterrupted(future);
    } else {
        entry = commandExecutor.get(future);
    }

    try {
        // 循环尝试获取锁
        while (true) {
            // 尝试获取锁
            ttl = tryAcquire(-1, leaseTime, unit, threadId);
            // 获取锁成功
            if (ttl == null) {
                break;
            }

            // 如果已经存在锁的过期时间大于等于0，需要等待通知
            if (ttl >= 0) {
                try {
                    // 通过Semaphore 的 tryAcquire方法等待指定时间
                    entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    if (interruptibly) {
                        throw e;
                    }
                    entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                }
            } else { //如果剩余时间小于0，就一直等待。
                if (interruptibly) {
                    entry.getLatch().acquire();
                } else {
                    entry.getLatch().acquireUninterruptibly();
                }
            }
        }
    } finally {
        // 无论加锁成功或失败，都取消订阅
        unsubscribe(entry, threadId);
    }
}

代码中加了注释，这里我总结下，首先调用 tryAcquire(long waitTime, long leaseTime, TimeUnit unit, long threadId) 方法尝试获取锁，如果锁存在的话则返回过期时间，为 null 的话表示获取锁成功。如果获取锁失败，则将自己加入到订阅中，然后开启一个死循环，在循环中再次尝试获取锁，如果还是没有获取到的话则使用 Semaphore 的 tryAcquire 方法阻塞当前线程，如果其他线程释放了锁，则这里继续循环再次尝试获取锁。

下面主要看下 tryAcquire(long waitTime, long leaseTime, TimeUnit unit, long threadId) 尝试获取锁的逻辑，看到该方法下：

在这里插入图片描述

tryAcquire 方法又调用了 tryAcquireAsync0 方法，然后又主要调用了 tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) 方法，下面主要看到这个方法下：

private RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
    RFuture<Long> ttlRemainingFuture;
    if (leaseTime > 0) {
        //如果指定了锁持有时间，则根据指定的时间设置 key 的过期时间
        ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    } else {
        // 没指定，默认锁持有 30s
        ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    }
    // 执行 lua 操作
    CompletionStage<Long> s = handleNoSync(threadId, ttlRemainingFuture);
    ttlRemainingFuture = new CompletableFutureWrapper<>(s);

    CompletionStage<Long> f = ttlRemainingFuture.thenApply(ttlRemaining -> {
        // 如果加锁成功
        if (ttlRemaining == null) {
            if (leaseTime > 0) {
                internalLockLeaseTime = unit.toMillis(leaseTime);
            } else {// 没指定的话
                // 启动看门狗，延长锁持有时间
                scheduleExpirationRenewal(threadId);
            }
        }
        // 返回锁的过期时间
        return ttlRemaining;
    });
    return new CompletableFutureWrapper<>(f);
}

这里其中 tryLockInnerAsync 方法主要是指定了 Lua 脚本，主要注意的是如果没有指定了锁的过期则默认为 30s 的时间，然后在 Lua 脚本执行后，同样的判断，如果获取到锁的话并且没有指定锁的过期时间则开启看门狗机制，为锁延长时间续命的操作。

这里先看下核心操作 tryLockInnerAsync 方法中 Lua 脚本:

<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    // lua 脚本
    return evalWriteSyncedAsync(getRawName(), LongCodec.INSTANCE, command,
            // 如果锁不存在，或者哈希表中锁对应的线程ID存在的话
            "if ((redis.call('exists', KEYS[1]) == 0) " +
                        "or (redis.call('hexists', KEYS[1], ARGV[2]) == 1)) then " +
                    // 对hash中的内容值 +1
                    "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                    // 设置过期时间
                    "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                    //表示脚本执行成功，且不需要返回特定的值。
                    "return nil; " +
                "end; " +
                    // 如果if条件不满足，返回剩余过期时间（以毫秒为单位）
                "return redis.call('pttl', KEYS[1]);",
            // 对应这 lua 脚本中的参数，第一个参数就是 KEYS[1]，以此类推
            Collections.singletonList(getRawName()), unit.toMillis(leaseTime), getLockName(threadId));
}

这里主要利于 Lua 的原子性将整个判断操作过程给原子化了，其中这里锁的结构是以 hash 的形式存放的，key为锁的名称，hash中的key为线程ID（UUID+线程ID的形式），因为分布式情况下线程ID也有可能重复，value为数字表示锁重入的次数， lua 脚本如果执行加锁逻辑成功则返回 null，否则返回锁的过期时间，也就对应前面获取锁的时候判断的依据。

下面回到上面的 tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) 方法中，在 ttlRemainingFuture.thenApply 中如果获取锁成功，并且没有指定锁的过期时间则会开启看门狗机制为锁进行续命操作，主要调用的是 scheduleExpirationRenewal(long threadId) 方法，下面看到该方法下的逻辑：

protected void scheduleExpirationRenewal(long threadId) {
    ExpirationEntry entry = new ExpirationEntry();
    // 加入看门狗记录中
    ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry);
    // 如果已经存在
    if (oldEntry != null) {
        // 重新指定线程ID
        oldEntry.addThreadId(threadId);
    } else { // 如果不存在的话就开启看门狗
        entry.addThreadId(threadId);
        try {
            // 启动看门狗
            renewExpiration();
        } finally {
            // 如果线程已经终止，则关闭看门狗
            if (Thread.currentThread().isInterrupted()) {
                cancelExpirationRenewal(threadId);
            }
        }
    }
}

主要的逻辑在 renewExpiration() 方法下，继续看到该方法中：

private void renewExpiration() {
    // 获取当前信息
    ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
    if (ee == null) {
        return;
    }
    // 执行计时任务
    Timeout task = getServiceManager().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout timeout) throws Exception {
            //再次获取信息
            ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
            if (ent == null) {
                return;
            }
            // 获取线程ID
            Long threadId = ent.getFirstThreadId();
            if (threadId == null) {
                return;
            }
            // 延长锁的过期时间
            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;
                }
                
                if (res) { // 如果执行成功
                    // 递归继续执行
                    renewExpiration();
                } else { // 执行失败
                    // 关闭看门狗
                    cancelExpirationRenewal(null);
                }
            });
        }
    }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
    
    ee.setTimeout(task);
}

这里主要通过递归延时任务的方式实现循环执行的效果，其中延时的时间为 internalLockLeaseTime 的三分之一，也就是默认 10s 触发一次，在任务中主要通过 renewExpirationAsync(long threadId) 方法，对锁进行了延时续命操作，看到该方法中：

protected CompletionStage<Boolean> renewExpirationAsync(long threadId) {
    // lua 脚本
    return evalWriteSyncedAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
            // 如果锁和线程ID存在
            "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                    // 重置过期时间
                    "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                    // 成功返回 1
                    "return 1; " +
                    "end; " +
                    // 失败返回 0
                    "return 0;",
            // lua 脚本中对应的参数
            Collections.singletonList(getRawName()),
            internalLockLeaseTime, getLockName(threadId));
}

这里还是依靠 Lua 脚本的方式，如果锁存在的话就重置过期时间，达到续命的效果。

三、tryLock 获取锁

tryLock和lock是两种获取分布式锁的方法，它们的主要区别在于获取锁的方式和阻塞行为。tryLock默认是一种非阻塞的获取锁的方法，也可以通过设置 waitTime 变成阻塞的。而lock默认就是一种阻塞的获取锁的方法。

他们俩的最终处理逻辑都是一样的，只不过默认的 tryLock 没有订阅阻塞的操作。

下面看下默认的 tryLock 的操作 ，进到 RedissonLock 下的 tryLock() 中：

在这里插入图片描述

再进入 tryLockAsync() 方法中：

在这里插入图片描述

这里调用了 tryLockAsync 方法，并将当前线程的ID传递了进来，继续看到 tryLockAsync 方法中：

在这里插入图片描述

在看到 tryAcquireOnceAsync 方法中，注意这里的等待时间和上面 lock() 默认一样，是 -1 ：

private RFuture<Boolean> tryAcquireOnceAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
    CompletionStage<Boolean> acquiredFuture;
    if (leaseTime > 0) {
        //如果指定了锁持有时间，则根据指定的时间设置 key 的过期时间
        acquiredFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_NULL_BOOLEAN);
    } else {
        // 没指定，默认锁持有 30s
        acquiredFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_NULL_BOOLEAN);
    }
    // 执行 lua 操作
    acquiredFuture = handleNoSync(threadId, acquiredFuture);

    CompletionStage<Boolean> f = acquiredFuture.thenApply(acquired -> {
        // 如果加锁成功
        if (acquired) {
            // 如果指定了锁持有时间
            if (leaseTime > 0) {
                internalLockLeaseTime = unit.toMillis(leaseTime);
            } else { // 没指定的话，
                // 看门狗，延长锁持有时间
                scheduleExpirationRenewal(threadId);
            }
        }
        // 返回获取锁的状态
        return acquired;
    });
    return new CompletableFutureWrapper<>(f);
}

这里的逻辑相比于前面 lock() 的逻辑就差不多了，只不过缺少了订阅和阻塞等待重试的操作，再下面的操作和lock() 的逻辑是一致的。

四、unlock 解锁和关闭看门狗

解锁的逻辑看到 RedissonBaseLock 下的 unlock() 方法中：

在这里插入图片描述

继续看到 unlockAsync 方法中：

在这里插入图片描述

主要逻辑在 unlockAsync0 方法中：

private RFuture<Void> unlockAsync0(long threadId) {
    // 解锁
    CompletionStage<Boolean> future = unlockInnerAsync(threadId);
    CompletionStage<Void> f = future.handle((opStatus, e) -> {
        // 关闭看门狗
        cancelExpirationRenewal(threadId);

        if (e != null) { // 如果执行有异常
            if (e instanceof CompletionException) {
                throw (CompletionException) e;
            }
            throw new CompletionException(e);
        }
        if (opStatus == null) { // 如果结果为空的话，表示锁不存在
            IllegalMonitorStateException cause = new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: "
                    + id + " thread-id: " + threadId);
            throw new CompletionException(cause);
        }

        return null;
    });

    return new CompletableFutureWrapper<>(f);
}

主要做了两件事，解锁和关闭看门狗，先看下 unlockInnerAsync(long threadId) 方法解锁的过程：

protected final RFuture<Boolean> unlockInnerAsync(long threadId) {
    String id = getServiceManager().generateId();
    MasterSlaveServersConfig config = getServiceManager().getConfig();
    int timeout = (config.getTimeout() + config.getRetryInterval()) * config.getRetryAttempts();
    timeout = Math.max(timeout, 1);
    // 解锁
    RFuture<Boolean> r = unlockInnerAsync(threadId, id, timeout);
    CompletionStage<Boolean> ff = r.thenApply(v -> {
        CommandAsyncExecutor ce = commandExecutor;
        if (ce instanceof CommandBatchService) {
            ce = new CommandBatchService(commandExecutor);
        }
        ce.writeAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.DEL, getUnlockLatchName(id));
        if (ce instanceof CommandBatchService) {
            ((CommandBatchService) ce).executeAsync();
        }
        // 释放锁的结果
        return v;
    });
    return new CompletableFutureWrapper<>(ff);
}

这里的重点主要关注 unlockInnerAsync 方法，通过使用 Lua 脚本进行解锁的操作：

protected RFuture<Boolean> unlockInnerAsync(long threadId, String requestId, int timeout) {
    // lua 脚本
    return evalWriteSyncedAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                          // 从Redis中获取锁的状态。
                          "local val = redis.call('get', KEYS[3]); " +
                                  //如果不是false
                                "if val ~= false then " +
                                  //将其转换为数字并返回，也就是 true 返回 1
                                    "return tonumber(val);" +
                                "end; " +
                                // 如果哈希表锁中不存在线程ID，表示锁已经被释放，返回nil。
                                "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
                                    "return nil;" +
                                "end; " +
                                  //对锁中的线程ID的值减1，并将结果存储在 counter 变量中。这是一个计数器的操作。
                                "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
                                  //如果计数器值大于0，表示锁仍然被持有。
                                "if (counter > 0) then " +
                                    // 更新哈希表锁的过期时间。
                                    "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                                  // 设置键锁的状态值为0，并设置过期时间，表示锁仍然被持有。
                                    "redis.call('set', KEYS[3], 0, 'px', ARGV[5]); " +
                                  //返回0，表示锁仍然被持有
                                    "return 0; " +
                                "else " + //如果计数器值不大于0，表示锁即将被释放。
                                    //删除锁
                                    "redis.call('del', KEYS[1]); " +
                                    "redis.call(ARGV[4], KEYS[2], ARGV[1]); " +
                                    // 设置键锁的状态值为1，并设置过期时间，表示锁已经被释放。
                                    "redis.call('set', KEYS[3], 1, 'px', ARGV[5]); " +
                                    //返回1，表示锁已经被释放
                                    "return 1; " +
                                "end; ",
                            Arrays.asList(getRawName(), getChannelName(), getUnlockLatchName(requestId)),
                            LockPubSub.UNLOCK_MESSAGE, internalLockLeaseTime,
                            getLockName(threadId), getSubscribeService().getPublishCommand(), timeout);
}

需要注意的是，在 Lua 脚本中，如果锁还存在的话，就对 hash 中的 value 减一，如果此时 value 结果还大于 0 的话，则表示这是重入锁的场景，此时不能直接删除锁，而是对重入的次数进行减一，并且要重置过期时间。

下面再回到 unlockAsync0(long threadId) 方法中，释放锁通过 Lua 脚本实现了，下面看下 cancelExpirationRenewal(Long threadId) 关闭看门狗的操作：

protected void cancelExpirationRenewal(Long threadId) {
    // 从记录中获取信息
    ExpirationEntry task = EXPIRATION_RENEWAL_MAP.get(getEntryName());
    if (task == null) {
        return;
    }
    
    if (threadId != null) {
        // 移除线程ID
        task.removeThreadId(threadId);
    }

    if (threadId == null || task.hasNoThreads()) {
        // 关闭计时任务
        Timeout timeout = task.getTimeout();
        if (timeout != null) {
            timeout.cancel();
        }
        // 从缓存记录中删除
        EXPIRATION_RENEWAL_MAP.remove(getEntryName());
    }
}

这里就比较好理解了，停止计时任务，从缓存记录中移除。

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

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

相关文章

查看网络信息的原初 ifconfig

查看网络信息的原初 ifconfig

文章目录 查看网络信息的原初 ifconfig默认无参数使用-s显示短列表配置IP地址修改MTU启动关闭网卡更多信息 查看网络信息的原初 ifconfig Linux ifconfig命令用于显示或设置网络设备&#xff0c;在调试或调优的时间经常使用。 官方定义为&#xff1a; ifconfig - configure a…
阅读更多...
19道ElasticSearch面试题（很全）

19道ElasticSearch面试题（很全）

1. elasticsearch的一些调优手段 1、设计阶段调优 &#xff08;1&#xff09;根据业务增量需求&#xff0c;采取基于日期模板创建索引&#xff0c;通过 roll over API 滚动索引&#xff1b; &#xff08;2&#xff09;使用别名进行索引管理&#xff1b; &#xff08;3&…
阅读更多...
linux中最常用的网络命令

linux中最常用的网络命令

文章目录 linux中最常用的网络命令查看网络信息的原初 ifconfig默认无参数使用-s显示短列表配置IP地址修改MTU启动关闭网卡 网络中不中&#xff0c;先看ping行不行语法不加任何参数发送指定数目设定发送时间间隔组合使用 Linux ip命令显示网络设备设置IP地址启动关闭网卡统计方…
阅读更多...
如何使用 CMake 生成一个静态库

如何使用 CMake 生成一个静态库

文章目录 tutorial_3/CMakeLists.txttutorial_3/src/CMakeLists.txtcmake_tutorial/tutorial_3/src/hello.cpptutorial_3/src/hello.h根目录的 CMakeLists.txtsrc 目录的 CMakeLists.txthello.cpp 和 hello.h构建过程总结 tutorial_3/CMakeLists.txt cmake_minimum_required(V…
阅读更多...
【AI视野·今日Robot 机器人论文速览 第六十七期】Mon, 1 Jan 2024

【AI视野·今日Robot 机器人论文速览 第六十七期】Mon, 1 Jan 2024

AI视野今日CS.Robotics 机器人学论文速览 Mon, 1 Jan 2024 Totally 16 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Robotics Papers MURP: Multi-Agent Ultra-Wideband Relative Pose Estimation with Constrained Communications in 3D Environments Authors A…
阅读更多...
leetcode算法题之递归--综合练习(一)

leetcode算法题之递归--综合练习(一)

此专题对我们之前所学的关于递归的内容进行一个整合&#xff0c;大家可以自行练习&#xff0c;提升自己的编码能力。 本章目录 1.找出所有子集的异或总和在求和2.全排列II3.电话号码的字母组合4.括号生成5.组合6.目标和7.组合总和8.字母大小写全排列9.优美的排列 1.找出所有子…
阅读更多...
【信息论与编码】习题-判断题-第二部分

【信息论与编码】习题-判断题-第二部分

目录 判断题 第二部分24. 信道矩阵 代表的信道的信道容量C125. 信源熵具有严格的下凸性。26. 率失真函数对允许的平均失真度具有上凸性。27. 信道编码定理是一个理想编码的存在性定理&#xff0c;即&#xff1a;信道无失真传递信息的条件是信息率小于信道容量 。28. 信道的输出…
阅读更多...
在Ubuntu22.04上安装WordPress

在Ubuntu22.04上安装WordPress

WordPress是当今最简单、最强大的博客和网站建设工具。据统计全球大约有40% 以上网站是使用WordPress&#xff0c;这是个巨大的数字也侧面证明了WordPress的强大和普遍性。因此&#xff0c;如果你正在寻找一款高效、实用、可靠的CMS工具来构建网站&#xff0c;那么WordPress无疑…
阅读更多...
【强化学习的数学原理-赵世钰】课程笔记（六）随机近似与随机梯度下降

【强化学习的数学原理-赵世钰】课程笔记（六）随机近似与随机梯度下降

目录 一.内容概述 二.激励性实例&#xff08;Motivating examples&#xff09; 三.Robbins-Monro 算法&#xff08;RM 算法&#xff09;&#xff1a; 1.算法描述 2.说明性实例&#xff08;llustrative examples&#xff09; 3.收敛性分析&#xff08;Convergence analysi…
阅读更多...
MySQL数据库主从复制和读写分离

MySQL数据库主从复制和读写分离

目录 一、MySQL主从复制和读写分离理论 &#xff08;一&#xff09;读写分离 1.什么是读写分离 2.为什么要读写分离 3.什么时候要读写分离 4.读写分离原理 5.常见MySQL 读写分离 &#xff08;1&#xff09;基于程序代码内部实现 &#xff08;2&#xff09;基于中间代理…
阅读更多...
大学物理实验绪论——测量与误差

大学物理实验绪论——测量与误差

测量 测量的定义 以确定被测量对象量值为目的的操作称作测量。 测量的过程就是把被测物理量与选作计量单位的同类物理量进行比较的过程。 测量值的组成 物理量的测量值由数值和单位两部分组成。 测量的分类 测量分直接测量与间接测量。 等精度测量&#xff1a;对某一物理量多…
阅读更多...
基于Java SSM框架实现实现机房预约系统项目【项目源码+论文说明】计算机毕业设计

基于Java SSM框架实现实现机房预约系统项目【项目源码+论文说明】计算机毕业设计

基于java的SSM框架实现机房预约系统演示 摘要 21世纪的今天&#xff0c;随着社会的不断发展与进步&#xff0c;人们对于信息科学化的认识&#xff0c;已由低层次向高层次发展&#xff0c;由原来的感性认识向理性认识提高&#xff0c;管理工作的重要性已逐渐被人们所认识&#…
阅读更多...
YOLOv8融合改进 更换检测头为Detect_DyHead同时添加C2f-EMSC和C2f-EMSCP模块

YOLOv8融合改进 更换检测头为Detect_DyHead同时添加C2f-EMSC和C2f-EMSCP模块

一、Detect_DyHead检测头和C2f-EMSC&#xff0c;C2f-EMSCP模块 详细介绍和代码在往期的博客里&#xff1a; Detect_DyHead&#xff1a; &#xff08;YOLOv8改进检测头Detect为Detect_Dyhead-CSDN博客&#xff09; C2f-EMSC和C2f-EMSCP&#xff1a; &#xff08;YOLOv8改进…
阅读更多...
【SpringCloud Alibaba】Nacos服务管理与Feign负载均衡

【SpringCloud Alibaba】Nacos服务管理与Feign负载均衡

目录 一、微服务搭建 1.1 服务提供者与服务消费者 1.2 依赖关系 二、服务注册与负载均衡使用 2.1 Nacos 实现服务的注册与发现 2.2 Loadbalancer负载均衡、Feign声明式服务调用 2.3 示例综合实现 2.3.1 服务注册与发现测试 2.3.2 负载均衡测试 一、微服务搭建 1.1 服…
阅读更多...
Gen-AI 的知识图和分析（无需图数据库）

Gen-AI 的知识图和分析（无需图数据库）

如今&#xff0c;图表比以往任何时候都更加相关和有用。由于目前正在发生的人工智能革命&#xff0c;工程师们正在考虑围绕 Gen-AI 的机会&#xff0c;利用具有动态提示、数据基础和屏蔽功能的开放 Gen-AI 解决方案&#xff0c;这进一步促使他们思考知识图谱等有效的解决方案。…
阅读更多...
【动态规划】【滑动窗口】C++算法：100154 执行操作后的最大分割数量

【动态规划】【滑动窗口】C++算法：100154 执行操作后的最大分割数量

作者推荐 【动态规划】【字符串】扰乱字符串 本文涉及的基础知识点 C算法&#xff1a;滑动窗口总结 动态规划 LeetCode100154 执行操作后的最大分割数量 给你一个下标从 0 开始的字符串 s 和一个整数 k。 你需要执行以下分割操作&#xff0c;直到字符串 s 变为 空&#xf…
阅读更多...
【SpringCloud】之配置中心（进阶使用）

【SpringCloud】之配置中心（进阶使用）

&#x1f389;&#x1f389;欢迎来到我的CSDN主页&#xff01;&#x1f389;&#x1f389; &#x1f3c5;我是君易--鑨&#xff0c;一个在CSDN分享笔记的博主。&#x1f4da;&#x1f4da; &#x1f31f;推荐给大家我的博客专栏《SpringCloud开发之远程消费》。&#x1f3af;&a…
阅读更多...
C++ queue

C++ queue

目录 一、介绍 二、queue使用 三、模拟实现 四、优先级队列 五、priority_queue使用 OJ题&#xff1a;215. 数组中的第K个最大元素 快速排序 优先级队列 TOPK 六、模拟实现priority_queue 1、仿函数 2、优先级队列类 3、测试函数 一、介绍 1、队列是一种容器适配器…
阅读更多...
阿里云服务器固定带宽实际下载速度表，不只是3M固定带宽

阿里云服务器固定带宽实际下载速度表，不只是3M固定带宽

阿里云服务器公网带宽上传和下载速度对照表&#xff0c;1M带宽下载速度是128KB/秒&#xff0c;为什么不是1M/秒&#xff1f;阿里云服务器网aliyunfuwuqi.com分享阿里云服务器带宽1M、2M、3M、5M、6M、10M、20M、30M、50M、100M及200M等公网带宽下载速度对照表&#xff0c;附带宽…
阅读更多...
VMware Workstation——修改虚拟机配置和设置网络

VMware Workstation——修改虚拟机配置和设置网络

目录 一、修改配置 1、点击需要修改配置的虚拟机&#xff0c;然后点击编辑虚拟机配置 2、修改内存、CPU、硬盘配置 二、设置网络 1、从虚拟机配置中进入到网络适配器设置 2、选择网络连接模式 一、修改配置 1、点击需要修改配置的虚拟机&#xff0c;然后点击编辑虚拟机配…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023