逍遥白亦
逍遥白亦

Redis应用之分布式锁

1. 分布式应用并发问题

分布式应用进行逻辑处理时经常会遇到并发问题，比如下面这个例子。

在Redis里对"account"这个key进行操作，两个客户端同时要修改account，首先要读取account的值，然后对其进行修改，修改完再存回去，那么就会出现并发问题，因为读取和保存状态这两个操作不是原子的。


image

2. Redis实现分布式锁

2.1 第一个示例

2.1.1 创建工程

首先创建一个空工程RedisStart，pom文件如下



    4.0.0

    org.example
    RedisStart
    pom
    1.0-SNAPSHOT
    
        redis-lock
    

    
        org.springframework.boot
        spring-boot-starter-parent
        2.1.3.RELEASE
    

    
        
            jdk-1.8
            
                true
                1.8
            
            
                1.8
                1.8
                1.8

2.1.2 创建子工程

创建子工程redis-lock，工程结构如下


image

pom文件:



    
        RedisStart
        org.example
        1.0-SNAPSHOT
    
    4.0.0

    redis-lock
    jar

    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            org.redisson
            redisson
            3.6.5
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

配置文件:

server:
  port: 8090

spring:
  redis:
    host: 127.0.0.1
    port: 6379

2.1.3 启动类

package com.redisson;

import org.redisson.Redisson;
import org.redisson.config.Config;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public Redisson redisson(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0);
        return (Redisson) Redisson.create(config);
    }

}

2.1.4 关键类

首先先在Redis中执行set account 50这条指令，加入数据。然后请看下面代码:

package com.redisson;

import org.redisson.Redisson;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class IndexController {

    @Autowired
    private Redisson redisson;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/deduct account")
    public String deductAccount() throws InterruptedException {
        int account = Integer.parseInt(stringRedisTemplate.opsForValue().get("account"));
        if (account > 0){
            int realAccount = account - 1;
            stringRedisTemplate.opsForValue().set("account",realAccount + "");
            System.out.println("扣减成功，剩余库存:"  + realAccount + "");
        }else {
            System.out.println("扣减失败，库存不足");
        }
        return "end";
    }

}

上面代码重现了开头提出的问题，如果有多线程知识储备的话，可以很容易想到，加入synchronized关键字即可解决。

    synchronized(this){
        int account = Integer.parseInt(stringRedisTemplate.opsForValue().get("account"));
        if (account > 0){
            int realAccount = account - 1;
            stringRedisTemplate.opsForValue().set("account",realAccount + "");
            System.out.println("扣减成功，剩余库存:"  + realAccount + "");
        }else {
            System.out.println("扣减失败，库存不足");
        }
        return "end";
        } 
    }

2.1.5 分布式锁简单实现setnx

如果上边的服务部署在单机模式下，并且程序没有其他异常的话，可以解决原子性问题，但是现在的服务都是在集群部署下的，如果有多台服务的话，上面代码无法解决这个问题。

如果看过前面Redis应用之常用数据类型文章的话，可以知道Redis提供了setnx指令实现分布式锁，可以用以下代码实现。

String lockKey = "lockKey";
        //获取锁信息
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "lock");
        //锁还没有被释放，直接返回
        if (!result){
            return "error";
        }

        int account = Integer.parseInt(stringRedisTemplate.opsForValue().get("account"));
        if (account > 0){
            int realAccount = account - 1;
            stringRedisTemplate.opsForValue().set("account",realAccount + "");
            System.out.println("扣减成功，剩余库存:"  + realAccount + "");
        }else {
            System.out.println("扣减失败，库存不足");
        }
        //业务代码执行完，释放锁
        stringRedisTemplate.delete(lockKey);
        return "end";

这样即使是集群部署下的服务，也可以实现分布式锁功能了，但是如果在执行释放锁那行代码之前，有异常的话，会导致该锁一直被占用，无法释放。

2.1.6 解决程序异常导致的无法释放锁

加入finally逻辑，可以保证即使程序有异常的话，也可以释放锁。

String lockKey = "lockKey";
        try {
            //获取锁信息
            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "lock");
            //锁还没有被释放，直接返回
            if (!result){
                return "error";
            }

            int account = Integer.parseInt(stringRedisTemplate.opsForValue().get("account"));
            if (account > 0){
                int realAccount = account - 1;
                stringRedisTemplate.opsForValue().set("account",realAccount + "");
                System.out.println("扣减成功，剩余库存:"  + realAccount + "");
            }else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            //业务代码执行完，释放锁
            stringRedisTemplate.delete(lockKey);
        }
        
        return "end";

上面代码解决了，如果程序有异常的话，无法释放锁的问题，但是如果在代码执行的一半的时候，服务挂了，或者被Kill掉的话，就不会执行finally里边的代码，所以依然无法释放锁。

2.1.7 setnx命令的原子操作

设置锁的时候，直接对该锁加入超时时间，可以解决由于上边的问题。

String lockKey = "lockKey";
        try {
            //设置锁超时时间
            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "lock",10, TimeUnit.MILLISECONDS);
            //锁还没有被释放，直接返回
            if (!result){
                return "error";
            }

            int account = Integer.parseInt(stringRedisTemplate.opsForValue().get("account"));
            if (account > 0){
                int realAccount = account - 1;
                stringRedisTemplate.opsForValue().set("account",realAccount + "");
                System.out.println("扣减成功，剩余库存:"  + realAccount + "");
            }else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            //业务代码执行完，释放锁
            stringRedisTemplate.delete(lockKey);
        }

        return "end";

如果并发不高的情况下，上面代码可以实现一个良好的分布式锁，但是如果在高并发情况下，会导致锁一直失效。举个例子:如果锁的失效时间是1秒，A线程成功获得了该锁，但是由于并发比较高，导致程序在1秒钟没有执行完，就不会执行删除锁的代码，但是这个时候由于超过了1秒，所以A线程获取的锁已经失效了， 其他线程可以获得该锁，假设B线程获取到了这把锁，开始执行后边的逻辑，这个时候A线程执行了finally中的逻辑，把B线程获取到的锁删除了，那么其他线程又可以获取到这把锁，而过一段时间该锁又失效了，而B线程就会删除C线程过去到的锁，以此类推，这个锁就会一直失效。

2.1.8 锁信息与线程信息绑定

为每一个线程设置线程ID，并将该ID作为锁Key信息的value值，在删除锁的时候，进行判断，如果是本线程自己加的锁，可以删除，如果不是，不能删除。

String lockKey = "lockKey";
        String clientId = UUID.randomUUID().toString();
        try {
            //设置锁超时时间
            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, clientId,30, TimeUnit.MILLISECONDS);
            //锁还没有被释放，直接返回
            if (!result){
                return "error";
            }

            int account = Integer.parseInt(stringRedisTemplate.opsForValue().get("account"));
            if (account > 0){
                int realAccount = account - 1;
                stringRedisTemplate.opsForValue().set("account",realAccount + "");
                System.out.println("扣减成功，剩余库存:"  + realAccount + "");
            }else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            //判断该锁是不是当前线程加的
            if (clientId.equals(stringRedisTemplate.opsForValue().get(lockKey))){
                //业务代码执行完，释放锁
                stringRedisTemplate.delete(lockKey);
            }
        }

        return "end";

至此，已经实现了一把比较完善的分布式锁，但是还是会有一些问题，比如业务代码执行时间大于锁的过期时间，如何对该锁进行续期？可以简单的想到，在主线程启动的时候，启动另外一个线程，监控这把锁的状态，启动一个定时任务，定期监控该锁，如果过一段时间，锁还没释放，就把锁的失效时间重新置位启始值。但这事儿说起来容易，实际写的时候，稍不注意，就会引起很多BUG。

2.2 用Redisson实现一个分布式锁

好在，贴心的Redisson已经帮我们实现了功能完善的分布式锁。请看下面代码:

        String lockKey = "lockKey";
        RLock redissonLock = redisson.getLock(lockKey);
        try {
            //加锁，实现锁续命
            redissonLock.lock();
            int account = Integer.parseInt(stringRedisTemplate.opsForValue().get("account"));
            if (account > 0){
                int realAccount = account - 1;
                stringRedisTemplate.opsForValue().set("account",realAccount + "");
                System.out.println("扣减成功，剩余库存:"  + realAccount + "");
            }else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            //释放锁
            redissonLock.unlock();
        }

可以看到加锁逻辑十分简洁。

2.2.1 Redisson加锁逻辑

下边用一张简单的图来说明下:


image

2.2.2 源码阅读

由于整个Redisson的代码实在太多，所以这里只看主要逻辑。

2.2.2.1 初始化逻辑

先看下边代码对应的源码

RLock redissonLock = redisson.getLock(lockKey);

会调用RedissonLock的构造方法，初始化锁的名称以及锁的失效时间为30秒

    public RedissonLock(CommandAsyncExecutor commandExecutor, String name) {
        super(commandExecutor, name);
        this.commandExecutor = commandExecutor;
        this.id = commandExecutor.getConnectionManager().getId();
        this.internalLockLeaseTime = commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout();
    }

初始化锁的失效时间

    private long lockWatchdogTimeout = 30 * 1000;

2.2.2.2 加锁逻辑

调用RedissonLock.lockInterruptibly()

    @Override
    public void lockInterruptibly() throws InterruptedException {
        lockInterruptibly(-1, null);
    }

下边代码大体逻辑就是，先尝试获取锁，如果获取成功就直接返回，如果没有获取成功，就自旋，直到获取成功。

@Override
    public void lockInterruptibly(long leaseTime, TimeUnit unit) throws InterruptedException {
        //获取当前线程ID
        long threadId = Thread.currentThread().getId();
        Long ttl = tryAcquire(leaseTime, unit, threadId);
        // 获取锁就返回
        if (ttl == null) {
            return;
        }

        RFuture future = subscribe(threadId);
        commandExecutor.syncSubscription(future);

        try {
            //没获取锁自旋获取
            while (true) {
                //再次尝试获取锁
                ttl = tryAcquire(leaseTime, unit, threadId);
                //获取锁就返回
                if (ttl == null) {
                    break;
                }

                //自旋的时候等待一段时间，下次再次获取
                if (ttl >= 0) {
                    getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                } else {
                    getEntry(threadId).getLatch().acquire();
                }
            }
        } finally {
            unsubscribe(future, threadId);
        }
//        get(lockAsync(leaseTime, unit));
    }

获取锁的逻辑

    private Long tryAcquire(long leaseTime, TimeUnit unit, long threadId) {
        return get(tryAcquireAsync(leaseTime, unit, threadId));
    }

继续看tryAcquireAsync(leaseTime, unit, threadId)

    private  RFuture tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
        if (leaseTime != -1) {
            return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        }
        RFuture ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
        ttlRemainingFuture.addListener(new FutureListener() {
            @Override
            public void operationComplete(Future future) throws Exception {
                if (!future.isSuccess()) {
                    return;
                }

                Long ttlRemaining = future.getNow();
                // lock acquired
                if (ttlRemaining == null) {
                    scheduleExpirationRenewal(threadId);
                }
            }
        });
        return ttlRemainingFuture;
    }

由于传入的leaseTime为-1，所以请看如下代码

     RFuture tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand command) {
        internalLockLeaseTime = unit.toMillis(leaseTime);

        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                  "if (redis.call('exists', KEYS[1]) == 0) then " +
                      "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                      "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "return redis.call('pttl', KEYS[1]);",
                    Collections.singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
    }


Redisson源码大量调用了Lua脚本，用于实现原子性。下面来分析这几个脚本,KEYS[1]为锁的名称、ARGV[1]为锁的失效时间、ARGV[2]为当前线程的ID。


    "if (redis.call('exists', KEYS[1]) == 0) then " +
    "redis.call('hset', KEYS[1], ARGV[2], 1); " +
    "redis.call('pexpire', KEYS[1], ARGV[1]); " +
    "return nil; " +
    "end; " +
    "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
        "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
        "redis.call('pexpire', KEYS[1], ARGV[1]); " +
        "return nil; " +
    "end; " +
    "return redis.call('pttl', KEYS[1]);",



上边脚本的逻辑为，首先判断锁是否存在，如果锁不存在，那么就设置该锁，并设置失效时间，返回空；如果锁已存在，就判断该锁是否是当前线程加的锁，如果是当前线程加的锁，就对这个锁的调用次数加1，并刷新锁的失效时间，返回空；如果不是当前线程加的锁，那么该返回该锁的失效时间。


下面来看监听里边相关的代码,这部分代码用了一个延时的任务执行，每隔10秒就查询当前线程获取的锁状态，如果存在就对失效时间进行刷新，并返回1，不存在就直接返回0。


    private void scheduleExpirationRenewal(final long threadId) {
        if (expirationRenewalMap.containsKey(getEntryName())) {
            return;
        }

        Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                
                RFuture future = commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                        "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                            "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                            "return 1; " +
                        "end; " +
                        "return 0;",
                          Collections.singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
                
                future.addListener(new FutureListener() {
                    @Override
                    public void operationComplete(Future future) throws Exception {
                        expirationRenewalMap.remove(getEntryName());
                        if (!future.isSuccess()) {
                            log.error("Can't update lock " + getName() + " expiration", future.cause());
                            return;
                        }
                        
                        if (future.getNow()) {
                            // reschedule itself
                            scheduleExpirationRenewal(threadId);
                        }
                    }
                });
            }
        }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);

        if (expirationRenewalMap.putIfAbsent(getEntryName(), task) != null) {
            task.cancel();
        }
    }


2.2.3 存在问题


由于Redis一般是集群部署的，所以会出现由于主节点挂掉的话，从节点会取而代之。这时候如果客户端在主节点上申请成功了一把锁，但是这把锁还没有来得及同步到从节点，主节点突然挂了，然后从节点变为主节点，这个新的节点内部没有这个锁，所以当另一个客户端过来请求加锁时，立即就批准了，这样就导致系统中同样一把锁被两个客户端同时持有，不安全性由此产生。


3. RedLock算法


为了解决由于主节点挂掉导致多个客户端同时持有一把锁的问题，Antirez发明了RedLock算法，它的流程比较复杂，不过已经有了很多大神开发了开源的库，用户可以拿来即用，比如redlock-py以及Redisson。


为了使用 Redlock，需要提供多个Redis实例，这些实例之前相互独立没有主从关系。同很多分布式算法一样，redlock 也使用「大多数机制」。


加锁时，它会向过半节点发送 set(key, value, nx=True, ex=xxx) 指令，只要过半节点 set成功，那就认为加锁成功。释放锁时，需要向所有节点发送 del 指令。不过 Redlock 算法还
 需要考虑出错重试、时钟漂移等很多细节问题，同时因为 Redlock 需要向多个节点进行读写，意味着相比单实例 Redis 性能会下降一些。


3.1 RedLock使用场景


如果你很在乎高可用性，希望挂了一台 redis 完全不受影响，那就应该考虑 redlock。不过代价也是有的，需要更多的 redis 实例，性能也下降了，代码上还需要引入额外的library，运维上也需要特殊对待，这些都是需要考虑的成本，使用前请再三斟酌。


参考资料


    

  1. 《Redis深度历险》
    2. 

























你可能感兴趣的:(Redis应用之分布式锁)






    

  • 分布式跟踪服务实战应用指南
CRMEB系统商城
分布式

    已成为了决解复杂系统运行效率问题的关键手段之一，随着企业向微服务化与分布式系统的转变，应用复杂度不断提升，监控技术的挑战更为严峻。此项服务不仅能协助开发与运维团队更直观地理解系统运作状况，还可增强系统稳定性及提升用户满意度。接下来，文章将详细剖析分布式追踪服务的优点、适用场景、可能存在的风险以及安全性，同时还会介绍如何在Python项目中进行集成操作，并对比其他可用选项，为您推荐合适的服务提供商。
    

    • 

  • python入门之控制结构-循环结构_python入门之流程控制
weixin_39770592

    流程控制就是控制程序执行的流程。流程控制分三种结构：顺序结构（程序从上往下执行最后结束）；分支结构（通过if判断）；循环结构（for循环、while循环）分支结构分支结构：通过判断条件的真假，选择执行不同的子代码块。实现方式：通过if语句if语法完整定义if条件1：代码块1elif条件2：代码块2elif条件3：代码块3else:代码块4#代码块指的是相同缩进的一堆代码。python通过缩进4个字
    

    • 

  • 服务器每秒钟执行命令数量是什么_Redis的内部运作机制
weixin_39753791
服务器每秒钟执行命令数量是什么

    本文将分五个部分来分析和总结Redis的内部机制，分别是：Redis数据库、Redis客户端、Redis事件、Redis服务器的初始化步骤、Redis命令的执行过程。首先介绍一下Redis服务器的状态结构。Redis使用一个类型为“redisServer”的数据结构来保存整个Redis服务器的状态(每个属性按照即将讲解的顺序进行排序)：structredisServer{intdbnum;//服务
    

    • 

  • 让Python更加充分的使用Sqlite3
weixin_33726318
python数据库运维

    我最近在涉及大量数据处理的项目中频繁使用sqlite3。我最初的尝试根本不涉及任何数据库，所有的数据都将保存在内存中，包括字典查找、迭代和条件等查询。这很好，但可以放入内存的只有那么多，并且将数据从磁盘重新生成或加载到内存是一个繁琐又耗时的过程。我决定试一试sqlite3。因为只需打开与数据库的连接，这样可以增加可处理的数据量，并将应用程序的加载时间减少到零。此外，我可以通过SQL查询替换很多Py
    

    • 

  • 9-Python3从入门到实战—基础之条件控制语句
weixin_33736649
pythonjava移动开发

    Python从入门到实战系列——目录条件判断if条件判断if语句语法if:elif:elif:else:每个条件后面要使用冒号（:），表示接下来是满足条件后要执行的语句块;使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块;在Python中没有switch–case语句;num=5ifnum==0:print('num=0')elifnum>0:print('num是一个正数')else:
    

    • 

  • Java实现建造者模式和源码中的应用
coffee_baby
JAVA实现设计模式java建造者模式开发语言

    Java实现建造者模式（BuilderPattern）文章目录Java实现建造者模式（BuilderPattern）案例：汉堡制作建造者模式的核心角色代码实现：汉堡制作内部类实现：Step1：产品类BurgerStep2：指挥者DirectorStep3：客户端代码结果总结抽象类实现Step1：产品类BurgerStep2：抽象的Builder类Step3：具体的Builder类Step4：指挥者
    

    • 

  • Java实现单例模式
coffee_baby
JAVA实现设计模式java单例模式javascript

    文章目录Java实现单例模式饿汉式（静态常量）代码实现优缺点说明饿汉式（静态代码块）代码实现优缺点说明：懒汉式(线程不安全)代码实现优缺点说明：懒汉式(线程安全，同步方法)优缺点说明：懒汉式(线程安全，同步代码块)代码实现优缺点说明：双重检查实现代码实现优缺点说明：静态内部类代码实现优缺点说明：枚举代码实现优缺点说明：单例在JDK中的应用单例模式注意事项Java实现单例模式单例模式（Singlet
    

    • 

  • Redis的各种机制
LLYYYYSS
redisredis

    一、Redis的持久化机制1.简介Redis有两种持久化机制，分别是RDB和AOF，RDB：每个一段时间保存一个快照；AOF：保存每次写的操作指令；2.RDB（1）RDB的概念RDB：每隔一段时间，把内存中的数据写入磁盘的临时文件，作为快照，恢复的时候把快照文件读进内存。如果宕机重启，那么内存里的数据肯定会没有的，因为RDB的存在，那么重启redis后，则会恢复。（2）备份与恢复备份：内存备份--
    

    • 

  • 精进打卡284天
谢逢春亚克力

    深圳天塑智能科技有限公司【口号】:天道酬勤，高雅精致【经营理念】：实现员工梦想，做幸福企业【愿景】：做亚克力道具的引领者【使命】：简约收纳空间、点缀生活之美【价值观】：感恩、责任、创新、精致【谢逢春日精进微信分享第284天，今天2020-3-12日】【知～学习】:《大学》《六项精进》《志工十二条》【行~实践】一.修身：二.齐家：三.建功：四.｛今日分享｝产品是做出来的，但更是设计出来的，所以做个产
    

    • 

  • Redis缓存机制(详解)
就是有缘人
redis缓存数据库

    1.Redis是什么?*redis是*一个运行在内存上的key-value存储系统。是NoSQL数据库之一2.缓存穿透,缓存击穿,缓存雪崩/**缓存穿透*/它会先查询Redis,Redis没有会查询数据库,数据库也没有这就是缓存穿透业界主流解决方案:布隆过滤器布隆过滤器的使用步骤布隆过滤器的使用步骤:1.针对现有所有数据,生成布隆过滤器2.在业务逻辑层,判断Redis之前先检查这个id是否在布隆过
    

    • 

  • NoSQL之REDIS配置与优化
m0_73868728
nosqlredis数据库

    一、Redis简介Redis（RemoteDictionaryServer）是一个开源的、使用C语言编写的NoSQL数据库，它基于内存运行并支持持久化，采用key-value的存储形式。Redis因其高性能、丰富的数据类型支持和原子性操作而广泛应用于缓存、实时分析系统、排行榜等多种场景。二、Redis的安装1.使用包管理器安装对于大多数Linux发行版，可以使用包管理器直接安装Redis。例如，在
    

    • 

  • 【深入学习Redis丨第三篇】深入详解Redis高可用集群模式
陈橘又青
深入学习Redis学习redis数据库高可用集群

    前言本文我们将介绍Redis的四种模式及各自优缺点分析。Redis一共4种模式：1、主从复制模式2、(Sentinel)哨兵模式3、(Cluster)集群模式4、代理模式文章目录前言1.**主从模式****1.1简介****1.2工作机制**2.**哨兵模式****2.1简介****2.2工作机制****2.3注意点**3.**Cluster模式****3.1简介****3.2工作机制****3.
    

    • 

  • 正能量
草原野狼战队

    2019年11月1日星期五晴亲子日记2014级7班马驰翔爸爸690古人讲：“与善人居，如入芝兰之室，久而不闻其香，即与之化矣；与不善人居，如入鲍鱼之肆，久而不闻其臭，亦与之化矣。”人是环境的产物，选择与什么样的人为伍，深刻影响着自己的人生。选择与正能量的人在一起，真的很重要。人与人之间有着能量的磁场，和正能量的人交往，能被他的积极向上所感染，心情也会变得阳光开朗，对生活充满信心。与负能量的人交往，
    

    • 

  • 《道德经》51-60章经典自译
远光的树洞

    第五十一章尊道贵德道生之，德畜之，物形之，势成之。是以万物莫不尊道，而贵德。道之尊，德之贵，夫莫之命而常自然。故道生之，德畜之。长之育之。亭之毒之。养之覆之。生而不有，为而不恃，长而不宰。是谓玄德。道生成万物，德养育万物，万物都有独特的形态，顺应时势而成长。因此，万物没有不尊敬道、重视德的。道之所以受尊敬，德之所以受重视，就在于道德从不对万物进行干涉，而是顺其自然。所以，道生成了万物，德养育了万物
    

    • 

  • 设计模式之七大设计原则详解
carl的分享笔记
设计模式与设计原则设计模式java设计原则面试

    七大设计原则：七大设计原则：开闭原则、依赖倒置原则、单一职责原则、接口隔离原则、迪米特原则、里氏替换原则、合成复用原则Java有三大特性：封装、继承、多态。而这七大设计原则，更像是对三大特性的一种体现。七大原则并不是分别独立的原则，他们之间是相互有联系的，甚至可以看做是一体的。有时候你为了符合某种原则会无意之间破坏另一个原则有时候你为了符合某种原则还会发现这也符合另外几种原则开闭原则对（类、方法）
    

    • 

  • 大模型面试就是演戏，胆子越大offer越多
AI大模型学习不迷路
面试职场和发展自然语言处理AI大模型大语言模型大模型面试面试题

    建议找工作和想跳槽的可以多记背场景题再去，通过率很高，都是深挖场景题，比较高效无脑的方法，金九银十时期面试岗多可以大胆去做，所有场景题都有对应答案，希望对你们面试有帮助一、大模型常见面试题及解答大模型相关的面试问题通常涉及模型的原理、应用、优化以及面试者对于该领域的理解和经验。以下是一些常见的大模型面试问题以及建议的回答方式：1、请简述什么是大模型，以及它与传统模型的主要区别是什么？回答：大模型通
    

    • 

  • 前缀匹配工具之IP-Prefix
数通Dinner
ensp华为数通tcp/ip网络协议网络信息与通信

    目录基本概念:技术背景：用户需求：安全需求：企业内部的访问控制需求：IP-Prefix的配置与语句分析：调用方式：尾声基本概念:IP-Prefix，即IP前缀，相比传统ACL，它能够基于路由前缀与路由掩码进行匹配例如，192.168.0.0/16，192.168.0.0/24，这两条前缀相同，但是掩码不同的路由流量若是ACL规则如是写下：rule5rulepermitsource192.168.0
    

    • 

  • 『倾城之云』祁连山2022年一月诗
诗人祁连山

    《倾城之云》每天总有一个时刻月亮和太阳相交汇世间所有阳光和月光也交相辉映穿越漫天云海这一切都被做饭侠丁伦看在眼里可他谁也没说因为他觉得就算说了也不会有人相信今晚做给璇雅的意大利面不一定要炒制番茄也可以煎荷包蛋2022.01.2603:01:16《动感之云》养殖场的肉鸡有着很动听的名字名叫白羽其实在人类诞生以前还有一个文明名叫魔影魔影们不会飞只会跳一蹦千百亿米他们出生一落地就是一个双脚跳现今谁都不知
    

    • 

  • 渡我
巧妹吉吉熊

    有人说，人的人生遇到的人，经历的事，都是来渡你的。只是有时我们身在其中，后知后觉。遇到的一些人，经历的有些事，是光明之渡。让我们在人生路走的顺畅，给我们的生命带来阳光。遇到伤害我们的人，经历的磨难。是黑暗之渡。看上去这些带给我们的是悲观的，不愿承受的。反观另一面，它让我们看清这个世界的险恶。磨练我们的意志，教会我们逆境中成长。人生的路程中，缘深缘浅皆是过客。应该看清的是自己才是摆渡自己的人。一次，
    

    • 

  • 【Redis】Redis 集群搭建与管理: 原理、实现与操作
Hsu琛君珩
Redisredisbootstrap数据库

    目录集群(Cluster)基本概念数据分片算法哈希求余⼀致性哈希算法哈希槽分区算法(Redis使⽤)集群搭建(基于docker)第⼀步:创建⽬录和配置第⼆步:编写docker-compose.yml第三步:启动容器第四步:构建集群主节点宕机演⽰效果处理流程1)故障判定2)故障迁移集群扩容第⼀步:把新的主节点加⼊到集群第⼆步:重新分配slots第三步:给新的主节点添加从节点集群缩容(选学)第⼀步:删
    

    • 

  • 拆书—反抗苦于学无所获，变读书为己用
北海道的娃仔

    面对这个网络发达、信息爆炸的时代，凡受波及之人均手足无措，难以平静思考、无法自由的学习，读书汲取精神食粮竟变成了一大难题。诸如压力与学习的矛盾产生没时间、没精力的念头；而投入学习以后初始就搞错主体导致的看不懂、记不住的苦恼；毫无目的的一头扎进书里，最终看不下去而不了了之造成大量的沉没成本。如此种种，难道读书之路真的变成了死胡同，“秀才不出门，方知天下事”成为奢望、书中“黄金屋”“颜如玉”将被深藏。
    

    • 

  • 比淘宝便宜的购物软件有哪些？2023哪个app买东西质量好又便宜？
全网优惠分享

    比淘宝便宜的购物软件有哪些？2023哪个app买东西质量好又便宜？下面我们一起来瞅瞅！1.高省高省目前对接了淘宝天猫、京东、拼多多、苏宁、唯品会、抖音、快手等电商平台，同时对接了饿了么外卖商超、美团外卖、优选、商超和酒店红包返利业务,不但购物能省钱，分享给朋友购物还能赚钱首先在手机应用商店搜索「高省」下载，注册时填写邀请码：666766或者保存下方图片到相册,用微信扫一扫下载「高省」注册时填写邀请
    

    • 

  • 七绝·赏绿萼梅
张成昱

    二十一世纪旧体诗词风骚榜七绝·赏绿萼梅次韵云子兄之辛丑雅集十一韵因爱青衫又早开，喜偕春燕赴低徊。曲桥野径竹篱外，独立一枝随性梅。
    

    • 

  • 键盘快捷键：提高工作效率与电脑操作的利器
wjs2024
开发语言

    键盘快捷键：提高工作效率与电脑操作的利器在数字化时代，键盘快捷键成为了提高工作效率和优化电脑操作的重要工具。无论是日常办公、图像编辑、编程开发，还是游戏娱乐，掌握键盘快捷键都能带来极大的便利。本文将详细介绍键盘快捷键的概念、重要性、以及在不同应用场景中的具体应用。什么是键盘快捷键？键盘快捷键，也称为热键或快捷键，是指通过按下键盘上的一组键来完成特定命令或操作的方式。这些快捷键通常涉及同时按下多个键
    

    • 

  • java-redis-击穿
Flying_Fish_Xuan
javaredisspringboot

    Java与Redis之缓存击穿问题解决方案1.背景：缓存的基本概念在高并发系统中，缓存是一个非常重要的优化手段。它的基本思想是将热点数据缓存在高速的存储系统（如Redis、Memcached）中，从而减轻数据库等持久层的压力，并加快请求响应速度。常见的缓存模式有：缓存读写：读取数据时优先从缓存中获取，如果缓存中没有数据，则从数据库或其他持久化存储中获取并缓存。缓存失效策略：缓存系统通常会为每条缓存
    

    • 

  • 万物发展史(二元)
opcc

    如何脱离物质世界纯粹地谈及意识？缸中脑，完全实验室培养出来，未接受任何刺激，它会产生意识活动吗？这样假设的前提已经陷入了物质决定意识的理论。假设意识是第一性的，一切物质存在都是意识用来限定自身的，使之成为个别的存在，相同相似的限制造就了许许多多相似的意识个体。物质世界是意识为了限制自身而产生的，实践只是在限制中活动，而创造性的思考才是意识世界的潜能。用唯物角度审视“只凭借意识活动无法实践和改造世界
    

    • 

  • 资治通鉴2023-09-14
荒原苍狼

    兴元元年，甲子，公元784年1、二月戊申，诏赠段秀实太尉，谥曰忠烈，厚恤其家。时贾隐林已卒，赠左仆射，赏其能直言也。李适用封官的追赠高官的形式表示自己不忘记忠臣，给其他人做个榜样2、李怀光既胁朝廷逐卢杞等，内不自安，遂有异志。又恶李晟独当一面，恐其成功，奏请与晟合军。诏许之。晟与怀光会于咸阳西陈涛斜，筑垒未毕，泚众大至。晟谓怀光曰：“贼若固守宫苑，或旷日持久，未易攻取。今去其巢穴，敢出求战，此天以
    

    • 

  • MelosBoom vs. Google Nest: 打造未来智能家居的去中心化之路
区块链小八歌
区块链

    在智能家居领域，GoogleNest凭借其出色的硬件设计和强大的AI助手，成为了家庭管理和物联网控制的标杆。然而，随着人们对数据隐私和自主权的日益关注，集中化的智能家居系统逐渐暴露出其固有的缺陷。MelosBoom的出现，为这一领域带来了新的突破，其去中心化的网络架构和独特的AI驱动能力，正重新定义未来智能家居的标准。对更加符合应用场景的网络基础设施需求成为了未来机构在投资选择时的更加青睐领域。例
    

    • 

  • 一套专门处理青少年成长教育问题的系统，简称为“3+1+1科学教育系统”
萧姝311系统

    在教育孩子的过程中，很多父母难免会遇到各种各样的麻烦，无从下手，心力交瘁，开始找各种专家和教育机构，那么，你真正的学会了那些所谓的技巧了吗？专业知识的储备要运用到生活当中，面对孩子的教育，不是靠理论和空谈就可以实现科学和正确的理念的，所以，我总结了一套专业又不缺乏实战的系统，该系统中所谓的“3”指的是运用的三大心理学应用板块，分为：教育心理学、认知心理学、人格心理学。在这三个心理学板块当中，从心理
    

    • 

  • 微服务架构设计详解
小小Java开发者
SpringCloud微服务架构详解

    为什么要做微服务？微服务一直是近几年的技术热点，凡是谈到架构设计，毫无疑问都离不开微服务这个话题。无论是做架构设计，还是只是做业务开发，几乎在所有的面试中，微服务设计几乎是必问的一道面试题。另外，在我们的实际工作中，几乎百分之80的公司，微服务也都是架构演变升级的方向。那么，为什么要做微服务呢？微服务的出发点是什么呢？单体架构达到瓶颈业务复杂度上升，扩展困难，维护费力度上升，牵一发动全身团队规模扩
    

    • 

  • html
周华华
html

    js
1，数组的排列
var arr=[1,4,234,43,52,];
for(var x=0;x<arr.length;x++){
   for(var y=x-1;y<arr.length;y++){
     if(arr[x]<arr[y]){
    &
    

    • 

  • 【Struts2 四】Struts2拦截器
bit1129
struts2拦截器

    Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。
 
Struts2中自定义拦截器的步骤是：
    

    • 

  • make:cc 命令未找到解决方法
daizj
linux命令未知make cc

    安装rz sz程序时，报下面错误：
 
[root@slave2 src]# make posix
cc   -O -DPOSIX -DMD=2 rz.c -o rz
make: cc：命令未找到
make: *** [posix] 错误 127
 
系统：centos 6.6
环境：虚拟机
 
错误原因：系统未安装gcc，这个是由于在安
    

    • 

  • Oracle之Job应用
周凡杨
oracle job

    
最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。
 
一：查看相关job信息
   1、相关视图 
dba_jobs 
all_jobs 
user_jobs 
dba_jobs_running 包含正在运行
    

    • 

  • 多线程机制
朱辉辉33
多线程

    转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx
程序、进程和线程：
程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
    

    • 

  • web报表工具FineReport使用中遇到的常见报错及解决办法（一）
老A不折腾
web报表finereportjava报表报表工具

    FineReport使用中遇到的常见报错及解决办法（一）
这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。
 
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。
 
1、address pool is full：
含义：地址池满，连接数超过并发数上
    

    • 

  • mysql rpm安装后没有my.cnf
林鹤霄
没有my.cnf

    Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的，
至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法，
第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动，
第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
    

    • 

  • Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题
aigo
root

    原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/
 
Step 4: Run ADB command from your PC
 
On the PC, you need install Amazon Fire ADB driver and instal
    

    • 

  • javascript 中var提升的典型实例
alxw4616
JavaScript

    // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧
myname = 'global';
var fn = function () {
console.log(myname); // undefined
var myname = 'local';
console.log(myname); // local
};
fn()
// 上述代码实际上等同于以下代码
m
    

    • 

  • 定时器和获取时间的使用
百合不是茶
时间的转换定时器

    定时器:定时创建任务在游戏设计的时候用的比较多
  Timer();定时器
TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。
 
 
  定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
    

    • 

  • JDK1.5 Queue
bijian1013
javathreadjava多线程Queue

    JDK1.5 Queue
LinkedList：
LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
    

    • 

  • http认证原理和https
bijian1013
httphttps

    一.基础介绍
        在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。
        Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。
http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
    

    • 

  • 【Java范型五】范型继承
bit1129
java

    定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2
 
package com.tom.lang.generics;
public abstract class SuperGenerics<T1, T2> {
private T1 t1;
private T2 t2;
public abstract void doIt(T
    

    • 

  • 【Nginx六】nginx.conf常用指令(Directive)
bit1129
Directive

    1. worker_processes    8;
表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行
 
nobody 53879 118449 0 Apr22 ? 00:26:15 nginx: worker process 
    

    • 

  • lua 遍历Header头部
ronin47
lua header 遍历　

    
local headers = ngx.req.get_headers()  
ngx.say("headers begin", "<br/>")  
ngx.say("Host : ", he
    

    • 

  • java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。
bylijinnan
java

    
import java.util.Arrays;
public class MinSumASumB {
/**
* Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序.
*
* 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
* 例如:
* int[] a = {100,99,98,1,2,3
    

    • 

  • redis
开窍的石头
redis

    在redis的redis.conf配置文件中找到# requirepass foobared
把它替换成requirepass 12356789 后边的12356789就是你的密码
打开redis客户端输入config get requirepass
返回
redis 127.0.0.1:6379> config get requirepass
1) "require
    

    • 

  • [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？
comsci
java语言

    
      无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情
       
    

    • 

  • 安装ubuntu14.04登录后花屏了怎么办
cuiyadll
ubuntu

    这个情况，一般属于显卡驱动问题。
可以先尝试安装显卡的官方闭源驱动。
按键盘三个键：CTRL + ALT  +  F1
进入终端，输入用户名和密码登录终端：
安装amd的显卡驱动
sudo 
apt-get 
install 
fglrx
安装nvidia显卡驱动
sudo 
ap
    

    • 

  • SSL 与 数字证书 的基本概念和工作原理
darrenzhu
加密ssl证书密钥签名

    SSL 与 数字证书 的基本概念和工作原理
http://www.linuxde.net/2012/03/8301.html
SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。
http://www.ibm.com/developerworks/cn/webspher
    

    • 

  • Ubuntu设置ip的步骤
dcj3sjt126com
ubuntu

    在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。
转载不是错：
Ubuntu命令行修改网络配置方法
/etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载.
1. 以D
    

    • 

  • php包管理工具推荐
dcj3sjt126com
PHPComposer

    http://www.phpcomposer.com/
  Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。
中文文档 
入门指南 
下载 
安装包列表
Composer 中国镜像 
    

    • 

  • Gson使用四（TypeAdapter）
eksliang
jsongsonGson自定义转换器gsonTypeAdapter

    转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述
       Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例
       例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
    

    • 

  • JQM控件之Navbar和Tabs
gundumw100
htmlxmlcss

    在JQM中使用导航栏Navbar是简单的。
只需要将data-role="navbar"赋给div即可：
<div data-role="navbar">
<ul>
<li><a href="#" class="ui-btn-active&qu
    

    • 

  • 利用归并排序算法对大文件进行排序
iwindyforest
java归并排序大文件分治法Merge sort

     
归并排序算法介绍，请参照Wikipeida
zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F
基本思想：
大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数
低于限制行数的子文件直接排序
两个排序好的子文件归并到父文件
直到最后所有排序好的父文件归并到输入
    

    • 

  • iOS UIWebView URL拦截
啸笑天
UIWebView

    本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
    

    • 

  • 索引的碎片整理SQL语句
macroli
sql

    SET NOCOUNT ON
DECLARE @tablename VARCHAR (128)
DECLARE @execstr VARCHAR (255)
DECLARE @objectid INT
DECLARE @indexid INT
DECLARE @frag DECIMAL
DECLARE @maxfrag DECIMAL
--设置最大允许的碎片数量,超过则对索引进行碎片
    

    • 

  • Angularjs同步操作http请求with $promise
qiaolevip
每天进步一点点学习永无止境AngularJS纵观千象

    // Define a factory
app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) {
var deferred = $q.defer();
AccountService.getProfile().then(function(res) {

    

    • 

  • hibernate联合查询问题
sxj19881213
sqlHibernateHQL联合查询

    最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。
针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2）
 
1 几个常识：
 （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。
 （2）hql的默认查询策略，在进行联合查询时，会产
    

    • 

  • struts2.xml
wuai
struts

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache
    

    •