分布式锁实现方案-基于Redis实现的分布式锁

目录

一、基于Lua+看门狗实现

1.1 缓存实体

1.2 延迟队列存储实体

1.3 分布式锁RedisDistributedLockWithDog

1.4 看门狗线程续期

1.5 测试类

1.6 测试结果

1.7 总结

二、RedLock分布式锁

2.1 Redlock分布式锁简介

2.2 RedLock测试例子

2.3 RedLock 加锁核心源码分析

2.4 RedLock的问题与解决方案

2.4.1 问题

2.4.1.1 时钟偏移

2.4.1.2 单点故障

2.4.1.3 性能瓶颈

2.4.2 解决方案

2.4.2.1 引入重试机制

2.4.2.2 时钟校准

2.4.2.3 引入冗余节点

2.5 总结

一、基于Lua+看门狗实现

1.1 缓存实体

package com.ningzhaosheng.distributelock.redis;/*** @author ningzhaosheng* @date 2024/4/18 15:37:16* @description 类说明：Redis的key-value结构*/
public class LockItem {private final String key;private final String value;public LockItem(String key, String value) {this.key = key;this.value = value;}public String getKey() {return key;}public String getValue() {return value;}
}

1.2 延迟队列存储实体

package com.ningzhaosheng.distributelock.redis;import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;/*** @author ningzhaosheng* @date 2024/4/18 15:35:43* @description 说明：存放到延迟队列的元素，比标准的delay的实现要提前一点时间*/
public class ItemVo<T> implements Delayed {/*到期时刻  20:00:35,234*/private long activeTime;/*业务数据，泛型*/private T data;/*传入的数值代表过期的时长，单位毫秒，需要乘1000转换为毫秒和到期时间* 同时提前100毫秒续期,具体的时间可以自己决定*/public ItemVo(long expirationTime, T data) {super();this.activeTime = expirationTime + System.currentTimeMillis() - 100;this.data = data;}public long getActiveTime() {return activeTime;}public T getData() {return data;}/*** 返回元素到激活时刻的剩余时长*/public long getDelay(TimeUnit unit) {long d = unit.convert(this.activeTime- System.currentTimeMillis(), unit);return d;}/*** 按剩余时长排序*/public int compareTo(Delayed o) {long d = (getDelay(TimeUnit.MILLISECONDS)- o.getDelay(TimeUnit.MILLISECONDS));if (d == 0) {return 0;} else {if (d < 0) {return -1;} else {return 1;}}}
}

1.3 分布式锁RedisDistributedLockWithDog

package com.ningzhaosheng.distributelock.redis;import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;/*** @author ningzhaosheng* @date 2024/4/18 15:38:07* @description Redis分布式锁，附带看门狗线程的实现:加锁，保持锁1秒*/
public class RedisDistributedLockWithDog implements Lock {private final static int LOCK_TIME = 1 * 1000;private final static String RS_DISTLOCK_NS = "tdln2:";/*if redis.call('get',KEYS[1])==ARGV[1] thenreturn redis.call('del', KEYS[1])else return 0 end*/private final static String RELEASE_LOCK_LUA ="if redis.call('get',KEYS[1])==ARGV[1] then\n" +"        return redis.call('del', KEYS[1])\n" +"    else return 0 end";/*还有并发问题，考虑ThreadLocal*/private ThreadLocal<String> lockerId = new ThreadLocal<>();private Thread ownerThread;private String lockName = "lock";private Jedis jedis = null;// 看门狗线程private Thread expireThread;private WatchDogThead watchDogThead;public String getLockName() {return lockName;}public void setLockName(String lockName) {this.lockName = lockName;}public Thread getOwnerThread() {return ownerThread;}public void setOwnerThread(Thread ownerThread) {this.ownerThread = ownerThread;}public RedisDistributedLockWithDog(Jedis jedis) {this.jedis = jedis;watchDogThead = new WatchDogThead(jedis);closeExpireThread();}@Overridepublic void lock() {while (!tryLock()) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}@Overridepublic void lockInterruptibly() throws InterruptedException {throw new UnsupportedOperationException("不支持可中断获取锁！");}@Overridepublic boolean tryLock() {Thread t = Thread.currentThread();/*说明本线程正在持有锁*/if (ownerThread == t) {return true;} else if (ownerThread != null) {/*说明本进程中有别的线程正在持有分布式锁*/return false;}try {/*每一个锁的持有人都分配一个唯一的id，也可采用snowflake算法*/String id = UUID.randomUUID().toString();SetParams params = new SetParams();params.px(LOCK_TIME); //加锁时间1sparams.nx();synchronized (this) {if ((ownerThread == null) &&"OK".equals(jedis.set(RS_DISTLOCK_NS + lockName, id, params))) {lockerId.set(id);setOwnerThread(t);if (expireThread == null) {//看门狗线程启动expireThread = new Thread(watchDogThead, "expireThread");expireThread.setDaemon(true);expireThread.start();}//往延迟阻塞队列中加入元素（让看门口可以在过期之前一点点的时间去做锁的续期）watchDogThead.addDelayDog(new ItemVo<>((int) LOCK_TIME, new LockItem(lockName, id)));System.out.println(Thread.currentThread().getName() + "已获得锁----");return true;} else {System.out.println(Thread.currentThread().getName() + "无法获得锁----");return false;}}} catch (Exception e) {throw new RuntimeException("分布式锁尝试加锁失败！", e);}}@Overridepublic boolean tryLock(long time, TimeUnit unit) throws InterruptedException {throw new UnsupportedOperationException("不支持等待尝试获取锁！");}@Overridepublic void unlock() {Thread t = Thread.currentThread();if (ownerThread != t) {throw new RuntimeException("试图释放无所有权的锁！");}try {Long result = (Long) jedis.eval(RELEASE_LOCK_LUA,Arrays.asList(RS_DISTLOCK_NS + lockName),Arrays.asList(lockerId.get()));System.out.println(result);if (result.longValue() != 0L) {System.out.println(t.getName()+" Redis上的锁已释放！");} else {System.out.println(t.getName()+" Redis上的锁释放失败！");}} catch (Exception e) {throw new RuntimeException("释放锁失败！", e);} finally {lockerId.remove();setOwnerThread(null);// 关闭看门狗closeExpireThread();// 关闭jedis连接jedis.close();}}@Overridepublic Condition newCondition() {throw new UnsupportedOperationException("不支持等待通知操作！");}/*** 中断看门狗线程*/public void closeExpireThread() {if (null != expireThread) {expireThread.interrupt();}}
}

1.4 看门狗线程续期

package com.ningzhaosheng.distributelock.redis;import redis.clients.jedis.Jedis;import java.util.Arrays;
import java.util.concurrent.DelayQueue;/*** @author ningzhaosheng* @date 2024/4/18 16:18:10* @description 看门狗线程*/
public class WatchDogThead implements Runnable {private final static int LOCK_TIME = 1 * 1000;private final static String LOCK_TIME_STR = String.valueOf(LOCK_TIME);private final static String RS_DISTLOCK_NS = "tdln2:";/*看门狗线程*/private Thread expireThread;//通过delayDog 避免无谓的轮询，减少看门狗线程的轮序次数   阻塞延迟队列   刷1  没有刷2private static DelayQueue<ItemVo<LockItem>> delayDog = new DelayQueue<>();//续锁逻辑：判断是持有锁的线程才能续锁private final static String DELAY_LOCK_LUA ="if redis.call('get',KEYS[1])==ARGV[1] then\n" +"        return redis.call('pexpire', KEYS[1],ARGV[2])\n" +"    else return 0 end";// 客户端Jedis jedis = null;public WatchDogThead(Jedis jedis) {this.jedis = jedis;}public void addDelayDog(ItemVo<LockItem> itemItemVo) {delayDog.add(itemItemVo);}@Overridepublic void run() {System.out.println("看门狗线程已启动......");while (!Thread.currentThread().isInterrupted()) {try {LockItem lockItem = delayDog.take().getData();//只有元素快到期了才能take到  0.9stry {Long result = (Long) jedis.eval(DELAY_LOCK_LUA,Arrays.asList(RS_DISTLOCK_NS + lockItem.getKey()),Arrays.asList(lockItem.getValue(), LOCK_TIME_STR));if (result.longValue() == 0L) {System.out.println("Redis上的锁已释放，无需续期！");} else {delayDog.add(new ItemVo<>((int) LOCK_TIME,new LockItem(lockItem.getKey(), lockItem.getValue())));System.out.println("Redis上的锁已续期:" + LOCK_TIME);}} catch (Exception e) {throw new RuntimeException("锁续期失败！", e);}} catch (InterruptedException e) {System.out.println("看门狗线程被中断");break;}}System.out.println("看门狗线程准备关闭......");}}

1.5 测试类

package com.ningzhaosheng.distributelock.redis;import com.ningzhaosheng.distributelock.zookeeper.OrderServiceHandle;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisSentinelPool;import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;/*** @author ningzhaosheng* @date 2024/4/19 8:07:38* @description redis看门狗分布式锁测试类*/
public class TestRedisDistributedLockWithDog {private static final String REDIS_ADDRESS1 = "192.168.31.167:26379";private static final String REDIS_ADDRESS2 = "192.168.31.215:26379";private static final String REDIS_ADDRESS3 = "192.168.31.154:26379";public static void main(String[] args) {Set<String> sentinels = new HashSet<String>();sentinels.add(REDIS_ADDRESS1);sentinels.add(REDIS_ADDRESS2);sentinels.add(REDIS_ADDRESS3);// Redis主服务器的名字String masterName = "mymaster";// Redis服务器的密码String password = "xiaoning";try {int NUM = 10;CountDownLatch cdl = new CountDownLatch(NUM);for (int i = 1; i <= NUM; i++) {// 创建JedisSentinelPoolJedisSentinelPool pool = new JedisSentinelPool(masterName, sentinels, password);// 从池中获取Jedis实例Jedis jedis  = pool.getResource();// 按照线程数迭代实例化线程Lock lock = new RedisDistributedLockWithDog(jedis);new Thread(new OrderServiceHandle(cdl, lock)).start();// 创建一个线程，倒计数器减1cdl.countDown();pool.close();}} catch (Exception e) {e.printStackTrace();}}
}

1.6 测试结果

1.7 总结

以上基于看门狗机制实现的Redis锁在对高并发要求不高的场景下可以使用，但是其实它还是有问题的，在主从架构模式下，可能会导致两个线程同时获取到锁得问题出现：

  •  线程A从主redis中请求一个分布式锁，获取锁成功；
  • 从redis准备从主redis同步锁相关信息时，主redis突然发生宕机，锁丢失了；
  • 触发从redis升级为新的主redis；线程B从继任主redis的从redis上申请一个分布式锁，此时也能获取锁成功；
  • 导致，同一个分布式锁，被两个客户端同时获取，没有保证独占使用特性；

当对高可用有要求的场景，这种方式就不合适了，那么在高并发、高可靠场景下，我们该如何基于Redis 实现分布式锁呢？得接着往下看！

二、RedLock分布式锁

2.1 Redlock分布式锁简介

Redlock是由Redis的作者Salvatore Sanfilippo提出的一种分布式锁算法，它利用Redis的特性来实现分布式锁。Redlock算法的核心思想是通过在多个Redis实例上创建相同的分布式锁，以保证锁的可靠性。Redlock算法通过在Redis中设置一个唯一的键值对来表示锁的存在，其他线程或进程需要通过竞争来获取这个锁。

官网wiki：8. 分布式锁和同步器 · redisson/redisson Wiki · GitHub

2.2 RedLock测试例子

package com.ningzhaosheng.distributelock.redis.redisson;import org.redisson.Redisson;
import org.redisson.RedissonRedLock;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;/*** @author ningzhaosheng* @date 2024/6/22 15:57:17* @description*/
public class TestRedLockByRedisson {public static void main(String[] args) {String RS_DISTLOCK_NS = "tdln2:";String lockName = "lock";Config config = new Config();config.useSentinelServers().addSentinelAddress("redis://192.168.31.215:26379","redis://192.168.31.167:26379","redis://192.168.31.154:26379").setMasterName("mymaster").setPassword("xiaoning");RedissonClient redisson = Redisson.create(config);try {for (int i = 1; i <= 10; i++) {// 生成8位随机数Random random = new Random();// 创建RedLockRLock rLock = redisson.getLock(RS_DISTLOCK_NS+lockName+ random.nextInt(99999999));RedissonRedLock rdLock = new RedissonRedLock(rLock);boolean islock = rdLock.tryLock(500,3000,TimeUnit.MILLISECONDS);if(islock){System.out.println("执行业务啦！======================");}else{System.out.println("获取锁失败！======================");}rdLock.unlock();}} catch (Exception e) {e.printStackTrace();}redisson.shutdown();}
}

测试结果：

2.3 RedLock 加锁核心源码分析

这里我就以tryLock()为例，分析下RedLock 的源码：

 public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {long newLeaseTime = -1L;if (leaseTime != -1L) {if (waitTime == -1L) {newLeaseTime = unit.toMillis(leaseTime);} else {newLeaseTime = unit.toMillis(waitTime) * 2L;}}long time = System.currentTimeMillis();long remainTime = -1L;if (waitTime != -1L) {remainTime = unit.toMillis(waitTime);}long lockWaitTime = this.calcLockWaitTime(remainTime);// 允许加锁失败的节点数量（N-(N/2+1)）int failedLocksLimit = this.failedLocksLimit();List<RLock> acquiredLocks = new ArrayList(this.locks.size());ListIterator iterator = this.locks.listIterator();// 遍历所有节点，通过EVAL命令执行lua脚本加锁while(iterator.hasNext()) {// 迭代获取Redis实例RLock lock = (RLock)iterator.next();boolean lockAcquired;// 尝试加锁，调用lock.tryLock()方法try {if (waitTime == -1L && leaseTime == -1L) {lockAcquired = lock.tryLock();} else {long awaitTime = Math.min(lockWaitTime, remainTime);// 尝试加锁lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);}} catch (RedisResponseTimeoutException var21) {// 如果抛出异常，为了防止加锁成功，但是响应失败，需要解锁所有节点，同时返回加锁失败状态this.unlockInner(Arrays.asList(lock));lockAcquired = false;} catch (Exception var22) {lockAcquired = false;}if (lockAcquired) {// 如果加锁成功，把锁加到以获得锁集合中acquiredLocks.add(lock);} else {//计算已经申请锁失败的节点是否已经到达允许加锁失败节点个数限制 (即：N-(N/2+1))；如果已经到达，就认定最终申请锁失败，则没有必要继续从后面的节点申请了因为 Redlock 算法要求至少N/2+1 个节点都加锁成功，才算最终的锁申请成功if (this.locks.size() - acquiredLocks.size() == this.failedLocksLimit()) {break;}if (failedLocksLimit == 0) {this.unlockInner(acquiredLocks);if (waitTime == -1L) {return false;}failedLocksLimit = this.failedLocksLimit();acquiredLocks.clear();while(iterator.hasPrevious()) {iterator.previous();}} else {--failedLocksLimit;}}// 计算 目前从各个节点获取锁已经消耗的总时间，如果已经等于最大等待时间，则认定最终申请锁失败，返回falseif (remainTime != -1L) {remainTime -= System.currentTimeMillis() - time;time = System.currentTimeMillis();if (remainTime <= 0L) {this.unlockInner(acquiredLocks);return false;}}}// 重置锁过期时间if (leaseTime != -1L) {acquiredLocks.stream().map((l) -> {return (RedissonLock)l;}).map((l) -> {return l.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS);}).forEach((f) -> {f.syncUninterruptibly();});}// 如果逻辑正常执行完则认为最终申请锁成功，返回truereturn true;}

2.4 RedLock的问题与解决方案

2.4.1 问题

2.4.1.1 时钟偏移

Redlock算法中需要使用到各个Redis实例的系统时钟来实现锁的过期时间控制。然而，不同Redis实例之间的时钟可能存在偏移，导致锁的过期时间计算错误，从而导致锁的误释放或者死锁的发生。

2.4.1.2 单点故障

Redlock算法的可靠性依赖于多个Redis实例之间的协作。如果其中一个Redis实例发生故障，可能会导致整个系统的分布式锁服务不可用。

2.4.1.3 性能瓶颈

RedLock需要访问多个实例，网络延迟可能导致某些线程获取锁的时间较长，会增加网络带宽的压力。此外，每个实例都需要对锁进行检查和定时删除操作，也会影响Redis的性能。

2.4.2 解决方案

针对上述问题，我们可以采取以下解决方案来提高Redlock分布式锁在高并发环境下的性能和可靠性：

2.4.2.1 引入重试机制

为了应对网络延迟带来的竞争问题，我们可以在获取锁失败后进行重试。通过设定适当的重试次数和重试间隔，可以减少因网络延迟导致的锁竞争失败的情况。但是该方案还是解决不了性能瓶颈问题，性能瓶颈问题是架构方案决定的。

2.4.2.2 时钟校准

为了解决时钟偏移问题，我们可以通过定期校准各个Redis实例的系统时钟来保证它们之间的一致性。可以使用NTP协议或者其他时间同步机制来实现时钟校准。

2.4.2.3 引入冗余节点

为了避免单点故障带来的问题，我们可以引入冗余节点来提高系统的可用性。通过在系统中增加多个Redis实例作为备份节点，可以在主节点故障时快速切换到备份节点，保证分布式锁服务的可用性。

2.5 总结

基于Redis实现分布式锁的方案，他的实现方式有两种，一直是基于setnx指令+lua脚本+看门狗进程，实现在Redis单实例下的分布式锁方案，这种方式在主从模式下，当主节点宕机，主从切换的时候，会有获取锁失败的情况或者会有多个客户端同时获取到锁的情况，为了提高分布式锁的可用性，则出现了改进后的RedLock锁，RedLock锁是基于多实例加锁（即：N/2+1），同时给N/2+1个实例加锁成功，才算获取锁成功。但是他的问题也很明显，具体如前文所述。所以在进行技术方案选型的时候，你要结合你的场景，明确选用分布式锁时需要用途：

  1. 如果你只考虑提升加锁效率问题，那么选用一台高性能的服务器，部署单实例，采用基于setnx指令+lua脚本+看门狗进程的方案就够了。
  2. 如果你考虑高可用，想避免单点问题，并且你的部署架构是主从的，或者集群模式的，那么你可以选择使用RedLock，但是你就不得不考虑因此带来的复杂性和各种问题。
  3. 如果你要保证绝对的数据一致性，那么不好意思，Redis实现分布式锁方案可能不适合你，因为从架构的角度来说，Redis的架构属于AP架构，它保证的是可用性；这时，你可以考虑使用Zookeeper实现分布式锁方案，因为它的架构属于CP架构，保证的是一致性；但是Zookeeper也有问题，就是它的性能没有Redis高。

那么在并发量大，可靠性高的场景下，我们最终应该怎么技术选型呢，我的建议是避免使用分布式锁，可以通过串行化来解决，比如同步串行化，异步串行化等方案。这里暂时不对串行化设计展开论述，后续有时间我会在另外的主题文章进行分享。

好了，本次内容就分享到这，欢迎关注本博主。如果有帮助到大家，欢迎大家点赞+关注+收藏，有疑问也欢迎大家评论留言！

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

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

相关文章

2009年-2022年 地级市-环境污染处罚数据

2009年-2022年 地级市-环境污染处罚数据

环境污染处罚数据是环境保护领域中重要的信息资源&#xff0c;它记录了因违反环保法律法规而受到行政处罚或法律制裁的具体情况。这些数据对于提高公众的环保意识、促进企业采取环保措施以及推动环境治理具有重要作用。 数据内容概述 违法行为的主体&#xff1a;即受到处罚的…
阅读更多...
私域引流的艺术：高效策略解锁流量密码

私域引流的艺术：高效策略解锁流量密码

在数字化营销的浪潮中&#xff0c;私域流量以其高黏性和低成本的优势成为品牌和企业竞相追逐的宝藏。然而&#xff0c;如何有效引流至私域&#xff0c;却成了摆在每个运营者面前的难题。今天&#xff0c;我们将一起探索那些值得采用的私域引流方法&#xff0c;帮助你解锁流量的…
阅读更多...
虚拟机有哪些写一篇文章

虚拟机有哪些写一篇文章

虚拟机技术作为现代计算环境中的重要组成部分&#xff0c;极大地丰富了我们对资源管理和系统部署的理解与实践。本文将深入探讨虚拟机的定义、工作原理、应用场景、优势、主要技术以及未来发展趋势&#xff0c;帮助读者全方位地理解虚拟机这一强大技术。 虚拟机概述虚拟机&…
阅读更多...
利用cuda的cublas库，编写复数矩阵乘的代码

利用cuda的cublas库，编写复数矩阵乘的代码

学习内容&#xff1a; 利用cuda的cublas库&#xff0c;编写复数矩阵乘的代码 学习产出&#xff1a; 编写代码如下&#xff1a; #include <stdio.h> #include <stdlib.h> #include <cuda_runtime.h> #include <cublas_v2.h> #include <random>…
阅读更多...
【力扣】从前序与中序遍历序列构造二叉树

【力扣】从前序与中序遍历序列构造二叉树

&#x1f525;博客主页&#xff1a; 我要成为C领域大神 &#x1f3a5;系列专栏&#xff1a;【C核心编程】 【计算机网络】 【Linux编程】 【操作系统】 ❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ 本博客致力于分享知识&#xff0c;欢迎大家共同学习和交流。 给定两个整数数…
阅读更多...
如何解决app广告填充率低、广告填充异常，提升广告变现收益？

如何解决app广告填充率低、广告填充异常，提升广告变现收益？

APP广告变现有助于开发者获得持续的收益来源&#xff0c;由于广告链路的封闭性和复杂化&#xff0c;一旦出现请求配置参数错误、返回广告源信息缺失、素材被拦截等异常&#xff0c;大部分开发者很难及时查清异常情况&#xff0c;导致广告填充率不理想&#xff0c;甚至填充率常常…
阅读更多...
【云服务-2】云服务器

【云服务-2】云服务器

弹性云服务器和服务器组的区别&#xff1f; 弹性云服务器和服务器组在云计算环境中有以下区别: 弹性云服务器(Elastic Cloud Server, ECS): 弹性云服务器是独立的虚拟机实例,可以独立启动、停止和管理。 弹性云服务器作为一个独立的计算资源运行,可以根据业务需求进行灵活扩展…
阅读更多...
【Linux】linux系统VIM简介_使用

【Linux】linux系统VIM简介_使用

1、简介 1.1定义 VIM&#xff08;Vi IMproved&#xff09;是 Vi 编辑器的增强版本&#xff0c;提供了更多的功能和改进的用户界面。它被广泛认为是程序员的编辑器首选之一&#xff0c;特别适用于代码编辑和文本处理。VIM 拥有多种模式&#xff0c;每种模式都有其特定的功能和…
阅读更多...
ImportError: No module named createrepo

ImportError: No module named createrepo

我在用createrepo命令创建本地源时&#xff0c;出现如下&#xff1a; ImportError: No module named createrepo原因估计就是之前升级python2.6为2.7时导致&#xff08;系统为centos7&#xff09;&#xff0c;看网上很多说&#xff0c; 修改/usr/share/createrepo/genpkgmeta…
阅读更多...
大咖共话｜智领未来，数字化革新生命健康产业

大咖共话｜智领未来，数字化革新生命健康产业

在数字化浪潮席卷全球的今天&#xff0c;生命健康产业正迎来前所未有的发展机遇。6月20日&#xff0c;“第三届滨海中关村协同创新发展交流会”在北京隆重举办&#xff0c;唯迈医疗与业界大咖齐聚一堂&#xff0c;在“数字化赋能驱动生命健康产业发展”圆桌论坛上&#xff0c;共…
阅读更多...
【PostgreSQL】AUTO_EXPLAIN - 慢速查询的日志执行计划

【PostgreSQL】AUTO_EXPLAIN - 慢速查询的日志执行计划

本文为云贝教育 刘峰 原创&#xff0c;请尊重知识产权&#xff0c;转发请注明出处&#xff0c;不接受任何抄袭、演绎和未经注明出处的转载。 一、介绍 在本文中&#xff0c;我们将了解 PostgreSQL AUTO_EXPLAIN功能的工作原理&#xff0c;以及为什么应该使用它来收集在生产系统…
阅读更多...
（1985-2022年）各省、地级市数字经济专利数据 整理

（1985-2022年）各省、地级市数字经济专利数据 整理

数字经济专利数量是衡量一个国家或地区在数字经济领域创新能力和技术发展水平的重要指标。这些专利通常与数字技术、互联网、大数据分析、云计算、人工智能&#xff08;AI&#xff09;、区块链、物联网&#xff08;IoT&#xff09;等创新成果相关。数字经济专利的增长不仅反映了…
阅读更多...
[JS]函数

[JS]函数

介绍 函数就是用来执行特点任务的代码块, 目的是实现代码复用, 提高开发效率 使用 1.0函数的声明 function 函数名 () {//函数体 } 2.0函数的调用 3.0命名规范 和变量命名规则基本一致尽量小驼峰式命名前缀应该为动词 传参 函数的参数可以极大提高函数的灵活性 1.0参数…
阅读更多...
【React】变量 useState

【React】变量 useState

开发需要&#xff0c;随便学学react。上手第一天&#xff0c;感觉这个JS语法很怪&#xff0c;没有什么逻辑性&#xff0c;比较抽象。随便写写笔记。 跟着网上找的项目写写感觉这个项目还不错&#xff1a; 分享给码友 https://zh-hans.react.dev/learn/tutorial-tic-tac-toe 参…
阅读更多...
PEI转染试剂哪个品牌好用？

PEI转染试剂哪个品牌好用？

在做细胞转染实验时&#xff0c;经常会有这样的疑问&#xff0c;我们应该选择PEI转染试剂还是脂质体转染试剂&#xff1f;PEI转染试剂哪个品牌好用?在了解这个问题之前&#xff0c;我们先看看细胞转染的背景。 近年来&#xff0c;随着许多与疾病和细胞过程相关的基因被确定为…
阅读更多...
等保测评是什么？等保方案怎么做？

等保测评是什么？等保方案怎么做？

等保测评&#xff0c;全称为网络安全等级保护测评&#xff0c;是依据国家相关标准对信息系统进行安全性评估和测试&#xff0c;以确保其符合国家等级保护要求的一种活动。这项测评工作对于保障信息系统安全至关重要&#xff0c;尤其是在当前网络安全威胁日益严峻的背景下。下面…
阅读更多...
内存问题调优-GC

内存问题调优-GC

1. 排查元空间内存溢出 &#xff1a; 在JVM中配置 -verbose:class 打印类加载信息。 什么条件触发GC-CMS为例 1. eden区满了&#xff1f;会不会触发GC&#xff1f; eden区满触发YGC&#xff0c;FGC会出发全代回收&#xff0c;即Eden区也会被回收2. 老年代满了会不会触发GC&a…
阅读更多...
代码随想录训练营Day45

代码随想录训练营Day45

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、打家劫舍二、打家劫舍2三、打家劫舍3 前言 提示&#xff1a;这里可以添加本文要记录的大概内容&#xff1a; 今天是跟着代码随想录刷题的第45天&#xff…
阅读更多...
XX公司-JAVA笔试题

XX公司-JAVA笔试题

一、单选题 某单位的会议室有5排共40个座位&#xff0c;每排座位数相同。小张和小李随机入座&#xff0c;则他们坐在同一排的概率&#xff08;&#xff09;。 A、不高于 15% B、高于 15%但低于 20% C、正好为 20% D、高于 20% 先让小张随机入座&#xff0c;有40个座位可选&…
阅读更多...
【大数据 复习】第9章 数据仓库分析工具Hive

【大数据 复习】第9章 数据仓库分析工具Hive

一、概念 1.概述 &#xff08;1&#xff09;Hive是一个构建于Hadoop顶层的数据仓库工具。 &#xff08;2&#xff09;某种程度上可以看作是用户编程接口&#xff0c;本身不存储和处理数据。 &#xff08;3&#xff09;依赖分布式文件系统HDFS存储数据。 &#xff08;4&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023