吾道孤矣
吾道孤矣

SpringBoot2.X.X集成redis的lettuce版，配置文件RedisConfig和分布式锁文件RedisLock

配置文件：

package com.xxx.conf.cache;

import com.beautiful.util.Constants;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;


@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 通过cacheManager方式配置缓存区域
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                // 默认策略，未配置的 key 会使用这个
                this.getRedisCacheConfigurationWithTtl(4 * 60 * 60),
                // 指定 key 策略
                this.getRedisCacheConfigurationMap()
        );
    }


    private Map getRedisCacheConfigurationMap() {
        Map redisCacheConfigurationMap = new HashMap<>();
        //SsoCache和BasicDataCache进行过期时间配置
        redisCacheConfigurationMap.put("xxx", this.getRedisCacheConfigurationWithTtl(30 * 60));
        redisCacheConfigurationMap.put("YYY", this.getRedisCacheConfigurationWithTtl(50 * 60));
        redisCacheConfigurationMap.put("ZZZ", this.getRedisCacheConfigurationWithTtl(12 * 30 * 60));
        return redisCacheConfigurationMap;
    }

    /**
     * 缓存时间
     *
     * @param seconds 秒
     * @return
     */
    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(RedisSerializationContext
                .SerializationPair
                .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));
        return redisCacheConfiguration;
    }

}


分布式锁文件：


package com.xxx.conf.cache;

import io.lettuce.core.RedisFuture;
import io.lettuce.core.ScriptOutputType;
import io.lettuce.core.SetArgs;
import io.lettuce.core.api.async.RedisAsyncCommands;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import java.nio.charset.StandardCharsets;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ExecutionException;

@Slf4j
public class RedisLock {

    private RedisTemplate redisTemplate;

    /**
     * 调用set后的返回值
     */
    public static final String OK = "OK";

    /**
     * 默认请求锁的超时时间(ms 毫秒)
     */
    private static final long TIME_OUT = 100;

    /**
     * 默认锁的有效时间(s)
     */
    public static final int EXPIRE = 60;

    /**
     * 解锁的lua脚本
     */
    public static final String UNLOCK_LUA;

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1])");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();
    }

    /**
     * 锁标志对应的key
     */
    private String lockKey;

    /**
     * 锁对应的值
     */
    private String lockValue;

    /**
     * 锁的有效时间(s)
     */
    private int expireTime = EXPIRE;

    /**
     * 请求锁的超时时间(ms)
     */
    private long timeOut = TIME_OUT;

    /**
     * 锁标记
     */
    private volatile boolean locked = false;

    private final Random random = new Random();

    /**
     * 使用默认的锁过期时间和请求锁的超时时间
     *
     * @param redisTemplate
     * @param lockKey       锁的key（Redis的Key）
     */
    public RedisLock(RedisTemplate redisTemplate, String lockKey) {
        this.redisTemplate = redisTemplate;
        this.lockKey = lockKey + "_lock";
    }

    /**
     * 使用默认的请求锁的超时时间，指定锁的过期时间
     *
     * @param redisTemplate
     * @param lockKey       锁的key（Redis的Key）
     * @param expireTime    锁的过期时间(单位：秒)
     */
    public RedisLock(RedisTemplate redisTemplate, String lockKey, int expireTime) {
        this(redisTemplate, lockKey);
        this.expireTime = expireTime;
    }

    /**
     * 使用默认的锁的过期时间，指定请求锁的超时时间
     *
     * @param redisTemplate
     * @param lockKey       锁的key（Redis的Key）
     * @param timeOut       请求锁的超时时间(单位：毫秒)
     */
    public RedisLock(RedisTemplate redisTemplate, String lockKey, long timeOut) {
        this(redisTemplate, lockKey);
        this.timeOut = timeOut;
    }

    /**
     * 锁的过期时间和请求锁的超时时间都是用指定的值
     *
     * @param redisTemplate
     * @param lockKey       锁的key（Redis的Key）
     * @param expireTime    锁的过期时间(单位：秒)
     * @param timeOut       请求锁的超时时间(单位：毫秒)
     */
    public RedisLock(RedisTemplate redisTemplate, String lockKey, int expireTime, long timeOut) {
        this(redisTemplate, lockKey, expireTime);
        this.timeOut = timeOut;
    }

    /**
     * 尝试获取锁 超时返回
     *
     * @return
     */
    public boolean tryLock() {
        // 生成随机key
        lockValue = UUID.randomUUID().toString();
        // 请求锁超时时间，纳秒
        long timeout = timeOut * 1000000;
        // 系统当前时间，纳秒
        long nowTime = System.nanoTime();
        while ((System.nanoTime() - nowTime) < timeout) {
            if (OK.equalsIgnoreCase(this.set(lockKey, lockValue, expireTime))) {
                locked = true;
                // 上锁成功结束请求
                return locked;
            }

            // 每次请求等待一段时间
            sleep(10, 50000);
        }
        return locked;
    }

    /**
     * 尝试获取锁 立即返回
     *
     * @return 是否成功获得锁
     */
    public boolean lock() {
        lockValue = UUID.randomUUID().toString();
        //不存在则添加 且设置过期时间（单位ms）
        String result = set(lockKey, lockValue, expireTime);
        locked = OK.equalsIgnoreCase(result);
        return locked;
    }

    /**
     * 以阻塞方式的获取锁
     *
     * @return 是否成功获得锁
     */
    public boolean lockBlock() {
        lockValue = UUID.randomUUID().toString();
        while (true) {
            //不存在则添加 且设置过期时间（单位ms）
            String result = set(lockKey, lockValue, expireTime);
            if (OK.equalsIgnoreCase(result)) {
                locked = true;
                return locked;
            }

            // 每次请求等待一段时间
            sleep(10, 50000);
        }
    }

    /**
     * 解锁
     *
     * @return false:   锁已不属于当前线程  或者 锁已超时
     */
    public Boolean unlock() {
        // 只有加锁成功并且锁还有效才去释放锁
        if (locked) {
            return redisTemplate.execute((RedisCallback) connection -> {
                Object nativeConnection = connection.getNativeConnection();
                Long result = 0L;
                Object[] keys = new Object[]{lockKey.getBytes(StandardCharsets.UTF_8)};
                if (nativeConnection instanceof RedisAsyncCommands) {
                    RedisAsyncCommands commands = ((RedisAsyncCommands) nativeConnection).getStatefulConnection().async();
                    RedisFuture future = commands.eval(UNLOCK_LUA, ScriptOutputType.INTEGER, keys, lockValue.getBytes(StandardCharsets.UTF_8));
                    try {
                        result = (Long) future.get();
                    } catch (InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    }
                }
                if (result == 1) {
                    log.info("Redis分布式锁，解锁{}成功！解锁时间：{}", lockKey, System.currentTimeMillis());
                    locked = false;
                    return true;
                }
                return false;
            });
        }

        return true;
    }

    /**
     * 重写redisTemplate的set方法
     * 

     * 命令 SET resource-name anystring NX EX max-lock-time 是一种在 Redis 中实现锁的简单方法。
     * 

     * 客户端执行以上的命令：
     * 

     * 如果服务器返回 OK ，那么这个客户端获得锁。
     * 如果服务器返回 NIL ，那么客户端获取锁失败，可以在稍后再重试。
     *
     * @param key     锁的Key
     * @param value   锁里面的值
     * @param seconds 过去时间（秒）
     * @return
     */
    private String set(final String key, final String value, final long seconds) {
        Assert.isTrue(!StringUtils.isEmpty(key), "key不能为空");

        return redisTemplate.execute((RedisCallback) connection -> {
            Object nativeConnection = connection.getNativeConnection();
            String result = null;
            //单机模式
            if (nativeConnection instanceof RedisAsyncCommands) {
                RedisAsyncCommands commands = (RedisAsyncCommands) nativeConnection;
                RedisFuture future = commands
                        .getStatefulConnection()
                        .async()
                        .set(key.getBytes(StandardCharsets.UTF_8), value.getBytes(StandardCharsets.UTF_8), SetArgs.Builder.ex(seconds).nx());
                try {
                    result = String.valueOf(future.get());
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
            //集群模式，ex为秒，px为毫秒
            if (nativeConnection instanceof RedisAdvancedClusterAsyncCommands) {
                RedisAdvancedClusterAsyncCommands commands = (RedisAdvancedClusterAsyncCommands) nativeConnection;
                RedisFuture future = commands
                        .getStatefulConnection()
                        .async()
                        .set(key.getBytes(StandardCharsets.UTF_8), value.getBytes(StandardCharsets.UTF_8), SetArgs.Builder.nx().ex(30));
                try {
                    result = String.valueOf(future.get());
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
            if (result.equalsIgnoreCase("ok")) {
                result = "ok";
                log.info("获取锁{}的时间：{}", key, System.currentTimeMillis());
            }
            return result;
        });
    }

    /**
     * 获取锁状态
     *
     * @return
     * @Title: isLock
     */
    public boolean isLock() {
        return locked;
    }

    /**
     * 线程等待时间
     *
     * @param millis 毫秒
     * @param nanos  纳秒
     */
    private void sleep(long millis, int nanos) {
        try {
            Thread.sleep(millis, random.nextInt(nanos));
        } catch (InterruptedException e) {
            log.info("获取分布式锁休眠被中断：", e);
        }
    }

    public int getExpireTime() {
        return expireTime;
    }

    public void setExpireTime(int expireTime) {
        this.expireTime = expireTime;
    }

    public long getTimeOut() {
        return timeOut;
    }

    public void setTimeOut(long timeOut) {
        this.timeOut = timeOut;
    }
}


properties文件redis部分：


## redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.database=9
spring.redis.password=
#缓存的类型
spring.cache.type=redis

# redis lettuce配置
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.shutdown-timeout=100ms


 

























你可能感兴趣的:(Redis,springboot2.x,分布式锁)






    

  • Redis系列：Geo 类型赋能亿级地图位置计算
Ly768768
redisbootstrap数据库

    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    

    • 

  • 华为云分布式缓存服务DCS 8月新特性发布
华为云PaaS服务小智
华为云分布式缓存

    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    

    • 

  • Redis Key的过期策略
ArchManual
分布式架构分布式Java后端微服务架构redis

    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
    

    • 

  • Redis:缓存击穿
我的程序快快跑啊
缓存redisjava

    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    

    • 

  • Redis 有哪些危险命令？如何防范？
花小疯
redis缓存数据库危险命令大数据

    Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
    

    • 

  • 分布式锁和spring事务管理
暴躁的鱼
锁及事务分布式springjava

    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    

    • 

  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
朱杰jjj
缓存分布式

    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
    

    • 

  • Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商
weixin_34302561
数据库devops大数据

    1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
    

    • 

  • 华为云分布式缓存服务DCS与开源服务差异对比
hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端

    分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
    

    • 

  • 关于Redis集群同步/持久化/淘汰机制的详解
尾巴尖上的阳光
大数据redis数据库

    Redis是非常常用的KV数据库,使用内存以及HashMap进行存储的特点带来了高效的查询.本文将围绕Redis的常见开发使用场景,阐述在Redis集群中各个节点是如何进行数据同步,每个节点如何进行持久化以及在长期使用中如何对数据进行更新和淘汰.如果对Redis有更多的兴趣,可以查看我的技术博客:https://dingyuqi.com下面是Redis在开发过程中常用的几种使用场景.集群Redis
    

    • 

  • 主流行架构
rainbowcheng
架构架构

    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    

    • 

  • 网上商城项目总结 续
猫只i
javaweb电子商城结构

    前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
    

    • 

  • 常用类库 Guava 简介
豆瑞瑞
java

    简介GoogleGuava是一个由Google开发的Java开源函数库。前身是GoogleCollectionsLibrary，提供了许多简化工具，如缓存、连接器、过滤器、关联数组等仓库代码GitCode-全球开发者的开源社区,开源代码托管平台参考https://github.com/google/guavahttps://github.com/google/guava/wikiRedisStre
    

    • 

  • 2024Mysql And Redis基础与进阶操作系列（8）作者——LJS[含MySQL 创建、修改、跟新、重命名、删除视图等具体详步骤；注意点及常见报错问题所对应的解决方法]
肾透侧视攻城狮
MYSQLREDISAdvanceoperationredismysql数据库linuxsqlbashadb

    目录1MySQL视图1.概念2.作用3.特点4.具体如何操作实现MYSQL视图4.1创建视图语法示例查看表和视图查看视图的结构查看视图属性信息（比如：显示数据表的存储引擎、版本、数据行数和数据大小等）查看视图的详细定义信息4.2修改视图简介格式举例4.3更新视图简介下述结构中不可更新的视图补充说明举例更新视图视图包含聚合函数不可更新视图包含distinct不可更新视图包含goupby、having
    

    • 

  • 自定义布隆过滤器解决缓存穿透
暗金烂狗
缓存

    什么是缓存穿透以及常见解决方案缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库，导致数据库压力提高，造成宕机。缓存穿透就是指用户访问那些在数据库和Redis中都不存在的数据，例如我们知道id采用自增策略，那么就不可能出现负数id，而如果不法分子使用负数id进行查询，那么这些请求都会穿过Redis直接向数据库发送请求，从而导致数据库压力骤增，导致数
    

    • 

  • Redis 为什么这么快？
小海海不怕困难
Redisredis

    决定Redis请求效率的因素主要是三个方面，分别是网络、cpu、内存。在网络层面，Redis采用多路复用的设计，提升了并发处理的连接数，不过这个阶段，Server端的所有IO操作，都是由同一个主线程处理的这个时候IO的瓶颈就会影响到Redis端的整体处理性能。所以从Redis6.0开始，在多路复用及层面增加了多线程的处理，来优化IO处理的能力不过，具体的数据操作仍然是由主线程来处理的，所以我们可以
    

    • 

  • Redis 集群
確定饿的猫
redislinux

    目录Redis主从复制Redis主从复制简介Redis主从复制的作用Redis主从复制流程搭建Redis主从复制master节点slave节点验证哨兵故障转移机制部署哨兵Redis集群作用数据分区高可用Redis集群Redis高可用实现的方式有持久化、主从复制、哨兵、集群，与持久化不同，另外三种方式都是属于集群，之前已经分析了解过两种持久化模式了，现在了解另外几种方式Redis主从复制Redis主
    

    • 

  • Redisson分布式锁实现原理和使用
牧竹子
springboot#redisRedissonredis

    常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
    

    • 

  • 分布式框架Celery七(Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警)
yjjpp2301
Celery分布式djangopython后端

    Django中集成方式安装模块pipinstallDjango==3.2.22pipinstallcelerypipinstallredispipinstalleventlet#在windows环境下需要安装eventlet包-----------pipinstalldjango-celery-beatpipinstalldjango-celery-resultspipinstalldjango-
    

    • 

  • Redis的持久化和高可用性
小辛学西嘎嘎
redis数据库缓存

    目录一、淘汰策略1、背景2、淘汰策略二、持久化1、背景2、fork进程写时复制机制3、Redis持久化方式1、aof2、rdb三、高可用1、主从复制2、Redis哨兵模式3、Rediscluster集群一、淘汰策略1、背景首先Redis是一个内存数据库，将所有数据存放在内存中，通过对K值进行hash后存储在散列表中。有一个小问题Redis数据库占96G，但为什么最终占满只有48G呢。因为中间有个过
    

    • 

  • 【Redis】Redis缓存
1886i
JavaRedis缓存redis数据库

    目录一、缓存1、概念2、作用3、缺点二、缓存模型三、缓存的更新1、更新策略2、主动更新的三种模式1.cacheasidepattern2.read/writethroughpattern3.writebehindcachingpattern3、线程安全问题1.缓存删除还是更新缓存2.先删除缓存后操作数据库3.先操作数据库后删除缓存4.如何保证缓存与数据库操作同时成功或失败4、最佳选择一、缓存1、概
    

    • 

  • Windows系统下安装Redis
bjzhang75
windowsredis数据库

    文章目录1、下载Redis安装包2、解压压缩包3、运行Redis4、Redis连接检测5、Redis相关设置5.1设置环境变量PATH5.2Redis配置文件修改1、下载Redis安装包Windows版本的Redis可以在Github中下载：下载Redis2、解压压缩包将下载的压缩包解压到某个目录下，比如：C:\redis。3、运行Redis在cmd窗口中运行命令redis-serverredis
    

    • 

  • 实现多级缓存的六种策略方法
Kixuan214
缓存redisrabbitmq

    保证多级缓存数据一致性是一个复杂的任务，尤其是在分布式和高并发环境中。以下是一些常见的方法和策略，可以帮助实现多级缓存的数据一致性1.缓存失效策略1.1主动失效在更新数据库时，主动使相关缓存失效。步骤：更新数据库删除或失效缓存publicclassCacheService{privateLocalCachelocalCache;privateRedisCacheredisCache;private
    

    • 

  • redis-shake v4全量增量同步redis数据
nangonghen
redisredis数据库缓存redis-shake

    1概述RedisShake是一个用于处理和迁移Redis数据的工具，github地址是https://github.com/tair-opensource/RedisShake。它提供以下特性：1）Redis兼容性：RedisShake兼容从2.8到7.2的Redis版本，并支持各种部署方式，包括单机，主从，哨兵和集群。2）云服务兼容性：RedisShake与主流云服务提供商提供的流行Redis-
    

    • 

  • redis,codis,云redis
shuff1e

    redis的分布式解决方式--codis（转）https://www.cnblogs.com/softidea/p/5365640.htmlhttps://help.aliyun.com/document_detail/57797.html?spm=5176.173352.925244.2.bF70Gb
    

    • 

  • Redis总结（八）redis单线程还是多线程问题
卢小记

    redis为什么可以支持高并发和它内部的工作模式有不可分割的关系：绝大部分请求是纯粹的内存操作（非常快速）采用单线程,避免了不必要的上下文切换和竞争条件非阻塞IO-IO多路复用Redis客户端对服务端的每次调用都经历了发送命令，执行命令，返回结果三个过程。其中执行命令阶段，由于Redis是单线程来处理命令的，所有到达服务端的命令都不会立刻执行，所有的命令都会进入一个队列中，然后逐个执行，并且多个客
    

    • 

  • Java 使用 Redis
lly202406
开发语言

    Java使用Redis1.引言Redis是一个开源的高性能键值对数据库。它支持多种类型的数据结构，如字符串、列表、集合、散列表等，适用于多种场景，如缓存、消息队列等。Java是一种广泛使用的编程语言，它在企业级应用中有着广泛的应用。在Java应用中，使用Redis可以提高数据访问速度，减轻数据库的压力。本文将介绍如何在Java应用中使用Redis。2.准备工作在开始使用Redis之前，需要确保已经
    

    • 

  • Redis数据结构—跳跃表 skiplist
马卫斌 前端工程师
skiplist

    跳跃表（Skiplist）是Redis中用于实现有序集合（SortedSet）的一种高效数据结构。以下是关于Redis中跳跃表（Skiplist）的关键特性和工作原理的概览：基本概念层级结构：跳跃表通过多层次的链表组成，每一层都是下一层的稀疏视图，顶层最快地遍历整个链表，而底层则是完全连通所有节点的传统链表结构。这样的设计使得查询操作能够快速跳过大量不需要检查的元素。有序集合：每个节点（或称为元素
    

    • 

  • Redis安装详解（单机安装，sentinel哨兵模式，Cluster模式）
dream21st
中间件学习笔记sentinelredisjava

    文章目录1Redis单机安装1.1windows中安装1.2linux中安装2Redis主从复制安装3Redis哨兵模式安装4Springboot项目操作RedisSentinel集群5官方cluster分区搭建5.1部署架构5.2RedisCluster的优势5.3集群搭建6Springboot项目操作Cluster集群1Redis单机安装Redis安装包可以从官网下载，也可以在redis的官方
    

    • 

  • Redis哨兵模式(Sentinel)详解
水木渔樵
Redisredis

    目录文章目录一、Sentinel1.何为Sentinel2.Sentinel启动流程当一个Sentinel启动时，它需要执行以下步骤：2.1初始化服务器2.2使用Sentinel专用代码2.3初始化Sentinel状态2.4初始化Sentinel状态的masters属性2.5创建连向主服务器的网络连接3.Sentinel获取主服务器信息4.Sentinel获取从服务器信息5.Sentinel与主从
    

    • 

  • 解线性方程组
qiuwanchi

    package gaodai.matrix;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Sc
    

    • 

  • 在mysql内部存储代码
annan211
性能mysql存储过程触发器

    
在mysql内部存储代码
在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。
先看优点：
1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。
2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。
3 可以简化代码的维护和版本更新。
4 可以帮助提升安全，比如提供更细
    

    • 

  • Android使用Asynchronous Http Client完成登录保存cookie的问题
hotsunshine
android

    Asynchronous Http Client是android中非常好的异步请求工具
除了异步之外还有很多封装比如json的处理，cookie的处理
引用
Persistent Cookie Storage with PersistentCookieStore
This library also includes a PersistentCookieStore whi
    

    • 

  • java面试题
Array_06
java面试

    java面试题
第一，谈谈final, finally, finalize的区别。
final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
    

    • 

  • 网站加速
oloz
网站加速

    前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教.
1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。
2、采用Gzip对网页进行压缩；
   GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
    

    • 

  • 正确书写单例模式
随意而生
java 设计模式 单例

    　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。
　　懒汉式，线程不安全
　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
    

    • 

  • 单例模式
香水浓
java

    懒汉  调用getInstance方法时实例化
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if(null == ins
    

    • 

  • 安装Apache问题：系统找不到指定的文件 No installed service named "Apache2"
AdyZhang
apachehttp server

    安装Apache问题：系统找不到指定的文件 No installed service named "Apache2"
每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。
解决方法确保几处：
1、停止IIS启动
2、把端口80改成其它 （譬如90，800，，，什么数字都好）
3、防火墙(关掉试试)
在运行处输入 cmd 回车，转到apa
    

    • 

  • 如何在android 文件选择器中选择多个图片或者视频？
aijuans
android

    我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传
但是android原生态的sdk中，只能一个一个的进行选择和上传。
我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个 处理方法
官方的图片选择器(但是不支持所有版本的androi，只支持API Level 
    

    • 

  • mysql中查询生日提醒的日期相关的sql
baalwolf
mysql

    SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(),  dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
    

    • 

  • MongoDB索引文件破坏后导致查询错误的问题
BigBird2012
mongodb

    问题描述：
MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。
解决方案：
 
使用脚本，重建MongoDB所有表的索引。
var names = db.getCollectionNames();
for( var i in names ){
var name = names[i];
print(name); 
    

    • 

  • Javascript Promise
bijian1013
JavaScriptPromise

            Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。
一.认识Promises
        “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
    

    • 

  • [Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程
bit1129
zookeeper

       Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是  
 
public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
    

    • 

  • 【Java命令三】jstack
bit1129
jstack

    jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump
 
[hadoop@hadoop sbin]$ jstack
Usage:
jstack [-l] <pid>
(to connect to running process)
jstack -F 
    

    • 

  • jboss 5.1启停脚本　动静分离部署
ronin47

    以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename  -b ip -g  clustername   -u broatcast jboss.messaging.ServerPeerID=int  -Djboss.service.binding.set=p
    

    • 

  • UI之如何打磨设计能力?
brotherlamp
UIui教程ui自学ui资料ui视频

     
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。
1.找到自己的方式
如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
    

    • 

  • 三色旗算法
bylijinnan
java算法

    
import java.util.Arrays;
/**
问题：
假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，
您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳
子上进行这个动作，而且一次只能调换两个旗子。
网上的解法大多类似：
在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
    

    • 

  • 警告:No configuration found for the specified action: \'s
chiangfai
configuration

    1.index.jsp页面form标签未指定namespace属性。
<!--index.jsp代码-->
<%@taglib prefix="s" uri="/struts-tags"%>
...
<s:form action="submit" method="post"&g
    

    • 

  • redis -- hash_max_zipmap_entries设置过大有问题
chenchao051
redishash

    使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑
 
#define ZIPMAP_BIGLEN 254
#define ZIPMAP_END 255
 
 
/* Return th
    

    • 

  • select into outfile access deny问题
daizj
mysqltxt导出数据到文件

    本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/
为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。
授权的语句如下：
grant select on armory.* to rn
    

    • 

  • phpexcel导出excel表简单入门示例
dcj3sjt126com
PHPExcelphpexcel

    
<?php
error_reporting(E_ALL);
ini_set('display_errors', TRUE);
ini_set('display_startup_errors', TRUE);
 
if (PHP_SAPI == 'cli')
die('This example should only be run from a Web Brows
    

    • 

  • 美国电影超短200句
dcj3sjt126com
电影

    1. I see． 我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too． 我也是。5. My god! 天哪!6. No way! 不行!7. Come on． 来吧(赶快)8. Hold on． 等一等。9. I agree。 我同意。10. Not bad． 还不错。11. Not yet． 还没。12. See you． 再见。13. Shut up! 
    

    • 

  • Java访问远程服务
dyy_gusi
httpclientwebservicegetpost

        随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
    

    • 

  • Maven的settings.xml配置
geeksun
settings.xml

    settings.xml是Maven的配置文件，下面解释一下其中的配置含义：
settings.xml存在于两个地方：
1.安装的地方：$M2_HOME/conf/settings.xml
2.用户的目录：${user.home}/.m2/settings.xml
前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。

    

    • 

  • ubuntu的init与系统服务设置
hongtoushizi
ubuntu

    转载自： 
http://iysm.net/?p=178 init
Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。
ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。
运行
    

    • 

  • 跟我学Nginx+Lua开发目录贴
jinnianshilongnian
nginxlua

    使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。 
  目录
第一章 安装Nginx+Lua开发环境
第二章 Nginx+Lua开发入门
第三章 Redis/SSDB+Twemproxy安装与使用
第四章 L
    

    • 

  • php位运算符注意事项
home198979
位运算PHP&

    $a = $b = $c = 0;
$a & $b = 1;
$b | $c = 1
 问a,b,c最终为多少?
 
当看到这题时，我犯了一个低级错误，误 以为位运算符会改变变量的值。所以得出结果是1 1 0
但是位运算符是不会改变变量的值的，例如：
$a=1;$b=2;
$a&$b;
 这样a,b的值不会有任何改变

    

    • 

  • Linux shell数组建立和使用技巧
pda158
linux

    1.数组定义 　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。 　　
2.数组读取与赋值 　　得到长度： 　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
    

    • 

  • hotspot源码(JDK7)
ol_beta
javaHotSpotjvm

    源码结构图，方便理解：
 
├─agent                            Serviceab
    

    • 

  • Oracle基本事务和ForAll执行批量DML练习
vipbooks
oraclesql

    基本事务的使用：
从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚
select * from account;
-- 创建一张账户表
create table account(
-- 账户ID
id number(3) not null,
-- 账户名称
nam
    

    •