change image

Author: NotFound9

docs/HashMap.md

@@ -502,7 +502,7 @@ table = newTab;
 hash%length=hash&(length-1)
 ```
 
-而因为length是2的N次幂，length-1在二进制中其实是N-1个1。例如：
+而因为length是2的N次幂，length-1在二进制中其实是N个1。例如：
 
 length为16，length用2进制表示是10000，
 

docs/JavaJVM.md

@@ -1178,7 +1178,7 @@ class name列：表示的就是当前类的名称，class name 对于基本数
 
 ##### jmap -dump
 
-使用`jmap -dump:format=b,file=dump.hprof 进程id`可以生成当前的堆栈快照，堆快照和对象统计信息，对生成的堆快照进行分析，可以分析堆中对象所占用内存的情况，检查大对象等。执行`jvisualvm`命令打开使用Java自带的工具Java VisualVM来打开堆栈快照文件，进行分析。可以用于排查内存溢出，内存泄露问题。在Java VisualVM里面可以看到每个类的实例对象占用的内存大小，以及持有这个对象的实例所在的类等等信息。
+使用`jmap -dump:format=b,file=dump.hprof 进程id`可以生成当前的堆栈快照，堆快照和对象统计信息，对生成的堆快照进行分析，可以分析堆中对象所占用内存的情况，检查大对象等。执行`jvisualvm`命令打开使用Java自带的工具**Java VisualVM**来打开堆栈快照文件，进行分析。可以用于排查内存溢出，内存泄露问题。在**Java VisualVM**里面可以看到每个类的实例对象占用的内存大小，以及持有这个对象的实例所在的类等等信息。
 
 也可以配置启动时的JVM参数，让发送内存溢出时，自动生成堆栈快照文件。
 

docs/JavaMultiThread.md

@@ -54,15 +54,15 @@ Linux系统会给每个进程分配4G的虚拟地址空间(0到3G是User地址
 
 五态模型一般指的是:
 
-新建态（创建一个进程）
+**新建态**（创建一个进程）
 
-就绪态（已经获取到资源，准备好了，进入运行队列，一旦获得时间片可以立即执行）
+**就绪态**（已经获取到资源，准备好了，进入运行队列，一旦获得时间片可以立即执行）
 
-运行态（获取到了时间片，执行程序）
+**运行态**（获取到了时间片，执行程序）
 
-阻塞态（运行过程中等待获取其他资源，I/O请求等）
+**阻塞态**（运行过程中等待获取其他资源，I/O请求等）
 
-终止态（进程被杀死了)
+**终止态**（进程被杀死了)
 
 #### 并发性
 
@@ -204,7 +204,7 @@ class ThreadTarget implements Runnable {
 
 ##### 原理
 
-之所以有这种实现方法，是因为Thread类的run方法中会判断成员变量target是否为空，不为空就会调用target类的run方法。
+之所以有这种实现方法，是因为Thread类的run()方法中会判断成员变量target是否为空，不为空就会调用target类的run方法。
 
 ```java
 private Runnable target;
@@ -258,7 +258,7 @@ thread.start()
 
 #### 第三种 实现Callable接口
 
-Runnable接口中的run方法是没有返回值，如果我们需要执行的任务带返回值就不能使用Runnable接口。创建一个类CallableTarget，实现Callable接口，实现带有**返回值的call()方法**，然后根据CallableTarget创建一个任务FutureTask，然后根据FutureTask来创建一个线程Thread，调用Thread的start方法可以执行任务。
+Runnable接口中的run()方法是没有返回值，如果我们需要执行的任务带返回值就不能使用Runnable接口。创建一个类CallableTarget，实现Callable接口，实现带有**返回值的call()方法**，然后根据CallableTarget创建一个任务FutureTask，然后根据FutureTask来创建一个线程Thread，调用Thread的start方法可以执行任务。
 
 ```java
 public class CallableTarget implements Callable<Integer> {
@@ -386,6 +386,40 @@ public interface RunnableFuture<V> extends Runnable, Future<V> {
 }
 ```
 
+##### 使用案例
+
+使用时，Runnable实现类的实例可以作为Thread的入参使用，而Callable只能使用FutureTask进行封装使用。
+
+```java
+//Runnable配合Thread进行使用
+Thread threadA = new Thread(new Runnable() {
+   @Override
+      public void run() {   
+			//任务的代码
+      }
+ });
+
+//Callable使用FutureTask封装后，配合线程池进行使用
+ExecutorService pool = Executors.newSingleThreadExecutor();
+FutureTask task = new FutureTask(new Callable() {
+        @Override
+        public Object call() throws Exception {
+          //任务的代码
+          return null;
+        }
+});
+pool.submit(task);
+
+//Runnable使用FutureTask封装后，配合线程池进行使用
+FutureTask task1 = new FutureTask(new Runnable() {
+      @Override
+      public void run() {
+   				//任务的代码
+      }
+});
+pool.submit(task1);
+```
+
 ### Java中单例有哪些写法？
 
 正确并且可以做到延迟加载的写法其实就是三种：
@@ -762,14 +796,11 @@ static void ensure_join(JavaThread* thread) {
 
   thread->clear_pending_exception();
 
-  java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
-
+  java_lang_Thread::set_thread_status(threadObj(),        java_lang_Thread::TERMINATED);
   java_lang_Thread::set_thread(threadObj(), NULL);
-
   //同志们看到了没，别的不用看，就看这一句
   //thread就是当前线程，是啥？就是刚才例子中说的threadA线程
   lock.notify_all(thread);
-
   thread->clear_pending_exception();
 }
 ```
@@ -848,24 +879,24 @@ FutureTask提供了cancel(boolean mayInterruptIfRunning)方法来取消任务，
 示例代码如下：
 
 ```java
-   Thread threadA = new Thread(new Runnable() {
-        @Override
-        public void run() {
+Thread threadA = new Thread(new Runnable() {
+      @Override
+      public void run() {
         //执行threadA的任务
-        }
-    });
-    Thread threadB= new Thread(new Runnable() {
-        @Override
-        public void run() {
-            //执行threadB的任务
-        }
-    });
-		//执行线程A任务
-    threadA.start();
-		//主线程进行等待
-    threadA.join();
-		//执行线程B的任务
-    threadB.start();
+      }
+});
+Thread threadB= new Thread(new Runnable() {
+      @Override
+      public void run() {
+        //执行threadB的任务
+      }
+});
+//执行线程A任务
+threadA.start();
+//主线程进行等待
+threadA.join();
+//执行线程B的任务
+threadB.start();
 ```
 
 ##### 子线程Join
@@ -1422,9 +1453,9 @@ public ThreadPoolExecutor(int corePoolSize,
 
 从阻塞队列取任务时，如果阻塞队列为空:
 
-核心线程的会一直卡在`workQueue.take`方法，被阻塞并挂起，不会占用CPU资源。
+**核心线程**的会一直卡在`workQueue.take`方法，被阻塞并挂起，不会占用CPU资源。
 
-非核心线程会调用workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)方法取任务 ，如果超过keepAliveTime时间后还没有拿到，下一次循环判断**compareAndDecrementWorkerCount**就会返回`null`,Worker对象的`run()`方法循环体的判断为`null`,任务结束，然后线程被系统回收）
+**非核心线程**会调用workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)方法取任务 ，如果超过keepAliveTime时间后还没有拿到，下一次循环判断**compareAndDecrementWorkerCount**就会返回`null`,Worker对象的`run()`方法循环体的判断为`null`,任务结束，然后线程被系统回收）
 
 ##### 2.maximumPoolSize 最大线程数
 
@@ -1611,8 +1642,6 @@ ThreadPoolExecutor提供了如下几个public的setter方法
 
 ![image-20210119104549770](../static/image-20210119104549770.png)
 
-
-
 调用corePoolSize方法之后，线程池会直接覆盖原来的corePoolSize值，并且基于当前值和原始值的比较结果采取不同的处理策略。（总得来说就是，多退少补的策略）
 
 **对于新corePoolSize<当前工作线程数的情况：**

docs/MySQLNote.md

@@ -1016,23 +1016,22 @@ EXPLAIN SELECT * FROM res_user ORDER BYmodifiedtime LIMIT 0,1000
 table |  type | possible_keys | key |key_len  | ref | rows | Extra  EXPLAIN列的解释：   
 
 - table   显示这一行的数据是关于哪张表的           
-- type    这是重要的列，显示连接使用了何种类型。从最好到最差的连接类型为const、eq_reg、ref、range、indexhe和ALL
+- type    这是重要的列，显示连接使用了何种类型。从最好到最差的连接类型为const、eq_reg、ref、range、index和ALL
+- ref    表里面的哪个索引被用到了
 - rows   显示需要扫描行数
 - key     使用的索引
 
-const就是针对主键或者唯一性索引的等值查询，通过索引查找一次就行了。仅仅是查一条数据。
+   const就是针对主键或者唯一性索引的等值查询，通过索引查找一次就行了。仅仅是查一条数据。
 
-eq_ref 唯一性索引键扫描，对于每个索引键，表中只有一条数据与其对应，例如join查询时，对于前表查出的结果集，每个结果在第二个表只有一条数据对应。
+   eq_ref 唯一性索引键扫描，对于每个索引键，表中只有一条数据与其对应，例如join查询时，对于前表查出的结果集，每个结果在第二个表只有一条数据对应。
 
-ref 非唯一性索引查询
-
-  ref : 此类型通常出现在多表的 join 查询, 针对于非唯一或非主键索引, 或者是使用了 `最左前缀` 规则索引的查询. 关键字:非唯一性索引
+   ref 非唯一性索引查询 此类型通常出现在多表的 join 查询, 针对于非唯一或非主键索引, 或者是使用了 `最左前缀` 规则索引的查询. 关键字:非唯一性索引
 
    ref_or_null：与ref方法类似，只是增加了null值的比较。
 
-   `range`: 表示使用索引范围查询, 通过索引字段范围获取表中部分数据记录. 这个类型通常出现在 =, <>, >, >=, <, <=, IS NULL, <=>, BETWEEN, IN() 操作中.
+   range: 表示使用索引范围查询, 通过索引字段范围获取表中部分数据记录. 这个类型通常出现在 =, <>, >, >=, <, <=, IS NULL, <=>, BETWEEN, IN() 操作中.
 
-   `index`: 表示全索引扫描(full index scan), 关键字:查询字段和条件都是索引本身
+   index: 表示全索引扫描(full index scan), 关键字:查询字段和条件都是索引本身
 
    index_merge：表示查询使用了两个以上的索引，最后取交集或者并集，常见and ，or的条件使用了不同的索引.效率不是很高 关键字:索引合并
 
@@ -1114,9 +1113,11 @@ SELECT * FROM test where id > 100 AND name = '123'
 https://dev.mysql.com/doc/refman/5.7/en/index-condition-pushdown-optimization.html
 
 ##### Using filesort
-如果在关联表查询时，Order By的所有字段都来自第一个表(也就是驱动表)，那么在处理驱动表时，从驱动表中取出满足条件的结果集时就会进行排序，不需要使用临时表存储数据行，进行重排序。
+
+如果在关联表查询时，Order By的所有字段都来自第一个表(也就是驱动表)，那么在处理驱动表时，从驱动表中取出满足条件的结果集时就会进行排序，不需要使用临时表存储数据行进行重排序，extral那一列就会显示是Using index。如果Order By的字段不在索引中，那么就需要在查找出结果集后，进行重排序，就会显示Using filesort。
 ##### Using temporary; Using fileSort
-再进行关联表查询时，如果Order By的字段不全是来自驱动表，那么会把关联结果存放在临时表中，等所有的关联都结束后，再在内存中对数据行进行排序。
+
+再进行关联表查询时，如果Order By中的字段不全是来自驱动表，也就是使用了被驱动表中的字段进行排序，那么会把关联结果全部查找出来，存放在临时表中，等所有的关联都结束后，再在内存中对数据行进行排序。
 
 ##### 优化的方法：
 

docs/RedisBasic.md

@@ -249,8 +249,8 @@ https://xie.infoq.cn/article/b3816e9fe3ac77684b4f29348
 
 ### 同步与异步的区别是什么？
 同步与异步的区别在于调用结果的通知方式上。
-同步执行一个方法后，需要等待结果返回，然后继续执行下去。
-异步执行一个方法后，不会等待结果的返回，调用方定时主动去轮询调用结果或者被调用方在执行完成后通过回调来通知调用方。
+同步执行一个方法后，需要等待结果返回轮询调用结果才能继续执行，然后继续执行下去。
+异步执行一个方法后，不会等待结果的返回，被调用方在执行完成后通过回调来通知调用方继续执行。
 
 ### 阻塞与非阻塞的区别是什么？
 阻塞与非阻塞的区别在于进程/线程在等待消息时，进程/线程是否是挂起状态。
@@ -291,7 +291,7 @@ Redis 缓存穿透指的是攻击者故意大量请求一些Redis缓存中不存
 
 1.在给缓存设置失效时间时加一个随机值，避免集体失效。
 
-2.双缓存机制，缓存A的失效时间为20分钟，缓存B没有失效时间，从缓存A读取数据，缓存A中没有时，去缓存B中读取数据，并且启动一个异步线程来更新缓存A。
+2.双缓存机制，缓存A的失效时间为20分钟，缓存B的失效时间会比A长一些，从缓存A读取数据，缓存A中没有时，去缓存B中读取数据，并且启动一个异步线程来更新缓存A(如果已经有异步线程正在更新了，就不用重复更新了)。以及更新缓存B，以便延迟B的过期时间。
 
 ### 如何解决缓存与数据库的数据一致性问题？
 

docs/Spring.md

@@ -169,3 +169,23 @@ IOC就是invention of control，就是控制反转，将对象获取外界依赖
 DI(Dependency Injection，依赖注入)其实就是IOC的另外一种说法，就是IOC是通过依赖注入技术实现的。
 《跟我学spring3系列》https://www.iteye.com/blog/jinnianshilongnian-1413851
 https://www.cnblogs.com/xdp-gacl/p/4249939.html
+
+### Spring IOC是怎么解决循环依赖问题的？
+
+Spring使用了3个Map来保存Bean，俗称为三级依赖：
+
+singletonObjects 一级缓存，用于保存实例化、注入、初始化完成的bean实例，可以使用的。
+
+earlySingletonObjects 二级缓存，用于保存依赖注入完成的bean实例，但是没有完成初始化完成的bean。
+
+singletonFactories 三级缓存，用于保存bean创建工厂，以便于后面扩展有机会创建代理对象，此时的bean是没有完成属性填充的。
+
+
+
+假设A类和B类相互依赖，A中有一个B类的属性，B中有一个A类的属性。那么在初始化A的Bean时，首先会依次去一级依赖，去二级依赖，三级依赖中去找，都没有就调用创建方法创建实例A，将A添加到三级依赖中，然后对A的属性进行依赖注入，填充属性时，发现B的Bean在各级依赖中都没有，就创建B的bean添加到三级依赖，然后对B的属性进行填充，填充B的属性A时，会从三级依赖中取出A，填充完放到二级依赖，然后对B进行初始化，初始化完成添加到一级依赖。B初始化完成后，将B从一级依赖中，填充到实例A，A可以进入到二级依赖，完全初始化完成后，A进入到一级依赖，供用户代码使用。
+
+![img](../static/d7687db8ecbd43a79d041badf07bbaf4~tplv-k3u1fbpfcp-watermark.image)
+
+https://juejin.cn/post/6911692836714840077
+
+https://segmentfault.com/a/1190000015221968