[docs update]添加Future相关的3个问题

docs/about-the-author/zhishixingqiu-two-years.md

@@ -125,4 +125,5 @@ star: 2
     <img src="https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/github/javaguide/IMG_3007.jpg" style="margin: 0 auto; " />
   </a>
 </div>
+
 **真诚欢迎准备面试的小伙伴加入星球一起交流！真心希望能够帮助到更多小伙伴！**

docs/java/concurrent/completablefuture-intro.md

@@ -19,6 +19,8 @@ public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
 }
 ```
 
+![](https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/github/javaguide/java/concurrent/completablefuture-class-diagram.jpg)
+
 `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外，还提供了函数式编程的能力。
 
 ![](https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/javaguide/image-20210902092441434.png)
@@ -31,9 +33,11 @@ public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
 - `get()` ：等待任务执行完成并获取运算结果。
 - `get(long timeout, TimeUnit unit)` ：多了一个超时时间。
 
-![](https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/javaguide/image-20210902093026059.png)
+`CompletionStage` 接口描述了一个异步计算的阶段。很多计算可以分成多个阶段或步骤，此时可以通过它将所有步骤组合起来，形成异步计算的流水线。
 
-`CompletionStage<T>` 接口中的方法比较多，`CompletableFuture` 的函数式能力就是这个接口赋予的。从这个接口的方法参数你就可以发现其大量使用了 Java8 引入的函数式编程。
+`CompletionStage` 接口中的方法比较多，`CompletableFuture` 的函数式能力就是这个接口赋予的。从这个接口的方法参数你就可以发现其大量使用了 Java8 引入的函数式编程。
+
+![](https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/javaguide/image-20210902093026059.png)
 
 由于方法众多，所以这里不能一一讲解，下文中我会介绍大部分常见方法的使用。
 

docs/java/concurrent/java-concurrent-questions-03.md

@@ -468,6 +468,99 @@ CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内
 - **[Hippo-4](https://github.com/opengoofy/hippo4j)** ：一款强大的动态线程池框架，解决了传统线程池使用存在的一些痛点比如线程池参数没办法动态修改、不支持运行时变量的传递、无法执行优雅关闭。除了支持动态修改线程池参数、线程池任务传递上下文，还支持通知报警、运行监控等开箱即用的功能。
 - **[Dynamic TP](https://github.com/dromara/dynamic-tp)** ：轻量级动态线程池，内置监控告警功能，集成三方中间件线程池管理，基于主流配置中心（已支持Nacos、Apollo，Zookeeper、Consul、Etcd，可通过SPI自定义实现）。
 
+## Future
+
+### Future 类有什么用？
+
+`Future` 类是异步思想的典型运用，主要用在一些需要执行耗时任务的场景，避免程序一直原地等待耗时任务执行完成，执行效率太低。具体来说是这样的：当我们执行某一耗时的任务时，可以将这个耗时任务交给一个子线程去异步执行，同时我们可以干点其他事情，不用傻傻等待耗时任务执行完成。等我们的事情干完后，我们再通过 `Future` 类获取到耗时任务的执行结果。这样一来，程序的执行效率就明显提高了。
+
+这其实就是多线程中经典的 **Future 模式**，你可以将其看作是一种设计模式，核心思想是异步调用，主要用在多线程领域，并非 Java 语言独有。
+
+在 Java 中，`Future` 类只是一个泛型接口，位于 `java.util.concurrent` 包下，其中定义了 5 个方法，主要包括下面这 4 个功能：
+
+- 取消任务；
+- 判断任务是否被取消;
+- 判断任务是否已经执行完成;
+- 获取任务执行结果。
+
+```java
+// V 代表了Future执行的任务返回值的类型
+public interface Future<V> {
+    // 取消任务执行
+    // 成功取消返回 true，否则返回 false
+    boolean cancel(boolean mayInterruptIfRunning);
+    // 判断任务是否被取消
+    boolean isCancelled();
+    // 判断任务是否已经执行完成
+    boolean isDone();
+    // 获取任务执行结果
+    V get() throws InterruptedException, ExecutionException;
+    // 指定时间内没有返回计算结果就抛出 TimeOutException 异常
+    V get(long timeout, TimeUnit unit)
+
+        throws InterruptedException, ExecutionException, TimeoutExceptio
+
+}
+```
+
+简单理解就是：我有一个任务，提交给了 `Future` 来处理。任务执行期间我自己可以去做任何想做的事情。并且，在这期间我还可以取消任务以及获取任务的执行状态。一段时间之后，我就可以 `Future` 那里直接取出任务执行结果。
+
+### Callable 和 Future 有什么关系？
+
+我们可以通过 `FutureTask` 来理解 `Callable` 和 `Future` 之间的关系。
+
+`FutureTask` 提供了 `Future` 接口的基本实现，常用来封装 `Callable` 和 `Runnable`，具有取消任务、查看任务是否执行完成以及获取任务执行结果的方法。`ExecutorService.submit()` 方法返回的其实就是 `Future` 的实现类 `FutureTask` 。
+
+```java
+<T> Future<T> submit(Callable<T> task);
+Future<?> submit(Runnable task);
+```
+
+`FutureTask` 不光实现了 `Future`接口，还实现了`Runnable` 接口，因此可以作为任务直接被线程执行。
+
+![](https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/github/javaguide/java/concurrent/completablefuture-class-diagram.jpg)
+
+`FutureTask` 有两个构造函数，可传入 `Callable` 或者 `Runnable` 对象。实际上，传入 `Runnable` 对象也会在方法内部转换为`Callable` 对象。
+
+```java
+public FutureTask(Callable<V> callable) {
+    if (callable == null)
+        throw new NullPointerException();
+    this.callable = callable;
+    this.state = NEW;
+}
+public FutureTask(Runnable runnable, V result) {
+    // 通过适配器RunnableAdapter来将Runnable对象runnable转换成Callable对象
+    this.callable = Executors.callable(runnable, result);
+    this.state = NEW;
+}
+```
+
+`FutureTask`相当于对`Callable` 进行了封装，管理着任务执行的情况，存储了 `Callable` 的 `call` 方法的任务执行结果。
+
+### CompletableFuture 类有什么用？
+
+`Future` 在实际使用过程中存在一些局限性比如不支持异步任务的编排组合、获取计算结果的 `get()` 方法为阻塞调用。
+
+Java 8 才被引入`CompletableFuture` 类可以解决`Future` 的这些缺陷。`CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外，还提供了函数式编程、异步任务编排组合（可以将多个异步任务串联起来，组成一个完整的链式调用）等能力。
+
+下面我们来简单看看 `CompletableFuture` 类的定义。
+
+```java
+public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
+}
+```
+
+可以看到，`CompletableFuture` 同时实现了 `Future` 和 `CompletionStage` 接口。
+
+![](https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/github/javaguide/java/concurrent/completablefuture-class-diagram.jpg)
+
+`CompletionStage` 接口描述了一个异步计算的阶段。很多计算可以分成多个阶段或步骤，此时可以通过它将所有步骤组合起来，形成异步计算的流水线。
+
+`CompletionStage` 接口中的方法比较多，`CompletableFuture` 的函数式能力就是这个接口赋予的。从这个接口的方法参数你就可以发现其大量使用了 Java8 引入的函数式编程。
+
+![](https://guide-blog-images.oss-cn-shenzhen.aliyuncs.com/javaguide/image-20210902093026059.png)
+
 ## AQS
 
 ### AQS 是什么？
@@ -842,5 +935,6 @@ public int await() throws InterruptedException, BrokenBarrierException {
 - 《实战 Java 高并发程序设计》
 - 带你了解下 SynchronousQueue（并发队列专题）：https://juejin.cn/post/7031196740128768037
 - 阻塞队列 — DelayedWorkQueue 源码分析：https://zhuanlan.zhihu.com/p/310621485
+- Java多线程（三）——FutureTask/CompletableFuture：https://www.cnblogs.com/iwehdio/p/14285282.html
 - Java 并发之 AQS 详解：https://www.cnblogs.com/waterystone/p/4920797.html
 - Java 并发包基石-AQS 详解：https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html

docs/java/jvm/jvm-intro.md

@@ -1,12 +1,11 @@
 ---
+title:  大白话带你认识 JVM
 category: Java
 tag:
   - JVM
 ---
 
-# 大白话带你认识JVM
+> 来自[说出你的愿望吧丷](https://juejin.im/user/5c2400afe51d45451758aa96)投稿，原文地址：https://juejin.im/post/5e1505d0f265da5d5d744050 。
-
-> 来自掘金用户：[说出你的愿望吧丷](https://juejin.im/user/5c2400afe51d45451758aa96)投稿，原文地址：https://juejin.im/post/5e1505d0f265da5d5d744050#heading-28
 
 ## 前言
 
@@ -104,6 +103,7 @@ JVM 是 Java Virtual Machine 的缩写，它是一个虚构出来的计算机，
 #### 2.1.3 初始化
 
 初始化其实就是执行类构造器方法的`<clinit>()`的过程，而且要保证执行前父类的`<clinit>()`方法执行完毕。这个方法由编译器收集，顺序执行所有类变量（static 修饰的成员变量）显式初始化和静态代码块中语句。此时准备阶段时的那个 `static int a` 由默认初始化的 0 变成了显式初始化的 3。 由于执行顺序缘故，初始化阶段类变量如果在静态代码块中又进行了更改，会覆盖类变量的显式初始化，最终值会为静态代码块中的赋值。
+
 > 注意：字节码文件中初始化方法有两种，非静态资源初始化的`<init>`和静态资源初始化的`<clinit>`，类构造器方法`<clinit>()`不同于类的构造器，这些方法都是字节码文件中只能给 JVM 识别的特殊方法。
 
 #### 2.1.4 卸载
@@ -152,7 +152,6 @@ public class String {
 
 方法区主要的作用是存放类的元数据信息，常量和静态变量···等。当它存储的信息过大时，会在无法满足内存分配时报错。
 
-
 ### 3.3 虚拟机栈和虚拟机堆
 
 一句话便是：栈管运行，堆管存储。则虚拟机栈负责运行代码，而虚拟机堆负责存储数据。
@@ -171,7 +170,6 @@ public class Person{
 }
 ```
 
-
 #### 3.3.2 虚拟机栈存在的异常
 
 如果线程请求的栈的深度大于虚拟机栈的最大深度，就会报 **StackOverflowError** （这种错误经常出现在递归中）。Java 虚拟机也可以动态扩展，但随着扩展会不断地申请内存，当无法申请足够内存时就会报错 **OutOfMemoryError**。
@@ -209,13 +207,21 @@ JVM内存会划分为堆内存和非堆内存，堆内存中也会划分为**年
 
 当我们 new 一个对象后，会先放到 Eden 划分出来的一块作为存储空间的内存，但是我们知道对堆内存是线程共享的，所以有可能会出现两个对象共用一个内存的情况。这里 JVM 的处理是为每个线程都预先申请好一块连续的内存空间并规定了对象存放的位置，而如果空间不足会再申请多块内存空间。这个操作我们会称作 TLAB，有兴趣可以了解一下。
 
-当Eden空间满了之后，会触发一个叫做Minor GC（就是一个发生在年轻代的GC）的操作，存活下来的对象移动到Survivor0区。Survivor0区满后触发 Minor GC，就会将存活对象移动到Survivor1区，此时还会把from和to两个指针交换，这样保证了一段时间内总有一个survivor区为空且to所指向的survivor区为空。经过多次的 Minor GC后仍然存活的对象（**这里的存活判断是15次，对应到虚拟机参数为 -XX:MaxTenuringThreshold 。为什么是15，因为HotSpot会在对象头中的标记字段里记录年龄，分配到的空间仅有4位，所以最多只能记录到15**）会移动到老年代。老年代是存储长期存活的对象的，占满时就会触发我们最常听说的Full GC，期间会停止所有线程等待GC的完成。所以对于响应要求高的应用应该尽量去减少发生Full GC从而避免响应超时的问题。
+当 Eden 空间满了之后，会触发一个叫做 Minor GC（就是一个发生在年轻代的 GC）的操作，存活下来的对象移动到 Survivor0 区。~~Survivor0 区满后触发 Minor GC，就会将存活对象移动到 Survivor1 区~~，此时还会把 from 和 to 两个指针交换，这样保证了一段时间内总有一个 survivor 区为空且 to 所指向的 survivor 区为空。经过多次的 Minor GC 后仍然存活的对象（**这里的存活判断是 15 次，对应到虚拟机参数为 -XX:MaxTenuringThreshold 。为什么是 15，因为 HotSpot 会在对象头中的标记字段里记录年龄，分配到的空间仅有 4 位，所以最多只能记录到 15**）会移动到老年代。
+
+> 🐛 修正 ：当 Eden 区内存空间满了的时候，就会触发 Minor GC，Survivor0 区满不会触发 Minor GC 。
+>
+> **那 Survivor0 区 的对象什么时候垃圾回收呢？**
+>
+> 假设 Survivor0 区现在是满的，此时又触发了 Minor GC ，发现 Survivor0 区依旧是满的，存不下，此时会将 S0 区与 Eden 区的对象一起进行可达性分析，找出活跃的对象，将它复制到 S1 区并且将 S0 区域和 Eden 区的对象给清空，这样那些不可达的对象进行清除，并且将 S0 区 和 S1 区交换。
+
+老年代是存储长期存活的对象的，占满时就会触发我们最常听说的 Full GC，期间会停止所有线程等待 GC 的完成。所以对于响应要求高的应用应该尽量去减少发生 Full GC 从而避免响应超时的问题。
 
 而且当老年区执行了 full gc 之后仍然无法进行对象保存的操作，就会产生 OOM，这时候就是虚拟机中的堆内存不足，原因可能会是堆内存设置的大小过小，这个可以通过参数-Xms、-Xmx 来调整。也可能是代码中创建的对象大且多，而且它们一直在被引用从而长时间垃圾收集无法收集它们。
 
 ![](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/c02ecba3c33f43429a765987b928e423-new-image93b46f3d-33f9-46f9-a825-ec7129b004f6.png)
 
-补充说明：关于-XX:TargetSurvivorRatio参数的问题。其实也不一定是要满足-XX:MaxTenuringThreshold才移动到老年代。可以举个例子：如对象年龄5的占30%，年龄6的占36%，年龄7的占34%，加入某个年龄段（如例子中的年龄6）后，总占用超过Survivor空间*TargetSurvivorRatio的时候，从该年龄段开始及大于的年龄对象就要进入老年代（即例子中的年龄6对象，就是年龄6和年龄7晋升到老年代），这时候无需等到MaxTenuringThreshold中要求的15
+补充说明：关于-XX:TargetSurvivorRatio 参数的问题。其实也不一定是要满足-XX:MaxTenuringThreshold 才移动到老年代。可以举个例子：如对象年龄 5 的占 30%，年龄 6 的占 36%，年龄 7 的占 34%，加入某个年龄段（如例子中的年龄 6）后，总占用超过 Survivor 空间\*TargetSurvivorRatio 的时候，从该年龄段开始及大于的年龄对象就要进入老年代（即例子中的年龄 6 对象，就是年龄 6 和年龄 7 晋升到老年代），这时候无需等到 MaxTenuringThreshold 中要求的 15
 
 #### 3.3.8 如何判断一个对象需要被干掉
 
@@ -237,7 +243,6 @@ JVM内存会划分为堆内存和非堆内存，堆内存中也会划分为**年
 4.  本地方法栈（即 native 修饰的方法）中 JNI 引用的对象（JNI 是 Java 虚拟机调用对应的 C 函数的方式，通过 JNI 函数也可以创建新的 Java 对象。且 JNI 对于对象的局部引用或者全局引用都会把它们指向的对象都标记为不可回收）
 5.  已启动的且未终止的 Java 线程
 
-
 这种方法的优点是能够解决循环引用的问题，可它的实现需要耗费大量资源和时间，也需要 GC（它的分析过程引用关系不能发生变化，所以需要停止所有进程）
 
 #### 3.3.9 如何宣告一个对象的真正死亡
@@ -247,7 +252,7 @@ JVM内存会划分为堆内存和非堆内存，堆内存中也会划分为**年
 finalize()是 Object 类的一个方法、一个对象的 finalize()方法只会被系统自动调用一次，经过 finalize()方法逃脱死亡的对象，第二次不会再调用。
 
 补充一句：并不提倡在程序中调用 finalize()来进行自救。建议忘掉 Java 程序中该方法的存在。因为它执行的时间不确定，甚至是否被执行也不确定（Java 程序的不正常退出），而且运行代价高昂，无法保证各个对象的调用顺序（甚至有不同线程中调用）。在 Java9 中已经被标记为 **deprecated** ，且 `java.lang.ref.Cleaner`（也就是强、软、弱、幻象引用的那一套）中已经逐步替换掉它，会比 `finalize` 来的更加的轻量及可靠。
-　　
+
 ![](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/c807dab33f8b42329c1910d609e7ed21-new-image565aeab2-6d3e-4c2c-80f6-7a7b0f629fda.png)
 
 判断一个对象的死亡至少需要两次标记
@@ -311,21 +316,21 @@ HotSpot VM中的垃圾回收器，以及适用场景
 JVM 的参数非常之多，这里只列举比较重要的几个，通过各种各样的搜索引擎也可以得知这些信息。
 
 | 参数名称                   | 含义                                                         | 默认值                | 说明                                                         |
-|------|------------|------------|------|
+| -------------------------- | ------------------------------------------------------------ | --------------------- | ------------------------------------------------------------ |
-| -Xms  | 初始堆大小          | 物理内存的1/64(<1GB)         |默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制.
+| -Xms                       | 初始堆大小                                                   | 物理内存的 1/64(<1GB) | 默认(MinHeapFreeRatio 参数可以调整)空余堆内存小于 40%时，JVM 就会增大堆直到-Xmx 的最大限制. |
-| -Xmx  | 最大堆大小        | 物理内存的1/4(<1GB)        | 默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制
+| -Xmx                       | 最大堆大小                                                   | 物理内存的 1/4(<1GB)  | 默认(MaxHeapFreeRatio 参数可以调整)空余堆内存大于 70%时，JVM 会减少堆直到 -Xms 的最小限制 |
-| -Xmn  | 年轻代大小(1.4or later)       |        |注意：此处的大小是（eden+ 2 survivor space).与jmap -heap中显示的New gen是不同的。整个堆大小=年轻代大小 + 老年代大小 + 持久代（永久代）大小.增大年轻代后,将会减小年老代大小.此值对系统性能影响较大,Sun官方推荐配置为整个堆的3/8
+| -Xmn                       | 年轻代大小(1.4or later)                                      |                       | 注意：此处的大小是（eden+ 2 survivor space).与 jmap -heap 中显示的 New gen 是不同的。整个堆大小=年轻代大小 + 老年代大小 + 持久代（永久代）大小.增大年轻代后,将会减小年老代大小.此值对系统性能影响较大,Sun 官方推荐配置为整个堆的 3/8 |
-| -XX:NewSize  | 设置年轻代大小(for 1.3/1.4)          |          |
+| -XX:NewSize                | 设置年轻代大小(for 1.3/1.4)                                  |                       |                                                              |
-| -XX:MaxNewSize  | 年轻代最大值(for 1.3/1.4)        |         |
+| -XX:MaxNewSize             | 年轻代最大值(for 1.3/1.4)                                    |                       |                                                              |
-| -XX:PermSize  | 设置持久代(perm gen)初始值     | 物理内存的1/64       |
+| -XX:PermSize               | 设置持久代(perm gen)初始值                                   | 物理内存的 1/64       |                                                              |
-| -XX:MaxPermSize  | 设置持久代最大值          | 物理内存的1/4         |
+| -XX:MaxPermSize            | 设置持久代最大值                                             | 物理内存的 1/4        |                                                              |
-| -Xss  | 每个线程的堆栈大小        |         | JDK5.0以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K.根据应用的线程所需内存大小进行 调整.在相同物理内存下,减小这个值能生成更多的线程.但是操作系统对一个进程内的线程数还是有限制的,不能无限生成,经验值在3000~5000左右一般小的应用， 如果栈不是很深， 应该是128k够用的 大的应用建议使用256k。这个选项对性能影响比较大，需要严格的测试。（校长）和threadstacksize选项解释很类似,官方文档似乎没有解释,在论坛中有这样一句话:-Xss is translated in a VM flag named ThreadStackSize”一般设置这个值就可以了
+| -Xss                       | 每个线程的堆栈大小                                           |                       | JDK5.0 以后每个线程堆栈大小为 1M,以前每个线程堆栈大小为 256K.根据应用的线程所需内存大小进行 调整.在相同物理内存下,减小这个值能生成更多的线程.但是操作系统对一个进程内的线程数还是有限制的,不能无限生成,经验值在 3000~5000 左右一般小的应用， 如果栈不是很深， 应该是 128k 够用的 大的应用建议使用 256k。这个选项对性能影响比较大，需要严格的测试。（校长）和 threadstacksize 选项解释很类似,官方文档似乎没有解释,在论坛中有这样一句话:-Xss is translated in a VM flag named ThreadStackSize”一般设置这个值就可以了 |
-| -XX:NewRatio  | 年轻代(包括Eden和两个Survivor区)与年老代的比值(除去持久代)       |        |-XX:NewRatio=4表示年轻代与年老代所占比值为1:4,年轻代占整个堆栈的1/5Xms=Xmx并且设置了Xmn的情况下，该参数不需要进行设置。
+| -XX:NewRatio               | 年轻代(包括 Eden 和两个 Survivor 区)与年老代的比值(除去持久代) |                       | -XX:NewRatio=4 表示年轻代与年老代所占比值为 1:4,年轻代占整个堆栈的 1/5Xms=Xmx 并且设置了 Xmn 的情况下，该参数不需要进行设置。 |
-| -XX:SurvivorRatio  | Eden区与Survivor区的大小比值          |          |设置为8,则两个Survivor区与一个Eden区的比值为2:8,一个Survivor区占整个年轻代的1/10
+| -XX:SurvivorRatio          | Eden 区与 Survivor 区的大小比值                              |                       | 设置为 8,则两个 Survivor 区与一个 Eden 区的比值为 2:8,一个 Survivor 区占整个年轻代的 1/10 |
-| -XX:+DisableExplicitGC  | 关闭System.gc()        |         |这个参数需要严格的测试
+| -XX:+DisableExplicitGC     | 关闭 System.gc()                                             |                       | 这个参数需要严格的测试                                       |
-| -XX:PretenureSizeThreshold  | 对象超过多大是直接在旧生代分配       | 0      |单位字节 新生代采用Parallel ScavengeGC时无效另一种直接在旧生代分配的情况是大的数组对象,且数组中无外部引用对象.
+| -XX:PretenureSizeThreshold | 对象超过多大是直接在旧生代分配                               | 0                     | 单位字节 新生代采用 Parallel ScavengeGC 时无效另一种直接在旧生代分配的情况是大的数组对象,且数组中无外部引用对象. |
-| -XX:ParallelGCThreads  | 并行收集器的线程数         |          |此值最好配置与处理器数目相等 同样适用于CMS
+| -XX:ParallelGCThreads      | 并行收集器的线程数                                           |                       | 此值最好配置与处理器数目相等 同样适用于 CMS                  |
-| -XX:MaxGCPauseMillis  | 每次年轻代垃圾回收的最长时间(最大暂停时间)        |         |如果无法满足此时间,JVM会自动调整年轻代大小,以满足此值.
+| -XX:MaxGCPauseMillis       | 每次年轻代垃圾回收的最长时间(最大暂停时间)                   |                       | 如果无法满足此时间,JVM 会自动调整年轻代大小,以满足此值.      |
 
 其实还有一些打印及 CMS 方面的参数，这里就不以一一列举了
 
@@ -379,12 +384,10 @@ System.out.println("free mem=" + Runtime.getRuntime().freeMemory() / 1024.0 / 10
 System.out.println("total mem=" + Runtime.getRuntime().totalMemory() / 1024.0 / 1024 + "M");
 ```
 
-
 ![](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/bdd717d0a3394be7a733760052773374-new-image371b5d59-0020-4091-9874-603c0ab0073d.png)
 
 此时 free memory 就又缩水了，不过 total memory 是没有变化的。Java 会尽可能将 total mem 的值维持在最小堆内存大小
 
-
 ```java
 byte[] b = new byte[10 * 1024 * 1024];
 System.out.println("分配了10M空间给数组");
@@ -412,7 +415,7 @@ System.out.println("total mem=" + Runtime.getRuntime().totalMemory() / 1024.0 /
 
 ### 4.2 调整新生代和老年代的比值
 
--XX:NewRatio --- 新生代（eden+2*Survivor）和老年代（不包含永久区）的比值
+-XX:NewRatio --- 新生代（eden+2\*Survivor）和老年代（不包含永久区）的比值
 
 例如：-XX:NewRatio=4，表示新生代:老年代=1:4，即新生代占整个堆的 1/5。在 Xms=Xmx 并且设置了 Xmn 的情况下，该参数不需要进行设置。
 
@@ -457,6 +460,7 @@ tips：如果堆空间没有用完也抛出了OOM，有可能是永久区导致
 JDK5.0 以后每个线程堆栈大小为 1M，以前每个线程堆栈大小为 256K。在相同物理内存下,减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在 3000~5000 左右
 
 #### 4.7.2 设置线程栈的大小
+
     -XXThreadStackSize：
         设置线程栈的大小(0 means use default stack size)
 
@@ -477,10 +481,12 @@ JDK5.0以后每个线程堆栈大小为1M，以前每个线程堆栈大小为256
         设置原始类型的快速优化
 
 #### 4.8.3 设置关闭手动 GC
+
     -XX:+DisableExplicitGC：
         设置关闭System.gc()(这个参数需要严格的测试)
 
 #### 4.8.4 设置垃圾最大年龄
+
     -XX:MaxTenuringThreshold
         设置垃圾最大年龄。如果设置为0的话,则年轻代对象不经过Survivor区,直接进入年老代.
         对于年老代比较多的应用,可以提高效率。如果将此值设置为一个较大值,
@@ -488,32 +494,39 @@ JDK5.0以后每个线程堆栈大小为1M，以前每个线程堆栈大小为256
         增加在年轻代即被回收的概率。该参数只有在串行GC时才有效.
 
 #### 4.8.5 加快编译速度
+
     -XX:+AggressiveOpts
+
 加快编译速度
 
 #### 4.8.6 改善锁机制性能
+
     -XX:+UseBiasedLocking
 
 #### 4.8.7 禁用垃圾回收
+
     -Xnoclassgc
 
 #### 4.8.8 设置堆空间存活时间
+
     -XX:SoftRefLRUPolicyMSPerMB
         设置每兆堆空闲空间中SoftReference的存活时间，默认值是1s。
 
 #### 4.8.9 设置对象直接分配在老年代
+
     -XX:PretenureSizeThreshold
         设置对象超过多大时直接在老年代分配，默认值是0。
 
 #### 4.8.10 设置 TLAB 占 eden 区的比例
+
     -XX:TLABWasteTargetPercent
         设置TLAB占eden区的百分比，默认值是1% 。
 
 #### 4.8.11 设置是否优先 YGC
+
     -XX:+CollectGen0First
         设置FullGC时是否先YGC，默认值是false。
 
-
 ## finally
 
 真的扯了很久这东西，参考了多方的资料，有极客时间的《深入拆解虚拟机》和《Java 核心技术面试精讲》，也有百度，也有自己在学习的一些线上课程的总结。希望对你有所帮助，谢谢。