Merge branch 'Snailclimb:master' into master

docs/java/basis/Java基础知识.md

@@ -1119,7 +1119,6 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence {
 Object 类是一个特殊的类，是所有类的父类。它主要提供了以下 11 个方法：
 
 ```java
-
 public final native Class<?> getClass()//native方法，用于返回当前运行时对象的Class对象，使用了final关键字修饰，故不允许子类重写。
 
 public native int hashCode() //native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的HashMap。
@@ -1140,9 +1139,9 @@ public final void wait(long timeout, int nanos) throws InterruptedException//多
 public final void wait() throws InterruptedException//跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念
 
 protected void finalize() throws Throwable { }//实例被垃圾回收器回收的时候触发的操作
-
 ```
 
+
 ## 反射
 
 ### 何为反射？
@@ -1400,4 +1399,4 @@ Java Io 流共涉及 40 多个类，这些类看上去很杂乱，但实际上
 
 - https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre
 - https://www.educba.com/oracle-vs-openjdk/
-- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk?answertab=active#tab-top## 基础概念与常识
+- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk?answertab=active#tab-top## 基础概念与常识

docs/java/basis/Java基础知识疑难点.md

@@ -72,16 +72,16 @@ Reference:[Java中equals方法造成空指针异常的原因及解决方案](htt
 先看下面这个例子：
 
 ```java
-Integer x = 3;
-Integer y = 3;
-System.out.println(x == y);// true
-Integer a = new Integer(3);
-Integer b = new Integer(3);
-System.out.println(a == b);//false
-System.out.println(a.equals(b));//true
+Integer i1 = 40;
+Integer i2 = new Integer(40);
+System.out.println(i1==i2);//false
 ```
 
-当使用自动装箱方式创建一个Integer对象时，当数值在-128 ~127时，会将创建的 Integer 对象缓存起来，当下次再出现该数值时，直接从缓存中取出对应的Integer对象。所以上述代码中，x和y引用的是相同的Integer对象。	
+`Integer i1=40` 这一行代码会发生拆箱，也就是说这行代码等价于 `Integer i1=Integer.valueOf(40)` 。因此，`i1` 直接使用的是常量池中的对象。而`Integer i1 = new Integer(40)` 会直接创建新的对象。因此，输出 false 。
+
+记住：**所有整型包装类对象之间值的比较，全部使用 `equals()`  方法比较**。
+
+![](https://img-blog.csdnimg.cn/20210313164740893.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MzM3Mjcy,size_16,color_FFFFFF,t_70)
 
 **注意：** 如果你的IDE(IDEA/Eclipse)上安装了阿里巴巴的p3c插件，这个插件如果检测到你用 ==的话会报错提示，推荐安装一个这个插件，很不错。
 

docs/java/basis/反射机制.md

@@ -80,7 +80,7 @@ Class alunbarClass2 = o.getClass();
 **4.通过类加载器`xxxClassLoader.loadClass()`传入类路径获取:**
 
 ```java
-class clazz = ClassLoader.LoadClass("cn.javaguide.TargetObject");
+Class clazz = ClassLoader.loadClass("cn.javaguide.TargetObject");
 ```
 
 通过类加载器获取 Class 对象不会进行初始化，意味着不进行包括初始化等一些列步骤，静态块和静态对象不会得到执行
@@ -173,4 +173,4 @@ value is JavaGuide
 
 ```java
 Class<?> tagetClass = Class.forName("cn.javaguide.TargetObject");
-```
+```

docs/java/collection/ArrayList源码+扩容机制分析.md

@@ -894,7 +894,7 @@ public class EnsureCapacityTest {
 运行结果：
 
 ```
-使用ensureCapacity方法前：1773
+使用ensureCapacity方法后：1773
 ```
 
 通过运行结果，我们可以看出向 ArrayList 添加大量元素之前最好先使用`ensureCapacity` 方法，以减少增量重新分配的次数。

docs/java/collection/ConcurrentHashMap源码+底层数据结构分析.md

@@ -91,7 +91,7 @@ public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLe
 总结一下在 Java 7 中 ConcurrnetHashMap 的初始化逻辑。
 
 1. 必要参数校验。
-2. 校验并发级别 concurrencyLevel 大小，如果大于最大值，重置为最大值。无惨构造**默认值是 16.**
+2. 校验并发级别 concurrencyLevel 大小，如果大于最大值，重置为最大值。无参构造**默认值是 16.**
 3. 寻找并发级别 concurrencyLevel 之上最近的 **2 的幂次方**值，作为初始化容量大小，**默认是 16**。
 4. 记录 segmentShift 偏移量，这个值为【容量 =  2 的N次方】中的 N，在后面 Put 时计算位置时会用到。**默认是 32 - sshift = 28**.
 5. 记录 segmentMask，默认是 ssize - 1 = 16 -1 = 15.

docs/java/collection/Java集合框架常见面试题.md

@@ -86,7 +86,7 @@
 
 - `HashMap`： JDK1.8 之前 `HashMap` 由数组+链表组成的，数组是 `HashMap` 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间
 - `LinkedHashMap`： `LinkedHashMap` 继承自 `HashMap`，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，`LinkedHashMap` 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。详细可以查看：[《LinkedHashMap 源码详细分析（JDK1.8）》](https://www.imooc.com/article/22931)
-- `Hashtable`： 数组+链表组成的，数组是 `HashMap` 的主体，链表则是主要为了解决哈希冲突而存在的
+- `Hashtable`： 数组+链表组成的，数组是 `Hashtable` 的主体，链表则是主要为了解决哈希冲突而存在的
 - `TreeMap`： 红黑树（自平衡的排序二叉树）
 
 ### 1.1.4. 如何选用集合?

docs/java/jvm/JVM垃圾回收.md

@@ -176,26 +176,30 @@ public class GCTest {
 
 大部分情况，对象都会首先在 Eden 区域分配，在一次新生代垃圾回收后，如果对象还存活，则会进入 s0 或者 s1，并且对象的年龄还会加 1(Eden 区->Survivor 区后对象的初始年龄变为 1)，当它的年龄增加到一定程度（默认为 15 岁），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数 `-XX:MaxTenuringThreshold` 来设置。
 
-> 修正（[issue552](https://github.com/Snailclimb/JavaGuide/issues/552)）：“Hotspot 遍历所有对象时，按照年龄从小到大对其所占用的大小进行累积，当累积的某个年龄大小超过了 survivor 区的一半时，取这个年龄和 MaxTenuringThreshold 中更小的一个值，作为新的晋升年龄阈值”。
+> 修正（[issue552](https://github.com/Snailclimb/JavaGuide/issues/552)）：“Hotspot 遍历所有对象时，按照年龄从小到大对其所占用的大小进行累积，当累积的某个年龄大小超过了 survivor 区的 50% 时（默认值是 50%，可以通过 `-XX:TargetSurvivorRatio=percent` 来设置，参见 [issue1199](https://github.com/Snailclimb/JavaGuide/issues/1199) ），取这个年龄和 MaxTenuringThreshold 中更小的一个值，作为新的晋升年龄阈值”。
 >
-> **动态年龄计算的代码如下**
+> jdk8官方文档引用 ：https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html 。
+>
+> ![](https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/java-guide-blog/image-20210523201742303.png)
+>
+> **动态年龄计算的代码如下：**
 >
 > ```c++
 > uint ageTable::compute_tenuring_threshold(size_t survivor_capacity) {
->     //survivor_capacity是survivor空间的大小
->     size_t desired_survivor_size = (size_t)((((double)survivor_capacity)*TargetSurvivorRatio)/100);
->     size_t total = 0;
->     uint age = 1;
->     while (age < table_size) {
->         //sizes数组是每个年龄段对象大小
->         total += sizes[age];
->         if (total > desired_survivor_size) {
->             break;
->         }
->         age++;
->     }
->     uint result = age < MaxTenuringThreshold ? age : MaxTenuringThreshold;
->     ...
+>  //survivor_capacity是survivor空间的大小
+>  size_t desired_survivor_size = (size_t)((((double)survivor_capacity)*TargetSurvivorRatio)/100);
+>  size_t total = 0;
+>  uint age = 1;
+>  while (age < table_size) {
+>      //sizes数组是每个年龄段对象大小
+>      total += sizes[age];
+>      if (total > desired_survivor_size) {
+>          break;
+>      }
+>      age++;
+>  }
+>  uint result = age < MaxTenuringThreshold ? age : MaxTenuringThreshold;
+>  ...
 > }
 > 
 > ```

docs/java/multi-thread/java线程池学习总结.md

@@ -545,7 +545,7 @@ public interface Callable<V> {
 1. **`execute()`方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；**
 2. **`submit()`方法用于提交需要返回值的任务。线程池会返回一个 `Future` 类型的对象，通过这个 `Future` 对象可以判断任务是否执行成功** ，并且可以通过 `Future` 的 `get()`方法来获取返回值，`get()`方法会阻塞当前线程直到任务完成，而使用 `get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
 
-我们以**`AbstractExecutorService`**接口中的一个 `submit` 方法为例子来看看源代码：
+我们以 **`AbstractExecutorService`** 接口中的一个 `submit()` 方法为例子来看看源代码：
 
 ```java
     public Future<?> submit(Runnable task) {