Redis知识点总结

最新推荐文章于 2022-05-02 15:56:04 发布
最新推荐文章于 2022-05-02 15:56:04 发布
阅读量162 收藏
点赞数
分类专栏： Java 数据库
Java 同时被 2 个专栏收录
120 篇文章 0 订阅
订阅专栏
数据库
23 篇文章 3 订阅
订阅专栏

Redis优势：

  1. 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
  2. 丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
  3. 原子 – Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。
  4. 丰富的特性 – Redis还支持 publish/subscribe 通知, key 过期等等特性
  5. 支持事务

与memcached相比：
1. memcached所有的值均是简单字符串,redis支持丰富的数据类型
2. redis速度比memcached快很多
3. redis可持久化其数据

Redis支持五种数据类型：string（字符串）、hash（map< string, string>）、list（链表）、set（没有排序的集合）、zset（有序集合）

redis客户端连接：
redis-cli -h 127.0.0.1 -p 6380
redis客户端连接集群：
redis-cli -c -h 127.0.0.1 -p 6379

Redis多数据库操作：

主要为了防止key冲突问题，默认情况下，客户端连接到数据库0，可通过修改配置文件redis.conf下的参数来进行修改：
databases 16
可通过select <数据库ID>来进行修改，每个数据库都有自己单独的空间，不用担心key冲突问题。

例子

key相关命令

flushdb　　　　　　　　　　 #清空当前选择的数据库
flushall 　　　　　　　　　　 #清空所有数据库
move key1 1　　　　　　　　#将当前数据库的key1移动到ID为1的数据库中
rename oldkey newkey　　　#将oldkey改名为newkey
renamenx oldkey newkey　　#如果newkey已存在，则无效
expire key 1 100　　　　　　 #把key1的过期时间设置为100秒
persist key1　　　　　　　　  #把key1的超时去掉，变成持久化的键
keys my*　　　　　　　　　　#获取数据库中以my开头的key
exists key1　　　　　　　　　#存在key1返回1，否则返回0
select 0　　　　　　　　　　  #打开ID为0的数据库

Java连redis集群的例子：

RedisClusterConnection.java

public class RedisClusterConnection {
    private static Logger LOG = LogManager
        .getLogger(RedisClusterConnection.class);

    private static JedisCluster jedisCluster;

    private static Pattern p = Pattern.compile("^.+[:]\\d{1,5}\\s*$");

    private static Set<HostAndPort> parseHostAndPort() {
        InputStream in = null;
        try {
            Properties properties = new Properties();
            in = ClassLoader.getSystemClassLoader().getResourceAsStream(
                    "redis-config.properties");
            properties.load(in);
            Set<HostAndPort> haps = new HashSet<HostAndPort>();
            for (Object key : properties.keySet()) {
                if (!key.toString().startsWith("redis.address")) {
                    continue;
                }
                String val = properties.get(key).toString();
                boolean isIpPort = p.matcher(val).matches();
                if (!isIpPort) {
                    throw new IllegalArgumentException("ip 或 port 不合法");
                }

                String[] ipAndPort = val.split(":");
                HostAndPort hap = new HostAndPort(ipAndPort[0],
                        Integer.parseInt(ipAndPort[1]));
                haps.add(hap);
            }
            return haps;
        } catch (InvalidPropertiesFormatException e) {
            LOG.error(e);
        } catch (IOException e1) {
            LOG.error(e1);
        } catch (Exception e2) {
            LOG.error(e2);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    public static JedisCluster getInstance() {
        Set<HostAndPort> haps = parseHostAndPort();
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(1024);
        poolConfig.setMaxIdle(10);
        poolConfig.setMaxWaitMillis(1800000L);
        poolConfig.setTimeBetweenEvictionRunsMillis(180000L);
        poolConfig.setTestOnBorrow(true);

        jedisCluster = new JedisCluster(haps, poolConfig);
        return jedisCluster;
    }

    public static void main(String[] args) {
        Set<HostAndPort> set = parseHostAndPort();
        Iterator<HostAndPort> iterator = set.iterator();
        while (iterator.hasNext()) {
            HostAndPort hap = iterator.next();
            System.out.println(hap.getHost() + ":" + hap.getPort());
        }

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73

redis-config.properties

#redis集群
redis.address1=192.168.0.1:6379
redis.address2=192.168.0.1:6380
redis.address3=192.168.0.1:6381
redis.address4=192.168.0.1:6382
redis.address5=192.168.0.1:6383
redis.address6=192.168.0.1:6384
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Redis持久化方式：

  1. RDB
    在指定时间间隔内生成数据集的时间点快照。
    　优点：RDB是一个非常紧凑的文件，它保存了Redis在某个时间点上的数据集。非常适合用于进行备份：比如：每小时备份一次RDB文件，遇上问题可随时还原数据集到不同的版本。非常适合灾难恢复：它只有一个文件,并且内容紧凑，可传输到其他地方。RDB在恢复大数据集时的速度比AOF的恢复速度快；RDB可最大化redis性能，父进程保存RDB文件时要做的是fork一个子进程，然后子进程处理接下来的保存操作，父进程无须执行任何磁盘I/O操作。
    　缺点：如需要尽量避免在服务器故障时丢失数据，RDB不适合。每隔一段时间保存数据集的状态，一旦故障会丢失这部分数据。每次保存RDB时，redis都要fork()一个子进程，并由子进程进行实际的持久化工作。在数据集庞大时，fork()会很耗时,造成服务器在某毫秒内停止处理客户端。
    　
    redis.conf里rdb相关配置：
    save 900 1 # 900秒有1个更改，进行数据同步
    save 300 10 # 300秒有10个更改，进行数据同步
    save 60 10000 # 60秒有10000更改，进行数据同步
    dbfilename dump.rdb # 指定rdb备份数据的文件名

  2. AOF
    记录服务器执行的所有写操作命令,并在服务器启动时，通过重新执行这些命令来还原数据库
    　优点：让redis更耐久，你可以设置不同的 fsync 策略，比如无 fsync ，每秒钟一次 fsync ，或者每次执行写入命令时 fsync 。 AOF 的默认策略为每秒钟 fsync 一次，在这种配置下，Redis 仍然可以保持良好的性能，并且就算发生故障停机，也最多只会丢失一秒钟的数据（ fsync 会在后台线程执行，所以主线程可以继续努力地处理命令请求）。AOF 文件是一个只进行追加操作的日志文件（append only log）， 因此对 AOF 文件的写入不需要进行 seek ， 即使日志因为某些原因而包含了未写入完整的命令（比如写入时磁盘已满，写入中途停机，等等）， redis-check-aof 工具也可以轻易地修复这种问题。Redis 可以在 AOF 文件体积变得过大时，自动地在后台对 AOF 进行重写： 重写后的新 AOF 文件包含了恢复当前数据集所需的最小命令集合。 整个重写操作是绝对安全的，因为 Redis 在创建新 AOF 文件的过程中，会继续将命令追加到现有的 AOF 文件里面，即使重写过程中发生停机，现有的 AOF 文件也不会丢失。 而一旦新 AOF 文件创建完毕，Redis 就会从旧 AOF 文件切换到新 AOF 文件，并开始对新 AOF 文件进行追加操作。AOF 文件有序地保存了对数据库执行的所有写入操作， 这些写入操作以 Redis 协议的格式保存， 因此 AOF 文件的内容非常容易被人读懂， 对文件进行分析（parse）也很轻松。 导出（export） AOF 文件也非常简单： 举个例子， 如果你不小心执行了 FLUSHALL 命令， 但只要 AOF 文件未被重写， 那么只要停止服务器， 移除 AOF 文件末尾的 FLUSHALL 命令， 并重启 Redis ， 就可以将数据集恢复到 FLUSHALL 执行之前的状态。
    　缺点：对于相同的数据集来说，AOF 文件的体积通常要大于 RDB 文件的体积。根据所使用的 fsync 策略，AOF 的速度可能会慢于 RDB 。 在一般情况下， 每秒 fsync 的性能依然非常高， 而关闭 fsync 可以让 AOF 的速度和 RDB 一样快， 即使在高负荷之下也是如此。

    redis.conf里AOF的相关配置：
    　appendonly yes //启用aof持久化方式
    　appendfilename appendonly.aof // 更新日志文件名，默认为appendonly.aof
    　appendfsync always //每次收到写命令就立即强制写入磁盘，最慢的，但是保证完全的持久化，不推荐使用
    　appendfsync everysec //每秒钟强制写入磁盘一次，在性能和持久化方面做了很好的折中，推荐
    　appendfsync no //完全依赖os，性能最好,持久化没保证

Redis备份与恢复

save、bgsave ——备份
config get dir ——得到redis安装目录
此时在redis安装目录下会有一个“dump.rdb”文件，将此文件拷贝到redis安装目录，重新启动redis即可。启用AOF后会在安装目录生成“appendonly.aofappendonly.aof”文件，AOF文件拷贝到redis安装目录即可。

redis工具

redis-benchmark：性能检测工具
-h <hostname>      Server hostname (default 127.0.0.1)  
-p <port>          Server port (default 6379)  
-s <socket>        Server socket (overrides host and port)  
-c <clients>       Number of parallel connections (default 50)  
-n <requests>      Total number of requests (default 10000)  
-d <size>          Data size of SET/GET value in bytes (default 2)  
-k <boolean>       1=keep alive 0=reconnect (default 1)  
-r <keyspacelen>   Use random keys for SET/GET/INCR, random values for SADD  
  Using this option the benchmark will get/set keys  
  in the form mykey_rand:000000012456 instead of constant  
  keys, the <keyspacelen> argument determines the max  
  number of values for the random number. For instance  
  if set to 10 only rand:000000000000 - rand:000000000009  
  range will be allowed.  
-P <numreq>        Pipeline <numreq> requests. Default 1 (no pipeline).  
-q                 Quiet. Just show query/sec values 只显示每秒钟能处理多少请求数结果  
--csv              Output in CSV format  
-l                 Loop. Run the tests forever 永久测试  
-t <tests>         Only run the comma separated list of tests. The test  
                    names are the same as the ones produced as output.  
-I                 Idle mode. Just open N idle connections and wait.
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
redis-check-dump

作用：检查本地数据文件
redis-check-dump dump.rdb
redis-check-dump例子

redis-check-aof

作用：更新日志检查，加–fix 进行修复
redis-check-aof appendonly.aof
redis-check-aof例子

飞翔的迈克
关注
专栏目录
Redis知识点总结归纳
悟已往之不谏，知来者之可追
01-26 485
Redis Redis 一、概述 二、数据类型 STRING LIST SET HASH ZSET 三、数据结构 字典 跳跃表 四、使用场景 计数器 缓存 查找表 消息队列 会话缓存 分布式锁实现 其它 五、Redis 与 Memcached 数据类型 数据持久化 分布式 内存管理机制 六、键的过期时间 七、数据淘汰策略 八、持久化 RDB 持久化 AOF 持久化 九、事务 十、事件 文件事件 时间事件 事件的调度与执行 十一、复制 连接过程 主从链 十二、S
redis知识点总结
selfimpr1的博客
11-03 1026
1.什么是Redis redist是一个key-value形式的非关系型数据库。 2.redis的数据类型 string(字符串，整数，浮点)、list(列表)、set(无序集合)、zset(有序集合)、hash(哈希) 3.Redis有哪些优缺点 优点： 读写性能优异， Redis能读的速度是110000次/s，写的速度是81000次/s。 支持数据持久化，支持AOF和RDB两种持久化方式。 支持事务，Redis的所有操作都是原子性的，同时Redis还支持对几个操作合并后的原子性执行。
Redis重要知识点
范栩的博客
02-14 654
Redis重要知识点 缓存穿透、雪崩、缓存击穿 缓存穿透 ==描述：==大量查询缓存中和数据库中都没有的数据，就会导致数据库的访问量变大，容易出现问题。 ==解决方法：==遇到缓存和数据库中都没有值的数据，就在缓存中设置一个空值，并且设置一个过期的时间，这样就不会大量的访问到数据库。而且当数据库中有这个值了，因为过期时间的存在，缓存也会更新这个正确的值。 雪崩 ==描述：==在缓存中，大面积的数据，同时过期，这时数据库的压力就会骤增，如果严重的话，数据库可能就会崩掉 解决办法： 在设置数据过期时间的时候，可
常见 Redis 知识点
qq_50840738的博客
03-29 1679
常见 Redis 知识点 1、Redis有哪些基本数据结构？ String、Hash、List、Set、SortedSet 它还有三种特殊的数据结构类型 Geospatial（地理空间，经纬度）、Hyperloglog（基数统计）、Bitmap（位图） 2、如果有大量的 key 需要设置同一时间过期，一般需要注意什么？ 如果大量的key过期时间设置的过于集中，到过期的那个时间点，Redis可能会出现短暂的卡顿现象。严重的话会出现缓存雪崩，我们一般需要在时间上加一个随机值，使得过期时间分散一些。 3、Redi
redis知识点介绍
tttalk的博客
12-30 3645
一、redis介绍 Redis是一种NoSQL数据库（多用于解决解决高并发、高可用、高可扩展、大数据存储问题。NoSQL可以作为关系型数据库的良好补充，但是不能替代关系型数据库。） 常见NoSQL数据库分类: 分类 相关产品 应用场景 数据模型 优点 键值存储数据库 Redis、Memcached 内容缓存，如会话、配置文件、参数等；频繁读写、拥有简单数据模型的应用 键值对 扩展性好，灵活性好，大量操作时性能高 列存储数据库 Cassandra(AP)、HBase(CP)、Clickho
redis知识点总结与分布式锁的实现
Linuxhus的博客
07-20 206
1. 常用命令 为指定key设置过期时间：expire key seconds 设置key对应的value，并设置过期时间：setex key seconds value 查询指定key剩余过期时间：ttl key 返回指定key的value类型：type key 为指定key修改key名称：rename oldkey newkey setnx key value：设置key和value值，若当前key不存在时，若存在则不执行该操作 文章相关视频讲解： C/C++ Linux服务器开发高级架
Redis知识点重点总结
最新发布
09-27
**Redis知识点重点总结** Redis，全称Remote Dictionary Server，是一个高性能的键值对存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。它以文本协议提供服务，支持多种数据结构，如字符串、哈希、列表...
Redis理论知识
XGkerwin1的博客
04-24 605
简介 Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings），散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了复制（replication），LUA脚本（Lua scripting），LRU驱动事件（LRU eviction
缓存穿透、缓存击穿、缓存雪崩、缓存一致性的区别和解决方案
XGkerwin1的博客
04-20 299
缓存雪崩 大量的key设置了相同的过期时间，导致在缓存在同一时间全部失效，引起数据库压力过大甚至down机。 和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。 解决方案 缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。 如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。 设置热点数据永远不过期。 使用高可用的分布式缓存集群，确保缓存的高可用性 缓存击穿 对于一些设置了过期时间的key，如果这些key可能会在某
redis---理论知识
菜鸟kevin的成长日志
04-07 236
入门 http://blog.csdn.net/guchuanyun111/article/details/52057407（1） http://blog.csdn.net/guchuanyun111/article/details/52064870（3） 数据类型: https://blog.csdn.net/guchuanyun111/article/details/52067...
Redis 基本理论知识
bad_boy的博客
06-22 339
1. Redis应用场景 分布式会话缓存 分布式锁 发布/订阅 排行榜/计数器 队列 全页缓存 缓存热点数据 2. 更新正确方法 先更新数据库，再删除缓存 3. 高并发引起的问题 缓存穿透：缓存和数据库都不存在的key，流量过高导致DB挂掉 解决方案：（常用）访问key未在DB查询到的值，也将空值写进缓存，但设置过期时间 采用布隆过滤器，不存在的key直接被过滤掉 缓存击穿：缓存中没有，数据库中有，直接去数据库中取数据，数据库压力过大导致挂掉（并发查询一条数据） 解决方案：设置热点数据永不过期；加互斥
Redis常用的理论知识
HelloWorldBegin
05-02 192
redis基础知识
在分布式数据库中CAP原理CAP+BASE
z_haitao的博客
11-09 695
关系型数据库遵循ACID规则 事务在英文中是transaction，和现实世界中的交易很类似，它有如下四个特性：   1、A (Atomicity) 原子性 原子性很容易理解，也就是说事务里的所有操作要么全部做完，要么都不做，事务成功的条件是事务里的所有操作都成功，只要有一个操作失败，整个事务就失败，需要回滚。比如银行转账，从A账户转100元至B账户，分为两个步骤：1）从A账户取100元；
redis核心知识点总结（超详细）
不积硅步，无以至千里
03-24 4236
redis核心知识点总结，超详细
Redis知识点全面汇总
qq_40126996的博客
09-17 910
系列文章目录 文章目录系列文章目录前言一、数据结构1.字符串2.链表3.字典4.跳跃表5.整数二、持久化机制1.RDB2.AOF三、主从复制旧版：SYNC1、同步2、命令传播新版：PSYNC1、完整重同步2、部分重同步四、哨兵概念：实现：五、集群过程：六、事务实现方法过程WATCH命令实现七、缓存三大问题缓存雪崩缓存穿透缓存击穿八、分布式锁总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学
Redis经常理论知识
qq_38383302的博客
08-24 146
Redis有哪些数据结构呀？ String、Hash、List、Set、SortedSet。 Redis使用场景？ 计数器可以对 String 进行自增自减运算，从而实现计数器功能。Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。 缓存将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。 会话缓存可以使用 Redis 来统一存储多台应用服务器的会话信息。当应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器，从而..
redis理论知识总结
ITCSDN_的博客
08-02 292
redis理论知识 1. 什么是缓存雪崩？怎么解决？ 通常，会使用缓存用于缓冲对 DB 的冲击。 但是如果缓存宕机，所有请求将直接打在 DB，造成 DB 宕机——从而导致整个系统宕机，这就是缓存雪崩。 如何解决呢？ 对缓存做高可用：搭建redis集群，防止缓存宕机 限流降级：使用断路器，如果缓存宕机，为了防止系统全部宕机，限制部分流量（通过加锁或者队列来控制线程数量）进入DB，保证部分可用，其余的请求返回断路器的默认值。 数据预热：在正式部署之前，先将可能的数据预先进行访问一遍，将大部分的数据都加载
Golang、MySQL与Redis面试必备知识点总结
本资源集合了面试中针对Go语言（Golang）、MySQL数据库和Redis缓存系统的一些常见知识点，旨在帮助面试者在面试过程中更好地展示自己的能力，同时也为技术面试官提供了一个参考标准。 首先，让我们从Go语言（Golang...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值