更新Redis基础知识

Tyson0314 · Tyson0314 · commit b8e9ee6b6197 · 2021-09-14T00:09:28.000+08:00
diff --git a/Java/Java基础.md b/Java/Java基础.md
@@ -287,9 +287,92 @@ public class OuterClass {
 ### final
 
 1. **基本数据**类型用final修饰，则不能修改，是常量；**对象引用**用final修饰，则引用只能指向该对象，不能指向别的对象，但是对象本身可以修改。
+
 2. final修饰的方法不能被子类重写
+
 3. final修饰的类不能被继承。
 
+
+
+### this
+
+ `this.属性名称`指访问类中的成员变量，可以用来区分成员变量和局部变量。如下代码所示，`this.name`访问类Person当前实例的变量。
+
+```java
+/**
+ * @description:
+ * @author: 程序员大彬
+ * @time: 2021-08-17 00:29
+ */
+public class Person {
+    String name;
+    int age;
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+}
+```
+
+`this.方法名称`用来访问本类的方法。以下代码中，`this.born()`调用类 Person 的当前实例的方法。
+
+```java
+/**
+ * @description:
+ * @author: 程序员大彬
+ * @time: 2021-08-17 00:29
+ */
+public class Person {
+    String name;
+    int age;
+
+    public Person(String name, int age) {
+        this.born();
+        this.name = name;
+        this.age = age;
+    }
+
+    void born() {
+    }
+}
+```
+
+
+
+### super
+
+super 关键字用于在子类中访问父类的变量和方法。 
+
+```java
+class A {
+    protected String name = "大彬";
+
+    public void getName() {
+        System.out.println("父类:" + name);
+    }
+}
+
+public class B extends A {
+    @Override
+    public void getName() {
+        System.out.println(super.name);
+        super.getName();
+    }
+
+    public static void main(String[] args) {
+        B b = new B();
+        b.getName();
+    }
+    /**
+     * 大彬
+     * 父类:大彬
+     */
+}
+```
+
+在子类B中，我们重写了父类的getName()方法，如果在重写的getName()方法中我们要调用父类的相同方法，必须要通过super关键字显式指出。
+
 ## object常用方法
 
 Java面试经常会出现的一道题目，Object的常用方法。下面给大家整理一下。
diff --git a/中间件/Redis入门指南总结.md b/中间件/Redis入门指南总结.md
@@ -69,6 +69,9 @@
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
+目录结构如下：
+
+![](https://gitee.com/tysondai/img/raw/master/image-20210914000822843.png)
 
 ## 简介
 
@@ -84,29 +87,11 @@ Redis是一个高性能的key-value数据库。Redis对数据的操作都是原
 4. 支持持久化。Redis支持RDB和AOF两种持久化机制，持久化功能有效地避免数据丢失问题。
 5. redis 采用IO多路复用技术。多路指的是多个socket连接，复用指的是复用一个线程。redis使用单线程来轮询描述符，将数据库的开、关、读、写都转换成了事件。多路复用主要有三种技术：select，poll，epoll。epoll是最新的也是目前最好的多路复用技术。
 
-缺点：
-
-对join或其他结构化查询的支持就比较差
-
-非关系型数据库适用场景：
-
-1. 数据高并发的读写
-2. 海量数据的读写
-3. 对扩展性要求高的数据
-
-关系型数据库适用场景：
-
-1. 存储结构化数据，如用户的帐号、地址。
-2. 数据需要做结构化查询，复杂查询
-3. 要求事务性、一致性
+缺点：对join或其他结构化查询的支持就比较差。
 
 ### io多路复用
 
-阻塞io：当你调用read时，如果没有数据收到，那么线程或者进程就会被挂起，直到收到数据。
-
-将用户socket对应的文件描述符（file description）注册进epoll，然后epoll帮你监听哪些socket上有消息到达。当某个socket可读或者可写的时候，它可以给你一个通知。只有当系统通知我哪个描述符可读了，我才去执行read操作，可以保证每次read都能读到有效数据而不做纯返回-1和EAGAIN的无用功。
-
-这样，多个描述符的I/O操作都能在一个线程内并发交替地顺序完成，这就叫I/O多路复用，这里的“复用”指的是复用同一个线程。
+将用户socket对应的文件描述符（file description）注册进epoll，然后epoll帮你监听哪些socket上有消息到达。当某个socket可读或者可写的时候，它可以给你一个通知。只有当系统通知哪个描述符可读了，才去执行read操作，可以保证每次read都能读到有效数据。这样，多个描述符的I/O操作都能在一个线程内并发交替地顺序完成，这就叫I/O多路复用，这里的复用指的是复用同一个线程。
 
 ### 应用场景
 
@@ -116,34 +101,12 @@ Redis是一个高性能的key-value数据库。Redis对数据的操作都是原
 4. 好友关系，利用集合的一些命令，比如求交集、并集、差集等。可以方便搞定一些共同好友、共同爱好之类的功能。
 5. 限速器，比较典型的使用场景是限制某个用户访问某个API的频率，常用的有抢购时，防止用户疯狂点击带来不必要的压力。
 
-![](../img/middleware/redis-usage.png)
-
-### Memcached
-
-与redis区别：
+### Memcached和Redis的区别
 
 1. Redis只使用单核，而Memcached可以使用多核。
 2. MemCached数据结构单一，仅用来缓存数据，而Redis支持更加丰富的数据类型，也可以在服务器端直接对数据进行丰富的操作，这样可以减少网络IO次数和数据体积。
 3. MemCached不支持数据持久化，断电或重启后数据消失。Redis支持数据持久化和数据恢复，允许单点故障。
 
-### 启动与停止
-
-**启动**
-
-切换目录到redis下，运行:
-`redis-server redis.windows.conf`
-
-若配置了环境变量，可直接运行`redis-server`
-
-新打开一个窗口，切换到redis目录下并运行（配置了环境变量可直接运行）
-`redis-cli -h 127.0.0.1 -p 6379`
-
->Linux下通过配置文件redis.conf设置deamonize yes允许后台进程，开启redis-server后控制台仍然可以接收输入。requirepass可以设置密码。
-
-**停止**
-
-`redis-cli SHUTDOWN`
-
 
 
 ## 数据类型
@@ -540,7 +503,7 @@ ziplist是 Redis 为了节约内存而开发的， 由一系列特殊编码的
 - 最底层的链表包含所有的元素
 - 跳跃表的查找次数近似于层数，时间复杂度为O(logn)，插入、删除也为 O(logn)
 
-![](../img/redis/redis-skiplist.png)
+![](https://gitee.com/tysondai/img/raw/master/redis-skiplist.png)
 
 #### 对象
 
@@ -582,7 +545,7 @@ hash类型内部编码有两种：
 
 Redis3.2版本提供了quicklist内部编码，简单地说它是以一个ziplist为节点的linkedlist，它结合了ziplist和linkedlist两者的优势，为列表类型提供了一种更为优秀的内部编码实现。
 
-![image-20201018203457076](../img/redis/list-api.png)
+![](https://gitee.com/tysondai/img/raw/master/list-api.png)
 
 使用场景：
 
@@ -667,7 +630,7 @@ GET #返回文章ID。
 
 3. EXEC命令进行提交事务
 
-![事务](https://img-blog.csdnimg.cn/20190125175715521.jpg)
+![](https://gitee.com/tysondai/img/raw/master/redis-multi.jpg)
 
 DISCARD：放弃事务，即该事务内的所有命令都将取消
 
@@ -690,7 +653,7 @@ QUEUED
 
 事务里的命令执行时会读取最新的值：
 
-![](../img/middleware/redis-transaction.png)
+![](https://gitee.com/tysondai/img/raw/master/redis-transaction.png)
 
 ### WATCH命令
 
@@ -837,7 +800,7 @@ SLAVEOF NO ONE //停止接收其他数据库的同步并转化为主数据库。
 5. 同步数据集。第一次同步的时候，从数据库启动后会向主数据库发送SYNC命令。主数据库接收到命令后开始在后台保存快照（RDB持久化过程），并将保存快照过程接收到的命令缓存起来。当快照完成后，Redis会将快照文件和缓存的命令发送到从数据库。从数据库接收到后，会载入快照文件并执行缓存的命令。以上过程称为复制初始化。
 6. 复制初始化完成后，主数据库每次收到写命令就会将命令同步给从数据库，从而实现主从数据库数据的一致性。
 
-![image-20201031160722595](../img/redis/redis-replication.png)
+![](https://gitee.com/tysondai/img/raw/master/redis-replication.png)
 
 Redis在2.8及以上版本使用psync命令完成主从数据同步，同步过程分为：全量复制和部分复制。
 
@@ -936,8 +899,6 @@ Redis集群内节点通过ping/pong消息实现节点通信，消息不但可以
 
 
 
-
-
 ## LUA脚本
 
 Redis 通过 LUA 脚本创建具有原子性的命令： 当lua脚本命令正在运行的时候，不会有其他脚本或 Redis 命令被执行，实现组合命令的原子操作。
@@ -971,7 +932,7 @@ redis 127.0.0.1:6379> EVALSHA "232fd51614574cf0867b83d384a5e898cfd24e5a" 0
 
 使用evalsha执行Lua脚本过程如下：
 
-![image-20201024233130770](E:/project/java/learn/Java-learning/img/redis/evalsha.png)
+![](https://gitee.com/tysondai/img/raw/master/evalsha.png)
 
 ### lua脚本作用
 
@@ -1008,56 +969,6 @@ RedisScript<Number> redisScript = new DefaultRedisScript<>(luaScript, Number.cla
 Number count = redisTemplate.execute(redisScript, keys, limit.count(), limit.period());
 ```
 
-
-
-## pipeline
-
-redis客户端执行一条命令分4个过程： 发送命令－〉命令排队－〉命令执行－〉返回结果。使用Pipeline可以批量请求，批量返回结果，执行速度比逐条执行要快。
-
-使用pipeline组装的命令个数不能太多，不然数据量过大，增加客户端的等待时间，还可能造成网络阻塞，可以将大量命令的拆分多个小的pipeline命令完成。
-
-原生批命令(mset, mget)与Pipeline对比：
-
-1. 原生批命令是原子性，pipeline是非原子性。pipeline命令中途异常退出，之前执行成功的命令不会回滚。
-
-2. 原生批命令只有一个命令, 但pipeline支持多命令。
-
-
-
-## 数据一致性
-
-缓存和DB之间怎么保证数据一致性：
-读操作：先读缓存，缓存没有的话读DB，然后取出数据放入缓存，最后响应数据
-写操作：先删除缓存，再更新DB
-为什么是删除缓存而不是更新缓存呢？
-
-1. 线程安全问题。同时有请求A和请求B进行更新操作，那么会出现(1)线程A更新了缓存(2)线程B更新了缓存(3)线程B更新了数据库(4)线程A更新了数据库，由于网络等原因，请求B先更新数据库，这就导致缓存和数据库不一致的问题。
-2. 如果业务需求写数据库场景比较多，而读数据场景比较少，采用这种方案就会导致，数据压根还没读到，缓存就被频繁的更新，浪费性能。
-3. 如果你写入数据库的值，并不是直接写入缓存的，而是要经过一系列复杂的计算再写入缓存。那么，每次写入数据库后，都再次计算写入缓存的值，无疑是浪费性能的。
-
-先删除缓存，再更新DB，同样也有问题。假如A先删除了缓存，但还没更新DB，这时B过来请求数据，发现缓存没有，去请求DB拿到旧数据，然后再写到缓存，等A更新完了DB之后就会出现缓存和DB数据不一致的情况了。
-
-解决方法：采用延时双删策略。更新完数据库之后，延时一段时间，再次删除缓存，确保可以删除读请求造成的缓存脏数据。评估项目的读数据业务逻辑的耗时。然后写数据的休眠时间则在读数据业务逻辑的耗时基础上，加几百ms即可。
-
-```java
-public void write(String key,Object data){
-    redis.delKey(key);
-    db.updateData(data);
-    Thread.sleep(1000);//确保读请求结束，写请求可以删除读请求造成的缓存脏数据
-    redis.delKey(key);
-}
-```
-
-可以将第二次删除作为异步的。自己起一个线程，异步删除。这样，写的请求就不用沉睡一段时间后了，加大吞吐量。
-
-当删缓存失败时，也会就出现数据不一致的情况。
-
-解决方法：
-
-![](../img/redis/cache-consist.png)
-
-
-
 ## 删除策略
 
 1. 被动删除。在访问key时，如果发现key已经过期，那么会将key删除。
@@ -1084,7 +995,9 @@ public void write(String key,Object data){
 
 
 
-## 客户端
+## 其他
+
+### 客户端
 
 Redis 客户端与服务端之间的通信协议是在TCP协议之上构建的。
 
@@ -1099,7 +1012,7 @@ OK
 
 
 
-## 慢查询
+### 慢查询
 
 Redis原生提供慢查询统计功能，执行`slowlog get{n}`命令可以获取最近的n条慢查询命令，默认对于执行超过10毫秒的命令都会记录到一个定长队列中，线上实例建议设置为1毫秒便于及时发现毫秒级以上的命令。慢查询队列长度默认128，可适当调大。
 
@@ -1120,3 +1033,49 @@ slowlog reset //重置，清理列表
 1. 修改为低时间复杂度的命令，如hgetall改为hmget等，禁用keys、sort等命令。
 2. 调整大对象：缩减大对象数据或把大对象拆分为多个小对象，防止一次命令操作过多的数据。
 
+### pipeline
+
+redis客户端执行一条命令分4个过程： 发送命令－〉命令排队－〉命令执行－〉返回结果。使用Pipeline可以批量请求，批量返回结果，执行速度比逐条执行要快。
+
+使用pipeline组装的命令个数不能太多，不然数据量过大，增加客户端的等待时间，还可能造成网络阻塞，可以将大量命令的拆分多个小的pipeline命令完成。
+
+原生批命令(mset, mget)与Pipeline对比：
+
+1. 原生批命令是原子性，pipeline是非原子性。pipeline命令中途异常退出，之前执行成功的命令不会回滚。
+
+2. 原生批命令只有一个命令, 但pipeline支持多命令。
+
+### 数据一致性
+
+缓存和DB之间怎么保证数据一致性：
+读操作：先读缓存，缓存没有的话读DB，然后取出数据放入缓存，最后响应数据
+写操作：先删除缓存，再更新DB
+为什么是删除缓存而不是更新缓存呢？
+
+1. 线程安全问题。同时有请求A和请求B进行更新操作，那么会出现(1)线程A更新了缓存(2)线程B更新了缓存(3)线程B更新了数据库(4)线程A更新了数据库，由于网络等原因，请求B先更新数据库，这就导致缓存和数据库不一致的问题。
+2. 如果业务需求写数据库场景比较多，而读数据场景比较少，采用这种方案就会导致，数据压根还没读到，缓存就被频繁的更新，浪费性能。
+3. 如果你写入数据库的值，并不是直接写入缓存的，而是要经过一系列复杂的计算再写入缓存。那么，每次写入数据库后，都再次计算写入缓存的值，无疑是浪费性能的。
+
+先删除缓存，再更新DB，同样也有问题。假如A先删除了缓存，但还没更新DB，这时B过来请求数据，发现缓存没有，去请求DB拿到旧数据，然后再写到缓存，等A更新完了DB之后就会出现缓存和DB数据不一致的情况了。
+
+解决方法：采用延时双删策略。更新完数据库之后，延时一段时间，再次删除缓存，确保可以删除读请求造成的缓存脏数据。评估项目的读数据业务逻辑的耗时。然后写数据的休眠时间则在读数据业务逻辑的耗时基础上，加几百ms即可。
+
+```java
+public void write(String key,Object data){
+    redis.delKey(key);
+    db.updateData(data);
+    Thread.sleep(1000);//确保读请求结束，写请求可以删除读请求造成的缓存脏数据
+    redis.delKey(key);
+}
+```
+
+可以将第二次删除作为异步的。自己起一个线程，异步删除。这样，写的请求就不用沉睡一段时间后了，加大吞吐量。
+
+当删缓存失败时，也会就出现数据不一致的情况。
+
+解决方法：
+
+![](https://gitee.com/tysondai/img/raw/master/image-20210913235221410.png)
+
+> 图片来源：https://tech.it168.com
+
