- 
)
- 
+
| 
| 
|
+| Project | Article |
+| :-----: | :----------------------------------------------------------- |
+| Maven | |
+| Git | |
+| IDEA | |
+| Jenkins | |
-二维码没有正常显示？点 [这里😎](https://doc.xugaoyi.com/pages/1b12ed/)
-## 致谢
-:heart:感谢支持这个项目的朋友
-:heart:感谢为这个项目贡献代码的朋友 → [Contributors](https://github.com/xugaoyi/vuepress-theme-vdoing/graphs/contributors)
+## 🎨 设计模式
+
+| Project | Article |
+| :------------------: | :----------------------------------------------------------- |
+| 23 种设计模式 | |
+
+
+
+## 🌍 SOA 架构
+
+| Project | Version | Article |
+| :-------: | :-----: | :----------------------------------------------------------- |
+| Zookeeper | 3.5.6 | |
+
+
+
+## 👨🏿💻 Big Data
+
+| Project | Version | Article |
+| :------: | :-----: | :------------------------------------------------ |
+| Big Data | | |
+
-## 交流群
-
- 
- vdoing微信群(添加我的微信进群) - |
-
- 
- vdoing QQ群: 694387113 - |
-
+ [扫码反馈] (opens new window)
`,
// `
diff --git a/docs/.vuepress/public/img/JavaDriver.png b/docs/.vuepress/public/img/JavaDriver.png
new file mode 100644
index 000000000..0baffd26b
Binary files /dev/null and b/docs/.vuepress/public/img/JavaDriver.png differ
diff --git a/docs/.vuepress/public/img/head_photo.JPG b/docs/.vuepress/public/img/head_photo.png
similarity index 100%
rename from docs/.vuepress/public/img/head_photo.JPG
rename to docs/.vuepress/public/img/head_photo.png
diff --git "a/docs/01.Java\347\233\270\345\205\263/30.JVM/001.JVM.md" "b/docs/01.Java\347\233\270\345\205\263/30.JVM/001.JVM.md"
deleted file mode 100644
index c7e40a4e5..000000000
--- "a/docs/01.Java\347\233\270\345\205\263/30.JVM/001.JVM.md"
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: JVM
-date: 2022-03-11 00:47:23
-permalink: /pages/5f2105/
-categories:
- - Java相关
- - JVM
-tags:
- -
----
-## Java 中垃圾回收机制中如何判断对象需要回收？常见的 GC 回收算法有哪些？
-## Java 中如何进行 GC 调优？
-## JMM 中内存模型是怎样的？什么是指令序列重排序？
-## JVM 内存是如何对应到操作系统内存的？
-## JVM 是怎么去调优的？了解哪些参数和指令？
-## 什么是内存泄漏，怎么确定内存泄漏？
-## 简述 CMS 与 G1 机制的区别
\ No newline at end of file
diff --git "a/docs/01.Java\347\233\270\345\205\263/30.JVM/001.Java \344\270\255\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266\344\270\255\345\246\202\344\275\225\345\210\244\346\226\255\345\257\271\350\261\241\351\234\200\350\246\201\345\233\236\346\224\266\357\274\237.md" "b/docs/01.Java\347\233\270\345\205\263/30.JVM/001.Java \344\270\255\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266\344\270\255\345\246\202\344\275\225\345\210\244\346\226\255\345\257\271\350\261\241\351\234\200\350\246\201\345\233\236\346\224\266\357\274\237.md"
new file mode 100644
index 000000000..70ba53364
--- /dev/null
+++ "b/docs/01.Java\347\233\270\345\205\263/30.JVM/001.Java \344\270\255\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266\344\270\255\345\246\202\344\275\225\345\210\244\346\226\255\345\257\271\350\261\241\351\234\200\350\246\201\345\233\236\346\224\266\357\274\237.md"
@@ -0,0 +1,107 @@
+---
+title: Java 中垃圾回收机制中如何判断对象需要回收？
+date: 2022-05-21 17:31:41
+permalink: /pages/948850/
+categories:
+ - Java相关
+ - JVM
+tags:
+ -
+---
+Java 中垃圾回收机制中如何判断对象需要回收？
+即死亡对象判断方法
+堆中几乎放着所有的对象实例，对堆垃圾回收前的第一步就是要判断哪些对象已经死亡（即不能再被任何途径使用的对象）。
+
+## 引用计数法
+给对象中添加一个引用计数器：
+
+每当有一个地方引用它，计数器就加 1；
+当引用失效，计数器就减 1；
+任何时候计数器为 0 的对象就是不可能再被使用的。
+这个方法实现简单，效率高，但是目前主流的虚拟机中并没有选择这个算法来管理内存，其最主要的原因是它很难解决对象之间相互循环引用的问题。
+
+所谓对象之间的相互引用问题，如下面代码所示：除了对象 objA 和 objB 相互引用着对方之外，这两个对象之间再无任何引用。但是他们因为互相引用对方，导致它们的引用计数器都不为 0，于是引用计数算法无法通知 GC 回收器回收他们。
+```java
+public class ReferenceCountingGc {
+ Object instance = null;
+ public static void main(String[] args) {
+ ReferenceCountingGc objA = new ReferenceCountingGc();
+ ReferenceCountingGc objB = new ReferenceCountingGc();
+ objA.instance = objB;
+ objB.instance = objA;
+ objA = null;
+ objB = null;
+ }
+}
+```
+
+## 可达性分析算法
+这个算法的基本思想就是通过一系列的称为 “GC Roots” 的对象作为起点，从这些节点开始向下搜索，节点所走过的路径称为引用链，当一个对象到 GC Roots 没有任何引用链相连的话，则证明此对象是不可用的，需要被回收。
+
+下图中的 Object 6 ~ Object 10 之间虽有引用关系，但它们到 GC Roots 不可达，因此为需要被回收的对象。
+
+
+哪些对象可以作为 GC Roots 呢？
+
+虚拟机栈(栈帧中的本地变量表)中引用的对象
+本地方法栈(Native 方法)中引用的对象
+方法区中类静态属性引用的对象
+方法区中常量引用的对象
+所有被同步锁持有的对象
+对象可以被回收，就代表一定会被回收吗？
+
+即使在可达性分析法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑阶段”，要真正宣告一个对象死亡，至少要经历两次标记过程；可达性分析法中不可达的对象被第一次标记并且进行一次筛选，筛选的条件是此对象是否有必要执行 'finalize' 方法。当对象没有覆盖 'finalize' 方法，或 'finalize' 方法已经被虚拟机调用过时，虚拟机将这两种情况视为没有必要执行。
+
+被判定为需要执行的对象将会被放在一个队列中进行第二次标记，除非这个对象与引用链上的任何一个对象建立关联，否则就会被真的回收。
+
+>Object 类中的 finalize 方法一直被认为是一个糟糕的设计，成为了 Java 语言的负担，影响了 Java 语言的安全和 GC 的性能。JDK9 版本及后续版本中各个类中的 finalize 方法会被逐渐弃用移除。忘掉它的存在吧！
+
+
+## 引用类型总结
+无论是通过引用计数法判断对象引用数量，还是通过可达性分析法判断对象的引用链是否可达，判定对象的存活都与“引用”有关。
+
+JDK1.2 之前，Java 中引用的定义很传统：如果 reference 类型的数据存储的数值代表的是另一块内存的起始地址，就称这块内存代表一个引用。
+
+JDK1.2 以后，Java 对引用的概念进行了扩充，将引用分为强引用、软引用、弱引用、虚引用四种（引用强度逐渐减弱）
+
+1．强引用（StrongReference）
+
+以前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，Java 虚拟机宁愿抛出 OutOfMemoryError 错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。
+
+2．软引用（SoftReference）
+
+如果一个对象只具有软引用，那就类似于可有可无的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
+
+软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，JAVA 虚拟机就会把这个软引用加入到与之关联的引用队列中。
+
+3．弱引用（WeakReference）
+
+如果一个对象只具有弱引用，那就类似于可有可无的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。
+
+弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java 虚拟机就会把这个弱引用加入到与之关联的引用队列中。
+
+4．虚引用（PhantomReference）
+
+"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。
+
+虚引用主要用来跟踪对象被垃圾回收的活动。
+
+虚引用与软引用和弱引用的一个区别在于： 虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
+
+特别注意，在程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，这是因为软引用可以加速 JVM 对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生。
+
+
+## 如何判断一个常量是废弃常量？
+运行时常量池主要回收的是废弃的常量。那么，我们如何判断一个常量是废弃常量呢？
+
+假如在字符串常量池中存在字符串 "abc"，如果当前没有任何 String 对象引用该字符串常量的话，就说明常量 "abc" 就是废弃常量，如果这时发生内存回收的话而且有必要的话，"abc" 就会被系统清理出常量池了。
+
+## 如何判断一个类是无用的类
+方法区主要回收的是无用的类，那么如何判断一个类是无用的类的呢？
+
+判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。类需要同时满足下面 3 个条件才能算是 “无用的类” ：
+
+* 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
+* 加载该类的 ClassLoader 已经被回收。
+* 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。
+虚拟机可以对满足上述 3 个条件的无用类进行回收，这里说的仅仅是“可以”，而并不是和对象一样不使用了就会必然被回收。
\ No newline at end of file
diff --git "a/docs/01.Java\347\233\270\345\205\263/30.JVM/010.\345\270\270\350\247\201\347\232\204 GC \345\233\236\346\224\266\347\256\227\346\263\225\346\234\211\345\223\252\344\272\233\357\274\237.md" "b/docs/01.Java\347\233\270\345\205\263/30.JVM/010.\345\270\270\350\247\201\347\232\204 GC \345\233\236\346\224\266\347\256\227\346\263\225\346\234\211\345\223\252\344\272\233\357\274\237.md"
new file mode 100644
index 000000000..f5c74f19b
--- /dev/null
+++ "b/docs/01.Java\347\233\270\345\205\263/30.JVM/010.\345\270\270\350\247\201\347\232\204 GC \345\233\236\346\224\266\347\256\227\346\263\225\346\234\211\345\223\252\344\272\233\357\274\237.md"
@@ -0,0 +1,141 @@
+---
+title: 常见的 GC 回收算法有哪些？
+date: 2022-09-18 19:01:29
+permalink: /pages/9b26e8/
+categories:
+ - Java相关
+ - JVM
+tags:
+ -
+---
+## 标记-清除算法
+该算法分为“标记”和“清除”阶段：首先标记出所有不需要回收的对象，在标记完成后统一回收掉所有没有被标记的对象。它是最基础的收集算法，后续的算法都是对其不足进行改进得到。这种垃圾收集算法会带来两个明显的问题：
+
+效率问题
+空间问题（标记清除后会产生大量不连续的碎片）
+
+
+## 标记-复制算法
+为了解决效率问题，“标记-复制”收集算法出现了。它可以将内存分为大小相同的两块，每次使用其中的一块。当这一块的内存使用完后，就将还存活的对象复制到另一块去，然后再把使用的空间一次清理掉。这样就使每次的内存回收都是对内存区间的一半进行回收。
+
+
+## 标记-整理算法
+根据老年代的特点提出的一种标记算法，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象回收，而是让所有存活的对象向一端移动，然后直接清理掉端边界以外的内存。
+
+
+## 分代收集算法
+当前虚拟机的垃圾收集都采用分代收集算法，这种算法没有什么新的思想，只是根据对象存活周期的不同将内存分为几块。一般将 java 堆分为新生代和老年代，这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
+
+比如在新生代中，每次收集都会有大量对象死去，所以可以选择”标记-复制“算法，只需要付出少量对象的复制成本就可以完成每次垃圾收集。而老年代的对象存活几率是比较高的，而且没有额外的空间对它进行分配担保，所以我们必须选择“标记-清除”或“标记-整理”算法进行垃圾收集。
+
+延伸面试问题： HotSpot 为什么要分为新生代和老年代？
+
+根据上面的对分代收集算法的介绍回答。
+
+## 垃圾收集器
+如果说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。
+
+虽然我们对各个收集器进行比较，但并非要挑选出一个最好的收集器。因为直到现在为止还没有最好的垃圾收集器出现，更加没有万能的垃圾收集器，我们能做的就是根据具体应用场景选择适合自己的垃圾收集器。试想一下：如果有一种四海之内、任何场景下都适用的完美收集器存在，那么我们的 HotSpot 虚拟机就不会实现那么多不同的垃圾收集器了。
+
+## Serial 收集器
+Serial（串行）收集器是最基本、历史最悠久的垃圾收集器了。大家看名字就知道这个收集器是一个单线程收集器了。它的 “单线程” 的意义不仅仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工作，更重要的是它在进行垃圾收集工作的时候必须暂停其他所有的工作线程（ "Stop The World" ），直到它收集结束。
+
+新生代采用标记-复制算法，老年代采用标记-整理算法。
+
+
+
+虚拟机的设计者们当然知道 Stop The World 带来的不良用户体验，所以在后续的垃圾收集器设计中停顿时间在不断缩短（仍然还有停顿，寻找最优秀的垃圾收集器的过程仍然在继续）。
+
+但是 Serial 收集器有没有优于其他垃圾收集器的地方呢？当然有，它简单而高效（与其他收集器的单线程相比）。Serial 收集器由于没有线程交互的开销，自然可以获得很高的单线程收集效率。Serial 收集器对于运行在 Client 模式下的虚拟机来说是个不错的选择。
+
+## ParNew 收集器
+ParNew 收集器其实就是 Serial 收集器的多线程版本，除了使用多线程进行垃圾收集外，其余行为（控制参数、收集算法、回收策略等等）和 Serial 收集器完全一样。
+
+新生代采用标记-复制算法，老年代采用标记-整理算法。
+
+
+
+它是许多运行在 Server 模式下的虚拟机的首要选择，除了 Serial 收集器外，只有它能与 CMS 收集器（真正意义上的并发收集器，后面会介绍到）配合工作。
+
+并行和并发概念补充：
+
+并行（Parallel） ：指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。
+
+并发（Concurrent）：指用户线程与垃圾收集线程同时执行（但不一定是并行，可能会交替执行），用户程序在继续运行，而垃圾收集器运行在另一个 CPU 上。
+
+## Parallel Scavenge 收集器
+Parallel Scavenge 收集器也是使用标记-复制算法的多线程收集器，它看上去几乎和 ParNew 都一样。 那么它有什么特别之处呢？
+
+```xml
+-XX:+UseParallelGC
+
+ 使用 Parallel 收集器+ 老年代串行
+
+-XX:+UseParallelOldGC
+
+ 使用 Parallel 收集器+ 老年代并行
+```
+
+Parallel Scavenge 收集器关注点是吞吐量（高效率的利用 CPU）。CMS 等垃圾收集器的关注点更多的是用户线程的停顿时间（提高用户体验）。所谓吞吐量就是 CPU 中用于运行用户代码的时间与 CPU 总消耗时间的比值。 Parallel Scavenge 收集器提供了很多参数供用户找到最合适的停顿时间或最大吞吐量，如果对于收集器运作不太了解，手工优化存在困难的时候，使用 Parallel Scavenge 收集器配合自适应调节策略，把内存管理优化交给虚拟机去完成也是一个不错的选择。
+
+新生代采用标记-复制算法，老年代采用标记-整理算法。
+
+
+
+这是 JDK1.8 默认收集器
+
+使用 java -XX:+PrintCommandLineFlags -version 命令查看
+
+```xml
+-XX:InitialHeapSize=262921408 -XX:MaxHeapSize=4206742528 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseParallelGC
+java version "1.8.0_211"
+Java(TM) SE Runtime Environment (build 1.8.0_211-b12)
+Java HotSpot(TM) 64-Bit Server VM (build 25.211-b12, mixed mode)
+JDK1.8 默认使用的是 Parallel Scavenge + Parallel Old，如果指定了-XX:+UseParallelGC 参数，则默认指定了-XX:+UseParallelOldGC，可以使用-XX:-UseParallelOldGC 来禁用该功能
+```
+## Serial Old 收集器
+Serial 收集器的老年代版本，它同样是一个单线程收集器。它主要有两大用途：一种用途是在 JDK1.5 以及以前的版本中与 Parallel Scavenge 收集器搭配使用，另一种用途是作为 CMS 收集器的后备方案。
+
+## Parallel Old 收集器
+Parallel Scavenge 收集器的老年代版本。使用多线程和“标记-整理”算法。在注重吞吐量以及 CPU 资源的场合，都可以优先考虑 Parallel Scavenge 收集器和 Parallel Old 收集器。
+
+## CMS 收集器
+CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它非常符合在注重用户体验的应用上使用。
+
+CMS（Concurrent Mark Sweep）收集器是 HotSpot 虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。
+
+从名字中的Mark Sweep这两个词可以看出，CMS 收集器是一种 “标记-清除”算法实现的，它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤：
+
+初始标记： 暂停所有的其他线程，并记录下直接与 root 相连的对象，速度很快 ；
+并发标记： 同时开启 GC 和用户线程，用一个闭包结构去记录可达对象。但在这个阶段结束，这个闭包结构并不能保证包含当前所有的可达对象。因为用户线程可能会不断的更新引用域，所以 GC 线程无法保证可达性分析的实时性。所以这个算法里会跟踪记录这些发生引用更新的地方。
+重新标记： 重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短
+并发清除： 开启用户线程，同时 GC 线程开始对未标记的区域做清扫。
+
+
+从它的名字就可以看出它是一款优秀的垃圾收集器，主要优点：并发收集、低停顿。但是它有下面三个明显的缺点：
+
+对 CPU 资源敏感；
+无法处理浮动垃圾；
+它使用的回收算法-“标记-清除”算法会导致收集结束时会有大量空间碎片产生。
+## G1 收集器
+G1 (Garbage-First) 是一款面向服务器的垃圾收集器,主要针对配备多颗处理器及大容量内存的机器. 以极高概率满足 GC 停顿时间要求的同时,还具备高吞吐量性能特征.
+
+被视为 JDK1.7 中 HotSpot 虚拟机的一个重要进化特征。它具备以下特点：
+
+并行与并发：G1 能充分利用 CPU、多核环境下的硬件优势，使用多个 CPU（CPU 或者 CPU 核心）来缩短 Stop-The-World 停顿时间。部分其他收集器原本需要停顿 Java 线程执行的 GC 动作，G1 收集器仍然可以通过并发的方式让 java 程序继续执行。
+分代收集：虽然 G1 可以不需要其他收集器配合就能独立管理整个 GC 堆，但是还是保留了分代的概念。
+空间整合：与 CMS 的“标记-清理”算法不同，G1 从整体来看是基于“标记-整理”算法实现的收集器；从局部上来看是基于“标记-复制”算法实现的。
+可预测的停顿：这是 G1 相对于 CMS 的另一个大优势，降低停顿时间是 G1 和 CMS 共同的关注点，但 G1 除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为 M 毫秒的时间片段内。
+G1 收集器的运作大致分为以下几个步骤：
+
+初始标记
+并发标记
+最终标记
+筛选回收
+G1 收集器在后台维护了一个优先列表，每次根据允许的收集时间，优先选择回收价值最大的 Region(这也就是它的名字 Garbage-First 的由来) 。这种使用 Region 划分内存空间以及有优先级的区域回收方式，保证了 G1 收集器在有限时间内可以尽可能高的收集效率（把内存化整为零）。
+
+## ZGC 收集器
+与 CMS 中的 ParNew 和 G1 类似，ZGC 也采用标记-复制算法，不过 ZGC 对该算法做了重大改进。
+
+在 ZGC 中出现 Stop The World 的情况会更少！
+详情可以看 ： [《新一代垃圾回收器 ZGC 的探索与实践》](https://tech.meituan.com/2020/08/06/new-zgc-practice-in-meituan.html)
\ No newline at end of file
diff --git "a/docs/01.Java\347\233\270\345\205\263/30.JVM/020.Java \344\270\255\345\246\202\344\275\225\350\277\233\350\241\214 GC \350\260\203\344\274\230\357\274\237.md" "b/docs/01.Java\347\233\270\345\205\263/30.JVM/020.Java \344\270\255\345\246\202\344\275\225\350\277\233\350\241\214 GC \350\260\203\344\274\230\357\274\237.md"
new file mode 100644
index 000000000..b1485c139
--- /dev/null
+++ "b/docs/01.Java\347\233\270\345\205\263/30.JVM/020.Java \344\270\255\345\246\202\344\275\225\350\277\233\350\241\214 GC \350\260\203\344\274\230\357\274\237.md"
@@ -0,0 +1,94 @@
+---
+title: Java 中如何进行 GC 调优？
+date: 2022-05-21 17:31:53
+permalink: /pages/07a030/
+categories:
+ - Java相关
+ - JVM
+tags:
+ -
+---
+当Java程序性能达不到既定目标，且其他优化手段都已经穷尽时，通常需要调整垃圾回收器来进一步提高性能，称为GC优化。
+但GC算法复杂，影响GC性能的参数众多，且参数调整又依赖于应用各自的特点，这些因素很大程度上增加了GC优化的难度。
+
+即便如此，GC调优也不是无章可循，仍然有一些通用的思考方法。
+
+本篇会介绍这些通用的GC优化策略和相关实践案例，主要包括如下内容：
+
+>优化前准备: 简单回顾JVM相关知识、介绍GC优化的一些通用策略。
+> 优化方法: 介绍调优的一般流程：明确优化目标→优化→跟踪优化结果。
+> 优化案例: 简述笔者所在团队遇到的GC问题以及优化方案。
+
+# 一、优化前的准备
+## GC优化需知
+为了更好地理解本篇所介绍的内容，你需要了解如下内容。 1. GC相关基础知识，包括但不限于： a) GC工作原理。 b) 理解新生代、老年代、晋升等术语含义。 c) 可以看懂GC日志。
+
+GC优化不能解决一切性能问题，它是最后的调优手段。
+如果对第一点中提及的知识点不是很熟悉，可以先阅读小结-JVM基础回顾；如果已经很熟悉，可以跳过该节直接往下阅读。
+
+# JVM基础回顾
+## JVM内存结构
+简单介绍一下JVM内存结构和常见的垃圾回收器。
+
+当代主流虚拟机（Hotspot VM）的垃圾回收都采用“分代回收”的算法。“分代回收”是基于这样一个事实：对象的生命周期不同，所以针对不同生命周期的对象可以采取不同的回收方式，以便提高回收效率。
+
+Hotspot VM将内存划分为不同的物理区，就是“分代”思想的体现。如图所示，JVM内存主要由新生代、老年代、永久代构成。
+
+
+
+① 新生代（Young Generation）：大多数对象在新生代中被创建，其中很多对象的生命周期很短。每次新生代的垃圾回收（又称Minor GC）后只有少量对象存活，所以选用复制算法，只需要少量的复制成本就可以完成回收。
+
+新生代内又分三个区：一个Eden区，两个Survivor区（一般而言），大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到两个Survivor区（中的一个）。当这个Survivor区满时，此区的存活且不满足“晋升”条件的对象将被复制到另外一个Survivor区。对象每经历一次Minor GC，年龄加1，达到“晋升年龄阈值”后，被放到老年代，这个过程也称为“晋升”。显然，“晋升年龄阈值”的大小直接影响着对象在新生代中的停留时间，在Serial和ParNew GC两种回收器中，“晋升年龄阈值”通过参数MaxTenuringThreshold设定，默认值为15。
+
+② 老年代（Old Generation）：在新生代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代，该区域中对象存活率高。老年代的垃圾回收（又称Major GC）通常使用“标记-清理”或“标记-整理”算法。整堆包括新生代和老年代的垃圾回收称为Full GC（HotSpot VM里，除了CMS之外，其它能收集老年代的GC都会同时收集整个GC堆，包括新生代）。
+
+③ 永久代（Perm Generation）：主要存放元数据，例如Class、Method的元信息，与垃圾回收要回收的Java对象关系不大。相对于新生代和年老代来说，该区域的划分对垃圾回收影响比较小。
+
+## 常见垃圾回收器
+不同的垃圾回收器，适用于不同的场景。常用的垃圾回收器：
+
+串行（Serial）回收器是单线程的一个回收器，简单、易实现、效率高。
+并行（ParNew）回收器是Serial的多线程版，可以充分的利用CPU资源，减少回收的时间。
+吞吐量优先（Parallel Scavenge）回收器，侧重于吞吐量的控制。
+并发标记清除（CMS，Concurrent Mark Sweep）回收器是一种以获取最短回收停顿时间为目标的回收器，该回收器是基于“标记-清除”算法实现的。
+GC日志
+每一种回收器的日志格式都是由其自身的实现决定的，换而言之，每种回收器的日志格式都可以不一样。但虚拟机设计者为了方便用户阅读，将各个回收器的日志都维持一定的共性。JavaGC日志 中简单介绍了这些共性。
+
+## 参数基本策略
+各分区的大小对GC的性能影响很大。如何将各分区调整到合适的大小，分析活跃数据的大小是很好的切入点。
+
+活跃数据的大小是指，应用程序稳定运行时长期存活对象在堆中占用的空间大小，也就是Full GC后堆中老年代占用空间的大小。可以通过GC日志中Full GC之后老年代数据大小得出，比较准确的方法是在程序稳定后，多次获取GC数据，通过取平均值的方式计算活跃数据的大小。活跃数据和各分区之间的比例关系如下（见参考文献1）：
+
+
+例如，根据GC日志获得老年代的活跃数据大小为300M，那么各分区大小可以设为：
+
+总堆：1200MB = 300MB × 4* 新生代：450MB = 300MB × 1.5* 老年代： 750MB = 1200MB - 450MB*
+
+这部分设置仅仅是堆大小的初始值，后面的优化中，可能会调整这些值，具体情况取决于应用程序的特性和需求。
+
+# 二、优化步骤
+GC优化一般步骤可以概括为：确定目标、优化参数、验收结果。
+
+## 确定目标
+明确应用程序的系统需求是性能优化的基础，系统的需求是指应用程序运行时某方面的要求，譬如： - 高可用，可用性达到几个9。 - 低延迟，请求必须多少毫秒内完成响应。 - 高吞吐，每秒完成多少次事务。
+
+明确系统需求之所以重要，是因为上述性能指标间可能冲突。比如通常情况下，缩小延迟的代价是降低吞吐量或者消耗更多的内存或者两者同时发生。
+
+由于笔者所在团队主要关注高可用和低延迟两项指标，所以接下来分析，如何量化GC时间和频率对于响应时间和可用性的影响。通过这个量化指标，可以计算出当前GC情况对服务的影响，也能评估出GC优化后对响应时间的收益，这两点对于低延迟服务很重要。
+
+举例：假设单位时间T内发生一次持续25ms的GC，接口平均响应时间为50ms，且请求均匀到达，根据下图所示：
+
+
+
+那么有(50ms+25ms)/T比例的请求会受GC影响，其中GC前的50ms内到达的请求都会增加25ms，GC期间的25ms内到达的请求，会增加0-25ms不等，如果时间T内发生N次GC，受GC影响请求占比=(接口响应时间+GC时间)×N/T 。可见无论降低单次GC时间还是降低GC次数N都可以有效减少GC对响应时间的影响。
+
+## 优化
+通过收集GC信息，结合系统需求，确定优化方案，例如选用合适的GC回收器、重新设置内存比例、调整JVM参数等。
+
+进行调整后，将不同的优化方案分别应用到多台机器上，然后比较这些机器上GC的性能差异，有针对性的做出选择，再通过不断的试验和观察，找到最合适的参数。
+
+## 验收优化结果
+将修改应用到所有服务器，判断优化结果是否符合预期，总结相关经验。
+
+
+参考：[美团技术团队-从实际案例聊聊Java应用的GC优化](https://tech.meituan.com/2017/12/29/jvm-optimize.html)
\ No newline at end of file
diff --git "a/docs/01.Java\347\233\270\345\205\263/30.JVM/030.JMM \344\270\255\345\206\205\345\255\230\346\250\241\345\236\213\346\230\257\346\200\216\346\240\267\347\232\204\357\274\237\344\273\200\344\271\210\346\230\257\346\214\207\344\273\244\345\272\217\345\210\227\351\207\215\346\216\222\345\272\217\357\274\237.md" "b/docs/01.Java\347\233\270\345\205\263/30.JVM/030.JMM \344\270\255\345\206\205\345\255\230\346\250\241\345\236\213\346\230\257\346\200\216\346\240\267\347\232\204\357\274\237\344\273\200\344\271\210\346\230\257\346\214\207\344\273\244\345\272\217\345\210\227\351\207\215\346\216\222\345\272\217\357\274\237.md"
new file mode 100644
index 000000000..67ef47f0d
--- /dev/null
+++ "b/docs/01.Java\347\233\270\345\205\263/30.JVM/030.JMM \344\270\255\345\206\205\345\255\230\346\250\241\345\236\213\346\230\257\346\200\216\346\240\267\347\232\204\357\274\237\344\273\200\344\271\210\346\230\257\346\214\207\344\273\244\345\272\217\345\210\227\351\207\215\346\216\222\345\272\217\357\274\237.md"
@@ -0,0 +1,84 @@
+---
+title: JMM 中内存模型是怎样的？什么是指令序列重排序？
+date: 2022-05-21 17:32:49
+permalink: /pages/c8e6cb/
+categories:
+ - Java相关
+ - JVM
+tags:
+ -
+---
+Java内存模型(JMM)和 Java 运行时内存区域是不一样的概念。
+## 为什么要有内存模型？
+
+要想回答这个问题，我们需要先弄懂传统计算机硬件内存架构。好了，我要开始画图了。
+
+## 硬件内存架构
+
+
+（1）CPU
+
+去过机房的同学都知道，一般在大型服务器上会配置多个CPU，每个CPU还会有多个
+
+核
+
+，这就意味着多个CPU或者多个核可以同时（并发）工作。如果使用Java 起了一个多线程的任务，很有可能每个 CPU 都会跑一个线程，那么你的任务在某一刻就是真正并发执行了。
+
+（2）CPU Register
+
+CPU Register也就是 CPU 寄存器。CPU 寄存器是 CPU 内部集成的，在寄存器上执行操作的效率要比在主存上高出几个数量级。
+
+（3）CPU Cache Memory
+
+CPU Cache Memory也就是 CPU 高速缓存，相对于寄存器来说，通常也可以成为 L2 二级缓存。相对于硬盘读取速度来说内存读取的效率非常高，但是与 CPU 还是相差数量级，所以在 CPU 和主存间引入了多级缓存，目的是为了做一下缓冲。
+
+（4）Main Memory
+
+Main Memory 就是主存，主存比 L1、L2 缓存要大很多。
+
+注意：部分高端机器还有 L3 三级缓存。
+
+## 缓存一致性问题
+
+由于主存与 CPU 处理器的运算能力之间有数量级的差距，所以在传统计算机内存架构中会引入高速缓存来作为主存和处理器之间的缓冲，CPU 将常用的数据放在高速缓存中，运算结束后 CPU 再讲运算结果同步到主存中。
+
+使用高速缓存解决了 CPU 和主存速率不匹配的问题，但同时又引入另外一个新问题：缓存一致性问题。
+
+
+在多CPU的系统中(或者单CPU多核的系统)，每个CPU内核都有自己的高速缓存，它们共享同一主内存(Main Memory)。当多个CPU的运算任务都涉及同一块主内存区域时，CPU 会将数据读取到缓存中进行运算，这可能会导致各自的缓存数据不一致。
+
+因此需要每个 CPU 访问缓存时遵循一定的协议，在读写数据时根据协议进行操作，共同来维护缓存的一致性。这类协议有 MSI、MESI、MOSI、和 Dragon Protocol 等。
+
+## 处理器优化和指令重排序
+
+为了提升性能在 CPU 和主内存之间增加了高速缓存，但在多线程并发场景可能会遇到
+
+。那还有没有办法进一步提升 CPU 的执行效率呢？答案是：处理器优化。
+
+为了使处理器内部的运算单元能够最大化被充分利用，处理器会对输入代码进行乱序执行处理，这就是处理器优化。
+
+除了处理器会对代码进行优化处理，很多现代编程语言的编译器也会做类似的优化，比如像 Java 的即时编译器（JIT）会做指令重排序。
+
+
+处理器优化其实也是重排序的一种类型，这里总结一下，重排序可以分为三种类型：
+** 编译器优化的重排序。编译器在不改变单线程程序语义放入前提下，可以重新安排语句的执行顺序。
+** 指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
+** 内存系统的重排序。由于处理器使用缓存和读写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。
+
+## 并发编程的问题
+
+上面讲了一堆硬件相关的东西，有些同学可能会有点懵，绕了这么大圈，这些东西跟 Java 内存模型有啥关系吗？不要急咱们慢慢往下看。
+
+熟悉 Java 并发的同学肯定对这三个问题很熟悉：『可见性问题』、『原子性问题』、『有序性问题』。如果从更深层次看这三个问题，其实就是上面讲的『缓存一致性』、『处理器优化』、『指令重排序』造成的。
+
+
+缓存一致性问题其实就是可见性问题，处理器优化可能会造成原子性问题，指令重排序会造成有序性问题，你看是不是都联系上了。
+
+出了问题总是要解决的，那有什么办法呢？首先想到简单粗暴的办法，干掉缓存让 CPU 直接与主内存交互就解决了可见性问题，禁止处理器优化和指令重排序就解决了原子性和有序性问题，但这样一夜回到解放前了，显然不可取。
+
+所以技术前辈们想到了在物理机器上定义出一套内存模型， 规范内存的读写操作。内存模型解决并发问题主要采用两种方式：
+
+限制处理器优化和使用内存屏障。
+
+参考：
+[全面学习掌握Java内存模型](https://baijiahao.baidu.com/s?id=1700599301374287320&wfr=spider&for=pc)
\ No newline at end of file
diff --git "a/docs/01.Java\347\233\270\345\205\263/30.JVM/040.JVM \345\206\205\345\255\230\346\230\257\345\246\202\344\275\225\345\257\271\345\272\224\345\210\260\346\223\215\344\275\234\347\263\273\347\273\237\345\206\205\345\255\230\347\232\204\357\274\237.md" "b/docs/01.Java\347\233\270\345\205\263/30.JVM/040.JVM \345\206\205\345\255\230\346\230\257\345\246\202\344\275\225\345\257\271\345\272\224\345\210\260\346\223\215\344\275\234\347\263\273\347\273\237\345\206\205\345\255\230\347\232\204\357\274\237.md"
new file mode 100644
index 000000000..9bc6f0c2f
--- /dev/null
+++ "b/docs/01.Java\347\233\270\345\205\263/30.JVM/040.JVM \345\206\205\345\255\230\346\230\257\345\246\202\344\275\225\345\257\271\345\272\224\345\210\260\346\223\215\344\275\234\347\263\273\347\273\237\345\206\205\345\255\230\347\232\204\357\274\237.md"
@@ -0,0 +1,63 @@
+---
+title: JVM 内存是如何对应到操作系统内存的？
+date: 2022-05-21 17:33:05
+permalink: /pages/da65e7/
+categories:
+ - Java相关
+ - JVM
+tags:
+ -
+---
+## Java 内存模型
+
+同一套内存模型规范，不同语言在实现上可能会有些差别。接下来着重讲一下 Java 内存模型实现原理。
+
+Java 运行时内存区域与硬件内存的关系
+
+了解过 JVM 的同学都知道，JVM 运行时内存区域是分片的，分为栈、堆等，其实这些都是 JVM 定义的逻辑概念。在传统的硬件内存架构中是没有栈和堆这种概念。
+
+
+
+从图中可以看出栈和堆既存在于高速缓存中又存在于主内存中，所以两者并没有很直接的关系。
+
+## Java 线程与主内存的关系
+
+Java 内存模型是一种规范，定义了很多东西：
+
+所有的变量都存储在主内存（Main Memory）中。
+每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的拷贝副本。
+线程对变量的所有操作都必须在本地内存中进行，而不能直接读写主内存。
+不同的线程之间无法直接访问对方本地内存中的变量。
+看文字太枯燥了，我又画了一张图：
+
+## 线程间通信
+
+如果两个线程都对一个共享变量进行操作，共享变量初始值为 1，每个线程都变量进行加 1，预期共享变量的值为 3。在 JMM 规范下会有一系列的操作。
+
+
+
+为了更好的控制主内存和本地内存的交互，Java 内存模型定义了八种操作来实现：
+* lock：锁定。作用于主内存的变量，把一个变量标识为一条线程独占状态。
+* unlock：解锁。作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
+* read：读取。作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
+* load：载入。作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
+* use：使用。作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
+* assign：赋值。作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
+* store：存储。作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
+* write：写入。作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。
+注意：工作内存也就是本地内存的意思。
+
+## 有态度的总结
+
+由于CPU 和主内存间存在数量级的速率差，想到了引入了多级高速缓存的传统硬件内存架构来解决，多级高速缓存作为 CPU 和主内间的缓冲提升了整体性能。解决了速率差的问题，却又带来了缓存一致性问题。
+
+数据同时存在于高速缓存和主内存中，如果不加以规范势必造成灾难，因此在传统机器上又抽象出了内存模型。
+
+Java 语言在遵循内存模型的基础上推出了 JMM 规范，目的是解决由于多线程通过共享内存进行通信时，存在的本地内存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的问题。
+
+为了更精准控制工作内存和主内存间的交互，JMM 还定义了八种操作：lock, unlock, read, load,use,assign, store, write。
+
+好了，今天就给大家介绍到这里，简单总结下Java内存模型的定义：Java内存模型并不是一件容易的事情，这个模型必须定义得足够严谨，才能让Java的并发操作不会产生歧义；但是，也必须得足够宽松，使得虚拟机的实现能有足够的自由空间去利用硬件的各种特性（寄存器、高速缓存等）来获取更好的执行速度。经过长时间的验证和修补，在JDK1.5发布后，Java内存模型就已经成熟和完善起来了。
+
+参考：
+[全面学习掌握Java内存模型](https://baijiahao.baidu.com/s?id=1700599301374287320&wfr=spider&for=pc)
\ No newline at end of file
diff --git "a/docs/01.Java\347\233\270\345\205\263/30.JVM/050.JVM \346\230\257\346\200\216\344\271\210\345\216\273\350\260\203\344\274\230\347\232\204\357\274\237\344\272\206\350\247\243\345\223\252\344\272\233\345\217\202\346\225\260\345\222\214\346\214\207\344\273\244\357\274\237.md" "b/docs/01.Java\347\233\270\345\205\263/30.JVM/050.JVM \346\230\257\346\200\216\344\271\210\345\216\273\350\260\203\344\274\230\347\232\204\357\274\237\344\272\206\350\247\243\345\223\252\344\272\233\345\217\202\346\225\260\345\222\214\346\214\207\344\273\244\357\274\237.md"
new file mode 100644
index 000000000..e9144aa07
--- /dev/null
+++ "b/docs/01.Java\347\233\270\345\205\263/30.JVM/050.JVM \346\230\257\346\200\216\344\271\210\345\216\273\350\260\203\344\274\230\347\232\204\357\274\237\344\272\206\350\247\243\345\223\252\344\272\233\345\217\202\346\225\260\345\222\214\346\214\207\344\273\244\357\274\237.md"
@@ -0,0 +1,43 @@
+---
+title: JVM 是怎么去调优的？了解哪些参数和指令？
+date: 2022-05-21 17:33:16
+permalink: /pages/d730dd/
+categories:
+ - Java相关
+ - JVM
+tags:
+ -
+---
+
+## 查看进程
+由于JVM大多数命令都是需要用到进程id的，所以我们需要先查看一下我们系统的进程id，通过使用jps -l，输出所有java相关进程。
+
+
+这里我们可以根据类名，大致确认出我们的系统进程是什么
+
+注：-l代表的是输出应用程序main class的完整package名或者应用程序的jar文件完整路径名
+
+## 查看JVM参数 jinfo
+通过运行jinfo -flags <端口号>查看jvm的参数。
+
+通过运行jinfo -sysprops <端口号>查看java系统参数。
+
+## 查看各项指标数据 jstat
+通过运行 -class <端口号>完成类加载统计
+通过运行jstat -gc <端口号>完成垃圾回收统计
+通过运行jstat -gccapacity <端口号>完成堆内存统计
+通过运行jstat -gcnew <端口号>完成新生代垃圾回收统计
+通过运行jstat -gcnewcapacity <端口号>完成新生代内存统计
+通过运行jstat -gcold <端口号>完成老年代垃圾回收统计
+通过运行jstat -gcoldcapacity <端口号>完成老年代内存统计
+通过运行jstat -gcmetacapacity <端口号>完成老年代内存统计
+通过运行jstat -gcutil <端口号>数据总览
+查看对象及内存使用情况
+通过运行jmap -histo <端口号> > ./log.txt类及其对象所占内存数据。
+
+## jmap
+通过运行jmap -heap <端口号>堆信息。
+
+参考：
+[深度好文：JVM调优](https://baijiahao.baidu.com/s?id=1708710107377134976&wfr=spider&for=pc)
+[Java核心篇-故事里的JVM性能调优](https://zhuanlan.zhihu.com/p/445492854)
\ No newline at end of file
diff --git "a/docs/01.Java\347\233\270\345\205\263/30.JVM/060.\344\273\200\344\271\210\346\230\257\345\206\205\345\255\230\346\263\204\346\274\217\357\274\214\346\200\216\344\271\210\347\241\256\345\256\232\345\206\205\345\255\230\346\263\204\346\274\217\357\274\237.md" "b/docs/01.Java\347\233\270\345\205\263/30.JVM/060.\344\273\200\344\271\210\346\230\257\345\206\205\345\255\230\346\263\204\346\274\217\357\274\214\346\200\216\344\271\210\347\241\256\345\256\232\345\206\205\345\255\230\346\263\204\346\274\217\357\274\237.md"
new file mode 100644
index 000000000..bfab9f4c1
--- /dev/null
+++ "b/docs/01.Java\347\233\270\345\205\263/30.JVM/060.\344\273\200\344\271\210\346\230\257\345\206\205\345\255\230\346\263\204\346\274\217\357\274\214\346\200\216\344\271\210\347\241\256\345\256\232\345\206\205\345\255\230\346\263\204\346\274\217\357\274\237.md"
@@ -0,0 +1,179 @@
+---
+title: 什么是内存泄漏，怎么确定内存泄漏？
+date: 2022-05-21 17:33:27
+permalink: /pages/3ab5f5/
+categories:
+ - Java相关
+ - JVM
+tags:
+ -
+---
+
+## 前言
+
+这个问题是我之前翻看面经的时候见到的。那位小姐姐把内存泄漏当成了内存溢出问题去解答的，结果当场挂掉了。为此总结一下，之前和一位老哥也讨论过这个问题。可见不管是面试还是工作这都是一个极为重要的点。
+
+我也曾在面阿里的时候也遇到过原题，题目是写出俩内存泄漏案例，然后问如何排查？如何解决？
+
+本篇文章大体结构来自外国大佬baeldung；
+
+## 一、介绍
+
+### 1、什么是内存泄漏
+
+java的优势之一就是内置了垃圾回收器GC，它帮助我们实现了自动化内存管理。但是GC再好，也有老马失前蹄的时候，它不能保证提供一个解决内存泄漏的万无一失的解决方案。什么是内存泄漏？可以看看下面这张图，
+
+
+也就是一部分内存空间我明明已经使用了，却没有引用指向这部分空间。造成这片已经使用的空间无法处理的情况。
+
+正规点的理解：动态开辟的空间，在使用完毕后未释放，结果导致一直占据该内存单元。直到程序结束。
+
+### 2、内存泄漏的危害
+
+长时间运行，程序变卡，性能严重下降
+程序莫名其妙挂掉
+OutOfMemoryError错误
+乱七八糟的错误，还不易排查
+反正内存泄漏不是好事。
+
+## 二、内存泄漏原因
+
+内存泄漏原因太多了。说不定就是某一行代码不对就会出现这种情况，因此这里给出最常见的几种。关键的还是如何找出哪个地方出现了内存泄漏，代码好修改，错误不易查。
+
+### 1、大量使用静态变量
+
+静态变量的生命周期与程序一致。因此常驻内存。
+
+```java
+public class Static Test{
+ public static List*长按图片保存或转发
\n\n \n不知道大家有没有发现，我们身边经常有这样的人，他们越是有能力的，越是有知识的，越是低调，越是谦逊，因为他们深知，知道的越多，不知道的也就越多。
\n", - "headersStr": null, - "content": "不知道大家有没有发现，我们身边经常有这样的人，他们越是有能力的，越是有知识的，越是低调，越是谦逊，因为他们深知，知道的越多，不知道的也就越多。\n\n你知道的越多，你不知道的也就越多，这是一句非常有哲理的话。\n\n每个人的知识面都是有限的，你有可能在某个领域会有较深的研究，成为这个领域里的专家，等到你站在高处的时候，才会发现，自己是多么的渺小，才知道自己有多少没有涉及的领域。知道的越多，疑惑、问题就会越来越多，对已知的质疑、疑虑、困惑就会越来越多。\n\n即使如此，我们也应该努力，至少可以成为某个领域的佼佼者。\n\n鸡汤1\n\n弱小的人，才习惯嘲讽与否定，而内心强大的人，从不吝啬赞美与鼓励。\n\n鸡汤2\n\n当代青年人都应该摆脱冷气，只管向上走，不必听从自暴自弃者的流言。能做事的做事，能发声的发声。有一份热，发一份光，就像萤火一般，也可以在黑暗里发一点光，不必等候炬火。", - "normalizedContent": "不知道大家有没有发现，我们身边经常有这样的人，他们越是有能力的，越是有知识的，越是低调，越是谦逊，因为他们深知，知道的越多，不知道的也就越多。\n\n你知道的越多，你不知道的也就越多，这是一句非常有哲理的话。\n\n每个人的知识面都是有限的，你有可能在某个领域会有较深的研究，成为这个领域里的专家，等到你站在高处的时候，才会发现，自己是多么的渺小，才知道自己有多少没有涉及的领域。知道的越多，疑惑、问题就会越来越多，对已知的质疑、疑虑、困惑就会越来越多。\n\n即使如此，我们也应该努力，至少可以成为某个领域的佼佼者。\n\n鸡汤1\n\n弱小的人，才习惯嘲讽与否定，而内心强大的人，从不吝啬赞美与鼓励。\n\n鸡汤2\n\n当代青年人都应该摆脱冷气，只管向上走，不必听从自暴自弃者的流言。能做事的做事，能发声的发声。有一份热，发一份光，就像萤火一般，也可以在黑暗里发一点光，不必等候炬火。", - "charsets": { - "cjk": true - }, - "lastUpdated": "2022/05/19, 21:26:01", - "lastUpdatedTimestamp": 1652966761000 - }, - { - "title": "我做了一个手写春联小网页，祝大家虎年暴富", - "frontmatter": { - "title": "我做了一个手写春联小网页，祝大家虎年暴富", - "date": "2022-01-28T14:59:51.000Z", - "permalink": "/pages/829589/", - "titleTag": "原创", - "sidebar": "auto", - "categories": [ - "随笔" - ], - "tags": [ - null - ] - }, - "regularPath": "/_posts/%E9%9A%8F%E7%AC%94/%E6%88%91%E5%81%9A%E4%BA%86%E4%B8%80%E4%B8%AA%E6%89%8B%E5%86%99%E6%98%A5%E8%81%94%E5%B0%8F%E7%BD%91%E9%A1%B5%EF%BC%8C%E7%A5%9D%E5%A4%A7%E5%AE%B6%E8%99%8E%E5%B9%B4%E6%9A%B4%E5%AF%8C.html", - "relativePath": "_posts/随笔/我做了一个手写春联小网页，祝大家虎年暴富.md", - "key": "v-d16706f0", - "path": "/pages/829589/", - "headers": [ - { - "level": 3, - "title": "前言", - "slug": "前言", - "normalizedTitle": "前言", - "charIndex": 33 - }, - { - "level": 3, - "title": "产品构思", - "slug": "产品构思", - "normalizedTitle": "产品构思", - "charIndex": 195 - }, - { - "level": 3, - "title": "设计", - "slug": "设计", - "normalizedTitle": "设计", - "charIndex": 478 - }, - { - "level": 3, - "title": "开发", - "slug": "开发", - "normalizedTitle": "开发", - "charIndex": 487 - } - ], - "excerpt": "\n虎年春节快到了，首先祝大家新年快乐，轻松暴富。\n最近在网上经常看到生成春联的文章，不过这些小demo要么功能简陋,要么UI特别‘程序员’，满足不了我挑剔的眼光。干脆我自己做一个吧，顺便简单体验一下vite+vue3。（因为页面相对简单，vue组件风格还是使用选项式api，重点还是想把产品快速做出来。）
\n", - "headersStr": "前言 产品构思 设计 开发", - "content": "手写春联：https://cl.xugaoyi.com/\n\n\n# 前言\n\n虎年春节快到了，首先祝大家新年快乐，轻松暴富。 最近在网上经常看到生成春联的文章，不过这些小demo要么功能简陋,要么UI特别‘程序员’，满足不了我挑剔的眼光。干脆我自己做一个吧，顺便简单体验一下vite+vue3。（因为页面相对简单，vue组件风格还是使用选项式api，重点还是想把产品快速做出来。）\n\n\n\n\n# 产品构思\n\n包含手写春节和生成春联两大功能：\n\n * 手写春联\n \n * 模拟用笔写字的字迹\n * 选择画笔颜色\n * 调整画笔大小\n * 清空画布\n * 撤回笔画\n * 切换上、下联、横批、福字\n * 随机切换对联提示\n * 预览图片和下载\n * 贴春联海报和下载\n\n * 生成模式\n \n * 选择画笔颜色\n * 挑选生成的对联\n * 输入对联\n * 随机切换对联\n * 贴春联海报和下载\n\n * 其他\n \n * 快速切换模式按钮\n * 可控制的背景音乐\n * 微信分享网页\n\n\n# 设计\n\n\n\n\n# 开发\n\n * 技术栈\n * vite (打包&构建)\n * vue3 (页面开发)\n * vant（ui）\n * sass (css)\n * smooth-signature.js (带笔锋手写库)\n\n\n*长按图片保存或转发
\n\n \n*长按图片保存或转发
\n\n \n生活在后现代的今天，很多人都有一种虚无感，认为人生没有意义。但是，人生不可能没有意义，因为当你认为没有意义的时候，一定有一个与之相对应的概念叫有意义。
\n", "headersStr": null, @@ -4034,17 +9725,17 @@ export const siteData = { "lastUpdatedTimestamp": 1652966761000 }, { - "title": "标签", + "title": "归档", "frontmatter": { - "tagsPage": true, - "title": "标签", - "permalink": "/tags/", + "archivesPage": true, + "title": "归档", + "permalink": "/archives/", "article": false }, - "regularPath": "/@pages/tagsPage.html", - "relativePath": "@pages/tagsPage.md", - "key": "v-10b59438", - "path": "/tags/", + "regularPath": "/@pages/archivesPage.html", + "relativePath": "@pages/archivesPage.md", + "key": "v-48f7eec0", + "path": "/archives/", "headersStr": null, "content": "", "normalizedContent": "", @@ -4053,17 +9744,17 @@ export const siteData = { "lastUpdatedTimestamp": 1652966761000 }, { - "title": "归档", + "title": "标签", "frontmatter": { - "archivesPage": true, - "title": "归档", - "permalink": "/archives/", + "tagsPage": true, + "title": "标签", + "permalink": "/tags/", "article": false }, - "regularPath": "/@pages/archivesPage.html", - "relativePath": "@pages/archivesPage.md", - "key": "v-3d588164", - "path": "/archives/", + "regularPath": "/@pages/tagsPage.html", + "relativePath": "@pages/tagsPage.md", + "key": "v-64f9b920", + "path": "/tags/", "headersStr": null, "content": "", "normalizedContent": "", @@ -4075,11 +9766,11 @@ export const siteData = { "title": "Home", "frontmatter": { "home": true, - "heroImage": "https://hbimg.huabanimg.com/fb25635e5908e98d4c0515824828c448efb1966e51d3-54Zry1_fw658/format/webp", + "heroImage": "/img/JAVADRIVER.png", "heroText": "JavaDriver", "tagline": "🚀精选大厂Java面试题", "actionText": "开始使用 →", - "actionLink": "/pages/a2f161/", + "actionLink": "/pages/a030ff/", "bannerBg": "none", "features": [ { @@ -4099,7 +9790,7 @@ export const siteData = { }, "regularPath": "/", "relativePath": "index.md", - "key": "v-92fa7286", + "key": "v-2cf94a0e", "path": "/", "headers": [ { @@ -4107,57 +9798,38 @@ export const siteData = { "title": "🎖友情链接", "slug": "🎖友情链接", "normalizedTitle": "🎖友情链接", - "charIndex": 14 + "charIndex": 11 }, { "level": 2, "title": "🎉上新推荐", "slug": "🎉上新推荐", "normalizedTitle": "🎉上新推荐", - "charIndex": 699 + "charIndex": 723 }, { "level": 2, "title": "⚡️未来...", "slug": "⚡️未来", "normalizedTitle": "⚡️未来...", - "charIndex": 751 + "charIndex": 775 }, { "level": 2, "title": "⚡ 反馈与交流", "slug": "⚡-反馈与交流", "normalizedTitle": "⚡ 反馈与交流", - "charIndex": 815 + "charIndex": 839 } ], "headersStr": "🎖友情链接 🎉上新推荐 ⚡️未来... ⚡ 反馈与交流", - "content": "支持这个项目\n\n\n\n\n\n# 🎖友情链接\n\nOpenHarmony\n\n开放原子开源基金会\n\nMyBatis-Plus官网\n\n🚀为简化开发而生\n\nDeepin 社区\n\nDeepin 应用开发技术分享、DTK开发经验等\n\nVForm官网\n\n低代码表单优选方案，拖拽式设计，一键生成源码\n\n- name: OpenHarmony\n desc: 开放原子开源基金会\n link: https://docs.openharmony.cn/pages/000000/\n bgColor: '#f1f1f1'\n textColor: '#2A3344'\n- name: MyBatis-Plus官网\n desc: 🚀为简化开发而生\n link: https://baomidou.com/\n bgColor: '#f1f1f1'\n textColor: '#2A3344'\n- name: Deepin 社区\n desc: Deepin 应用开发技术分享、DTK开发经验等\n link: https://docs.deepin.org\n bgColor: '#f1f1f1'\n textColor: '#2A3344'\n- name: VForm官网\n desc: 低代码表单优选方案，拖拽式设计，一键生成源码\n link: http://www.vform666.com\n bgColor: '#f1f1f1'\n textColor: '#2A3344'\n\n\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n\n\n\n\n# 🎉上新推荐\n\n * v1.1.x：第一个版本，快去 看看 吧~\n\n更多上新请查阅：更新日志\n\n\n\n# ⚡️未来...\n\n提示\n\n期待 更多Java领域的面试题正式发布...\n\n还希望大家多多 💖支持 哟，持续关注吧~\n\n\n\n# ⚡ 反馈与交流\n\n在使用过程中有任何问题和想法，请给我提 Issue。 你也可以在Issue查看别人提的问题和给出解决方案。\n\n", - "normalizedContent": "支持这个项目\n\n\n\n\n\n# 🎖友情链接\n\nopenharmony\n\n开放原子开源基金会\n\nmybatis-plus官网\n\n🚀为简化开发而生\n\ndeepin 社区\n\ndeepin 应用开发技术分享、dtk开发经验等\n\nvform官网\n\n低代码表单优选方案，拖拽式设计，一键生成源码\n\n- name: openharmony\n desc: 开放原子开源基金会\n link: https://docs.openharmony.cn/pages/000000/\n bgcolor: '#f1f1f1'\n textcolor: '#2a3344'\n- name: mybatis-plus官网\n desc: 🚀为简化开发而生\n link: https://baomidou.com/\n bgcolor: '#f1f1f1'\n textcolor: '#2a3344'\n- name: deepin 社区\n desc: deepin 应用开发技术分享、dtk开发经验等\n link: https://docs.deepin.org\n bgcolor: '#f1f1f1'\n textcolor: '#2a3344'\n- name: vform官网\n desc: 低代码表单优选方案，拖拽式设计，一键生成源码\n link: http://www.vform666.com\n bgcolor: '#f1f1f1'\n textcolor: '#2a3344'\n\n\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n\n\n\n\n# 🎉上新推荐\n\n * v1.1.x：第一个版本，快去 看看 吧~\n\n更多上新请查阅：更新日志\n\n\n\n# ⚡️未来...\n\n提示\n\n期待 更多java领域的面试题正式发布...\n\n还希望大家多多 💖支持 哟，持续关注吧~\n\n\n\n# ⚡ 反馈与交流\n\n在使用过程中有任何问题和想法，请给我提 issue。 你也可以在issue查看别人提的问题和给出解决方案。\n\n", + "content": "支持这个项目\n\n\n# 🎖友情链接\n\nOpenHarmony\n\n开放原子开源基金会\n\nMyBatis-Plus官网\n\n🚀为简化开发而生\n\nvuepress-theme-vdoing\n\n优秀的vuepress主题\n\nVForm官网\n\n低代码表单优选方案，拖拽式设计，一键生成源码\n\n- name: OpenHarmony\n desc: 开放原子开源基金会\n link: https://docs.openharmony.cn/pages/000000/\n bgColor: '#f1f1f1'\n textColor: '#2A3344'\n- name: MyBatis-Plus官网\n desc: 🚀为简化开发而生\n link: https://baomidou.com/\n bgColor: '#f1f1f1'\n textColor: '#2A3344'\n- name: vuepress-theme-vdoing\n desc: 优秀的vuepress主题\n link: https://github.com/xugaoyi/vuepress-theme-vdoing\n bgColor: '#f1f1f1'\n textColor: '#2A3344'\n- name: VForm官网\n desc: 低代码表单优选方案，拖拽式设计，一键生成源码\n link: http://www.vform666.com\n bgColor: '#f1f1f1'\n textColor: '#2A3344'\n\n\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n\n\n\n\n# 🎉上新推荐\n\n * v1.1.x：第一个版本，快去 看看 吧~\n\n更多上新请查阅：更新日志\n\n\n\n# ⚡️未来...\n\n提示\n\n期待 更多Java领域的面试题正式发布...\n\n还希望大家多多 💖支持 哟，持续关注吧~\n\n\n\n# ⚡ 反馈与交流\n\n在使用过程中有任何问题和想法，你可以：\n\n * 给我提 Issue。\n\n你也可以在Issue查看别人提的问题和给出解决方案。\n\n * 戳JavaDriver社区\n\n", + "normalizedContent": "支持这个项目\n\n\n# 🎖友情链接\n\nopenharmony\n\n开放原子开源基金会\n\nmybatis-plus官网\n\n🚀为简化开发而生\n\nvuepress-theme-vdoing\n\n优秀的vuepress主题\n\nvform官网\n\n低代码表单优选方案，拖拽式设计，一键生成源码\n\n- name: openharmony\n desc: 开放原子开源基金会\n link: https://docs.openharmony.cn/pages/000000/\n bgcolor: '#f1f1f1'\n textcolor: '#2a3344'\n- name: mybatis-plus官网\n desc: 🚀为简化开发而生\n link: https://baomidou.com/\n bgcolor: '#f1f1f1'\n textcolor: '#2a3344'\n- name: vuepress-theme-vdoing\n desc: 优秀的vuepress主题\n link: https://github.com/xugaoyi/vuepress-theme-vdoing\n bgcolor: '#f1f1f1'\n textcolor: '#2a3344'\n- name: vform官网\n desc: 低代码表单优选方案，拖拽式设计，一键生成源码\n link: http://www.vform666.com\n bgcolor: '#f1f1f1'\n textcolor: '#2a3344'\n\n\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n\n\n\n\n# 🎉上新推荐\n\n * v1.1.x：第一个版本，快去 看看 吧~\n\n更多上新请查阅：更新日志\n\n\n\n# ⚡️未来...\n\n提示\n\n期待 更多java领域的面试题正式发布...\n\n还希望大家多多 💖支持 哟，持续关注吧~\n\n\n\n# ⚡ 反馈与交流\n\n在使用过程中有任何问题和想法，你可以：\n\n * 给我提 issue。\n\n你也可以在issue查看别人提的问题和给出解决方案。\n\n * 戳javadriver社区\n\n", "charsets": { "cjk": true }, - "lastUpdated": "2022/05/19, 21:26:01", - "lastUpdatedTimestamp": 1652966761000 - }, - { - "title": "分类", - "frontmatter": { - "categoriesPage": true, - "title": "分类", - "permalink": "/categories/", - "article": false - }, - "regularPath": "/@pages/categoriesPage.html", - "relativePath": "@pages/categoriesPage.md", - "key": "v-5d307544", - "path": "/categories/", - "headersStr": null, - "content": "", - "normalizedContent": "", - "charsets": {}, - "lastUpdated": "2022/05/19, 21:26:01", - "lastUpdatedTimestamp": 1652966761000 + "lastUpdated": "2022/06/20, 22:47:41", + "lastUpdatedTimestamp": 1655736461000 } ], "themeConfig": { @@ -4180,11 +9852,11 @@ export const siteData = { }, { "text": "JVM", - "link": "/pages/5f2105/" + "link": "/pages/948850/" }, { "text": "设计模式", - "link": "/pages/6a18d3/" + "link": "/pages/b37ad7/" } ] }, @@ -4216,37 +9888,25 @@ export const siteData = { "items": [ { "text": "MYSQL", - "link": "/pages/39e05b/" + "link": "/pages/3a8659/" }, { "text": "REDIS", - "link": "/pages/894769/" + "link": "/pages/d70c1f/" } ] }, { "text": "中间件", "link": "/middleware/", - "items": [ - { - "text": "Netty", - "link": "/pages/40f3c9/" - }, - { - "text": "Spring", - "link": "/pages/434235/" - }, + "items": [ { - "text": "Mybatis", - "link": "/pages/3793a5/" + "text": "Netty", + "link": "/pages/40f3c9/" }, { "text": "Kafka", "link": "/pages/561f34/" - }, - { - "text": "Dubbo", - "link": "/pages/78517c/" } ] }, @@ -4262,10 +9922,6 @@ export const siteData = { "text": "关于", "link": "/about/" }, - { - "text": "收藏", - "link": "/pages/beb6c0bd8a66cea6/" - }, { "text": "索引", "link": "/archives/", @@ -4286,7 +9942,7 @@ export const siteData = { } ], "sidebarDepth": 2, - "logo": "/img/logo.png", + "logo": "/img/JAVADRIVER.png", "repo": "https://github.com/AdmireAn/JavaDriver", "searchMaxSuggestions": 10, "lastUpdated": "上次更新", @@ -4515,9 +10171,44 @@ export const siteData = { "collapsable": true, "children": [ [ - "30.JVM/001.JVM.md", - "JVM", - "/pages/5f2105/" + "30.JVM/001.Java 中垃圾回收机制中如何判断对象需要回收？.md", + "Java 中垃圾回收机制中如何判断对象需要回收？", + "/pages/948850/" + ], + [ + "30.JVM/010.常见的 GC 回收算法有哪些？.md", + "常见的 GC 回收算法有哪些？", + "/pages/9b26e8/" + ], + [ + "30.JVM/020.Java 中如何进行 GC 调优？.md", + "Java 中如何进行 GC 调优？", + "/pages/07a030/" + ], + [ + "30.JVM/030.JMM 中内存模型是怎样的？什么是指令序列重排序？.md", + "JMM 中内存模型是怎样的？什么是指令序列重排序？", + "/pages/c8e6cb/" + ], + [ + "30.JVM/040.JVM 内存是如何对应到操作系统内存的？.md", + "JVM 内存是如何对应到操作系统内存的？", + "/pages/da65e7/" + ], + [ + "30.JVM/050.JVM 是怎么去调优的？了解哪些参数和指令？.md", + "JVM 是怎么去调优的？了解哪些参数和指令？", + "/pages/d730dd/" + ], + [ + "30.JVM/060.什么是内存泄漏，怎么确定内存泄漏？.md", + "什么是内存泄漏，怎么确定内存泄漏？", + "/pages/3ab5f5/" + ], + [ + "30.JVM/070.简述 CMS 与 G1 机制的区别.md", + "简述 CMS 与 G1 机制的区别", + "/pages/be69af/" ] ] }, @@ -4526,53 +10217,358 @@ export const siteData = { "collapsable": true, "children": [ [ - "40.设计模式/001.设计模式.md", - "设计模式", - "/pages/6a18d3/" + "40.设计模式/002.实现单例设计模式（懒汉，饿汉）.md", + "实现单例设计模式（懒汉，饿汉）", + "/pages/b37ad7/" + ], + [ + "40.设计模式/003.什么是设计模式 .md", + "什么是设计模式", + "/pages/3d768c/" + ], + [ + "40.设计模式/004.工厂模式使用场景 能举个例子吗.md", + "工厂模式使用场景 能举个例子吗", + "/pages/f15489/" + ], + [ + "40.设计模式/005.装饰者模式.md", + "简述装饰者模式", + "/pages/47a4e3/" + ], + [ + "40.设计模式/010.适配器模式.md", + "适配器模式", + "/pages/827fc4/" + ], + [ + "40.设计模式/020.代理模式.md", + "代理模式", + "/pages/dd3a6f/" + ], + [ + "40.设计模式/030.责任链模式.md", + "责任链模式", + "/pages/d3ff35/" + ], + [ + "40.设计模式/040.模板方法模式.md", + "模板方法模式", + "/pages/43b656/" + ], + [ + "40.设计模式/050.策略模式.md", + "策略模式", + "/pages/78c7aa/" + ], + [ + "40.设计模式/060.观察模式.md", + "观察模式", + "/pages/cbff3c/" ] ] } ], "/02.计算机基础/": [ { - "title": "计算机网络.HTML", + "title": "计算机网络", "collapsable": true, "children": [ [ - "10.计算机网络.HTML/01.计算机网络.md", - "计算机网络", + "10.计算机网络/01.简述 TCP 三次握手以及四次挥手.md", + "简述 TCP 三次握手以及四次挥手的流程。为什么需要三次握手以及四次挥手？", "/pages/e00207/" + ], + [ + "10.计算机网络/010.简述常见的 HTTP 状态码的含义.md", + "简述常见的 HTTP 状态码的含义", + "/pages/f33310/" + ], + [ + "10.计算机网络/020.从输入 URL 到展现页面的全过程.md", + "从输入 URL 到展现页面的全过程", + "/pages/ab48ba/" + ], + [ + "10.计算机网络/030.HTTP 中 GET 和 POST 区别.md", + "HTTP 中 GET 和 POST 区别", + "/pages/a0e400/" + ], + [ + "10.计算机网络/040.TCP 怎么保证可靠传输.md", + "TCP 怎么保证可靠传输", + "/pages/5fcc49/" + ], + [ + "10.计算机网络/050.什么是 TCP 粘包和拆包？.md", + "什么是 TCP 粘包和拆包？", + "/pages/2822ac/" + ], + [ + "10.计算机网络/060.简述 HTTPS 的加密与认证过程.md", + "简述 HTTPS 的加密与认证过程", + "/pages/12c0cc/" + ], + [ + "10.计算机网络/070.简述对称与非对称加密的概念.md", + "简述对称与非对称加密的概念", + "/pages/057092/" + ], + [ + "10.计算机网络/080.TCP 与 UDP 在网络协议中的哪一层，他们之间有什么区别？.md", + "TCP 与 UDP 在网络协议中的哪一层，他们之间有什么区别？", + "/pages/cc4b24/" + ], + [ + "10.计算机网络/090.如何解决 TCP 传输丢包问题？.md", + "如何解决 TCP 传输丢包问题？", + "/pages/a656a9/" + ], + [ + "10.计算机网络/100.TCP 长连接和短连接有那么不同的使用场景？.md", + "TCP 长连接和短连接有那么不同的使用场景？", + "/pages/dda19e/" + ], + [ + "10.计算机网络/110.TCP 的 keepalive 了解吗？说一说它和 HTTP 的 keepalive 的区别？.md", + "TCP 的 keepalive 了解吗？说一说它和 HTTP 的 keepalive 的区别？", + "/pages/212438/" + ], + [ + "10.计算机网络/120.HTTP 与 HTTPS 有哪些区别？.md", + "HTTP 与 HTTPS 有哪些区别？", + "/pages/253334/" + ], + [ + "10.计算机网络/130.TCP 中常见的拥塞控制算法有哪些？.md", + "TCP 中常见的拥塞控制算法有哪些？", + "/pages/9ccc31/" + ], + [ + "10.计算机网络/140.简述 HTTP 1.0，1.1，2.0 的主要区别 .md", + "简述 HTTP 1.0，1.1，2.0 的主要区别", + "/pages/f50b70/" + ], + [ + "10.计算机网络/150.从系统层面上，UDP如何保证尽量可靠？.md", + "从系统层面上，UDP如何保证尽量可靠？", + "/pages/e57cfe/" + ], + [ + "10.计算机网络/160.TCP 挥手时出现大量 CLOSE_WAIT 或 TIME_WAIT 怎么解决？.md", + "TCP 挥手时出现大量 CLOSE_WAIT 或 TIME_WAIT 怎么解决？", + "/pages/15d37a/" + ], + [ + "10.计算机网络/170.简述 TCP 滑动窗口.md", + "简述 TCP 滑动窗口", + "/pages/dae451/" + ], + [ + "10.计算机网络/171. 简述TCP重传机制.md", + "简述TCP重传机制", + "/pages/a219df/" + ], + [ + "10.计算机网络/180.简述 JWT 的原理和校验机制.md", + "简述 JWT 的原理和校验机制", + "/pages/34d064/" + ], + [ + "10.计算机网络/190.为什么需要序列化？有什么序列化的方式？.md", + "为什么需要序列化？有什么序列化的方式？", + "/pages/68d6c8/" + ], + [ + "10.计算机网络/200.简述 iPv4 和 iPv6 的区别.md", + "简述 iPv4 和 iPv6 的区别", + "/pages/6a2e50/" + ], + [ + "10.计算机网络/210.TCP 中 SYN 攻击是什么？如何防止？.md", + "TCP 中 SYN 攻击是什么？如何防止？", + "/pages/d0c6d3/" + ], + [ + "10.计算机网络/220.简述 DDOS 攻击原理，如何防范它？.md", + "简述 DDOS 攻击原理，如何防范它？", + "/pages/056828/" + ], + [ + "10.计算机网络/230.什么是 ARP 协议？简述其使用场景.md", + "什么是 ARP 协议？简述其使用场景", + "/pages/665162/" + ], + [ + "10.计算机网络/240.什么是跨域，什么情况下会发生跨域请求？.md", + "什么是跨域，什么情况下会发生跨域请求？", + "/pages/eadd05/" + ], + [ + "10.计算机网络/250.Cookie 和 Session 的关系和区别是什么？.md", + "Cookie 和 Session 的关系和区别是什么？", + "/pages/980cc7/" + ], + [ + "10.计算机网络/260.简述 WebSocket 是如何进行传输的.md", + "简述 WebSocket 是如何进行传输的", + "/pages/172129/" + ], + [ + "10.计算机网络/270.DNS 查询服务器的基本流程是什么？DNS 劫持是什么？.md", + "DNS 查询服务器的基本流程是什么？DNS 劫持是什么？", + "/pages/017113/" + ], + [ + "10.计算机网络/280.RestFul 是什么？RestFul 请求的 URL 有什么特点？.md", + "RestFul 是什么？RestFul 请求的 URL 有什么特点？", + "/pages/c08bb6/" + ], + [ + "10.计算机网络/290.简述 HTTP 报文头部的组成结构.md", + "简述 HTTP 报文头部的组成结构", + "/pages/dfb780/" ] ] }, { - "title": "操作系统.CSS", + "title": "操作系统", "collapsable": true, "children": [ [ - "20.操作系统.CSS/01.操作系统.md", - "操作系统", + "20.操作系统/01.进程间有哪些通信方式？.md", + "进程间有哪些通信方式？", "/pages/e5f2d7/" + ], + [ + "20.操作系统/010.简述自旋锁与互斥锁的使用场景.md", + "简述自旋锁与互斥锁的使用场景", + "/pages/9e6232/" + ], + [ + "20.操作系统/020.进程和线程之间有什么区别？.md", + "进程和线程之间有什么区别？", + "/pages/c2fd8a/" + ], + [ + "20.操作系统/030.简述几个常用的 Linux 命令以及他们的功能.md", + "简述几个常用的 Linux 命令以及他们的功能", + "/pages/198887/" + ], + [ + "20.操作系统/040.创建线程有多少种方式？.md", + "创建线程有多少种方式？", + "/pages/888737/" + ], + [ + "20.操作系统/050.线程有多少种状态，状态之间如何转换.md", + "线程有多少种状态，状态之间如何转换", + "/pages/7de80d/" + ], + [ + "20.操作系统/060.进程有多少种状态？.md", + "进程有多少种状态？", + "/pages/165ea8/" + ], + [ + "20.操作系统/070.简述 select, poll, epoll 的使用场景以及区别.md", + "简述 select, poll, epoll 的使用场景以及区别", + "/pages/68ea00/" + ], + [ + "20.操作系统/080.Linux 下如何排查 CPU 以及 内存占用过多？.md", + "Linux 下如何排查 CPU 以及 内存占用过多？", + "/pages/b043a6/" + ], + [ + "20.操作系统/090.进程通信中的管道实现原理是什么？.md", + "进程通信中的管道实现原理是什么？", + "/pages/8e880a/" + ], + [ + "20.操作系统/100.Linux 下如何查看 CPU 荷载，正在运行的进程，某个端口对应的进程？.md", + "Linux 下如何查看 CPU 荷载，正在运行的进程，某个端口对应的进程？", + "/pages/326cf9/" + ], + [ + "20.操作系统/110.如何调试服务器内存占用过高的问题？.md", + "如何调试服务器内存占用过高的问题？", + "/pages/3653a2/" + ], + [ + "20.操作系统/120.Linux 如何查看实时的滚动日志？.md", + "Linux 如何查看实时的滚动日志？", + "/pages/f6e4d2/" + ], + [ + "20.操作系统/130.简述 Linux 零拷贝的原理.md", + "简述 Linux 零拷贝的原理", + "/pages/b43547/" + ], + [ + "20.操作系统/140.为什么进程切换慢，线程切换快？.md", + "为什么进程切换慢，线程切换快？", + "/pages/773d64/" + ], + [ + "20.操作系统/150.简述创建进程的流程.md", + "简述创建进程的流程", + "/pages/c64d20/" + ], + [ + "20.操作系统/160.简述 Linux 虚拟内存的页面置换算法.md", + "简述 Linux 虚拟内存的页面置换算法", + "/pages/93b870/" + ], + [ + "20.操作系统/170.简述 Linux 进程调度的算法.md", + "简述 Linux 进程调度的算法", + "/pages/36fd29/" + ], + [ + "20.操作系统/180.什么时候会由用户态陷入内核态？.md", + "什么时候会由用户态陷入内核态？", + "/pages/b84950/" + ], + [ + "20.操作系统/190.Linux 下如何查看端口被哪个进程占用？.md", + "Linux 下如何查看端口被哪个进程占用？", + "/pages/4c2d8e/" + ], + [ + "20.操作系统/200.Linux 中虚拟内存和物理内存有什么区别？有什么优点？.md", + "Linux 中虚拟内存和物理内存有什么区别？有什么优点？", + "/pages/3bab8c/" + ], + [ + "20.操作系统/210.简述 traceroute 命令的原理.md", + "简述 traceroute 命令的原理", + "/pages/655f8f/" + ], + [ + "20.操作系统/220.简述IO模型.md", + "Untitled", + "/pages/782c23/" ] ] }, { - "title": "数据结构.CSS", + "title": "数据结构", "collapsable": true, "children": [ [ - "30.数据结构.CSS/01.数据结构.md", + "30.数据结构/01.数据结构.md", "数据结构", "/pages/a25c3a/" ] ] }, { - "title": "算法.CSS", + "title": "算法", "collapsable": true, "children": [ [ - "40.算法.CSS/01.算法.md", + "40.算法/01.算法.md", "算法", "/pages/92288a/" ] @@ -4585,9 +10581,114 @@ export const siteData = { "collapsable": true, "children": [ [ - "01.MYSQL相关/01.MYSQL.md", - "MYSQL", - "/pages/39e05b/" + "01.MYSQL相关/001.MySQL中 InnoDB 和 MylSAM 的区别是什么？.md", + "MySQL中 InnoDB 和 MylSAM 的区别是什么？", + "/pages/3a8659/" + ], + [ + "01.MYSQL相关/006.聚簇索引和非聚簇索引有什么区别？.md", + "聚簇索引和非聚簇索引有什么区别？", + "/pages/a5adb0/" + ], + [ + "01.MYSQL相关/007.简述 MySQL 常见索引类型，介绍一下覆盖索引.md", + "简述 MySQL 常见索引类型，介绍一下覆盖索引", + "/pages/17b014/" + ], + [ + "01.MYSQL相关/010.简述Mysql的事务隔离级别.md", + "简述Mysql的事务隔离级别", + "/pages/9f2936/" + ], + [ + "01.MYSQL相关/015.说一下Mysql锁.md", + "说一下Mysql锁", + "/pages/b17e88/" + ], + [ + "01.MYSQL相关/020.MySQL 为什么使用 B+ 树来作索引，对比 B 树它的优点和缺点是什么.md", + "MySQL 为什么使用 B+ 树来作索引，对比 B 树它的优点和缺点是什么", + "/pages/bc5538/" + ], + [ + "01.MYSQL相关/030.简述乐观锁以及悲观锁的区别以及使用场景.md", + "简述乐观锁以及悲观锁的区别以及使用场景", + "/pages/57561d/" + ], + [ + "01.MYSQL相关/040.简述脏读和幻读的发生场景，InnoDB 是如何解决幻读的？.md", + "简述脏读和幻读的发生场景，InnoDB 是如何解决幻读的？", + "/pages/36672c/" + ], + [ + "01.MYSQL相关/050.简述什么是最左匹配原则.md", + "简述什么是最左匹配原则", + "/pages/7a1f1e/" + ], + [ + "01.MYSQL相关/060.MySQL 联合索引底层原理是什么？.md", + "MySQL 联合索引底层原理是什么？", + "/pages/52773a/" + ], + [ + "01.MYSQL相关/070.产生死锁的必要条件有哪些？如何解决死锁？.md", + "产生死锁的必要条件有哪些？如何解决死锁？", + "/pages/f4cf50/" + ], + [ + "01.MYSQL相关/080.简述常见的负载均衡算法.md", + "简述常见的负载均衡算法", + "/pages/f2dbbe/" + ], + [ + "01.MYSQL相关/090.简述 MySQL 的主从同步机制，如果同步失败会怎么样？.md", + "简述 MySQL 的主从同步机制，如果同步失败会怎么样？", + "/pages/1ac30e/" + ], + [ + "01.MYSQL相关/100.如何设计数据库压测方案？.md", + "如何设计数据库压测方案？", + "/pages/a8eb47/" + ], + [ + "01.MYSQL相关/110.简述数据库中什么情况下进行分库，什么情况下进行分表？.md", + "简述数据库中什么情况下进行分库，什么情况下进行分表？", + "/pages/ac0bb8/" + ], + [ + "01.MYSQL相关/120.数据库的读写分离的作用是什么？如何实现？.md", + "数据库的读写分离的作用是什么？如何实现？", + "/pages/f62359/" + ], + [ + "01.MYSQL相关/130.简述 undo log 和 redo log 的作用.md", + "简述 undo log 和 redo log 的作用", + "/pages/7bbbf6/" + ], + [ + "01.MYSQL相关/140.什么是 SQL 注入攻击？如何防止这类攻击？.md", + "什么是 SQL 注入攻击？如何防止这类攻击？", + "/pages/b4338e/" + ], + [ + "01.MYSQL相关/150.MySQL 中 join 与 left join 的区别是什么？.md", + "MySQL 中 join 与 left join 的区别是什么？", + "/pages/429100/" + ], + [ + "01.MYSQL相关/160.简述 MySQL MVCC 的实现原理 .md", + "简述 MySQL MVCC 的实现原理", + "/pages/1656d8/" + ], + [ + "01.MYSQL相关/170.MySQL 中 varchar 和 char 的区别是什么？.md", + "MySQL 中 varchar 和 char 的区别是什么？", + "/pages/d97948/" + ], + [ + "01.MYSQL相关/180.模糊查询是如何实现的？.md", + "模糊查询是如何实现的？", + "/pages/32696d/" ] ] }, @@ -4596,9 +10697,74 @@ export const siteData = { "collapsable": true, "children": [ [ - "02.REDIS相关/01.REDIS.md", - "REDIS", - "/pages/894769/" + "02.REDIS相关/001.Redis 有几种数据结构？Zset 是如何实现的？.md", + "Redis 有几种数据结构？Zset 是如何实现的？", + "/pages/d70c1f/" + ], + [ + "02.REDIS相关/002.为什么 Redis 在单线程下能如此快？.md", + "为什么 Redis 在单线程下能如此快？", + "/pages/d66211/" + ], + [ + "02.REDIS相关/005.简述 Redis 字符串的底层结构.md", + "简述 Redis 字符串的底层结构", + "/pages/34aec2/" + ], + [ + "02.REDIS相关/010.Redis的缓存淘汰策略有哪些？.md", + "Redis的缓存淘汰策略有哪些？", + "/pages/9326cc/" + ], + [ + "02.REDIS相关/020.简述 Redis 持久化中 RDB 以及 AOF 方案的优缺点.md", + "简述 Redis 持久化中 RDB 以及 AOF 方案的优缺点", + "/pages/7e708d/" + ], + [ + "02.REDIS相关/030.Redis 如何实现分布式锁？.md", + "Redis 如何实现分布式锁？", + "/pages/656f46/" + ], + [ + "02.REDIS相关/040.简述 Redis 集群配置以及基础原理.md", + "简述 Redis 集群配置以及基础原理", + "/pages/338e30/" + ], + [ + "02.REDIS相关/050.简述 Redis 中跳表的应用以及优缺点.md", + "简述 Redis 中跳表的应用以及优缺点", + "/pages/a42826/" + ], + [ + "02.REDIS相关/060.Redis 中，sentinel 和 cluster 的区别和适用场景是什么？.md", + "Redis 中，sentinel 和 cluster 的区别和适用场景是什么？", + "/pages/e2e910/" + ], + [ + "02.REDIS相关/070.简述 Redis 中如何防止缓存雪崩和缓存击穿.md", + "简述 Redis 中如何防止缓存雪崩和缓存击穿", + "/pages/03cd25/" + ], + [ + "02.REDIS相关/080.简述 Redis 的线程模型以及底层架构设计.md", + "简述 Redis 的线程模型以及底层架构设计", + "/pages/9c28c9/" + ], + [ + "02.REDIS相关/100.简述 Redis 的哨兵机制.md", + "简述 Redis 的哨兵机制", + "/pages/cc8507/" + ], + [ + "02.REDIS相关/110.简述 Redis 如何处理热点 key 访问.md", + "简述 Redis 如何处理热点 key 访问", + "/pages/795c09/" + ], + [ + "02.REDIS相关/120.Redis 序列化有哪些方式？.md", + "Redis 序列化有哪些方式？", + "/pages/0d3c6b/" ] ] } @@ -4609,31 +10775,39 @@ export const siteData = { "collapsable": true, "children": [ [ - "10.Netty/01.Netty.md", + "10.Netty/001.你熟悉哪些IO模型？.md", "Netty", "/pages/40f3c9/" - ] - ] - }, - { - "title": "Spring", - "collapsable": true, - "children": [ + ], [ - "20.Spring/01.Spring.md", - "Spring", - "/pages/434235/" - ] - ] - }, - { - "title": "Mybatis", - "collapsable": true, - "children": [ + "10.Netty/010.TCP粘包拆包问题的解决之道.md", + "TCP粘包拆包问题的解决之道", + "/pages/3db019/" + ], + [ + "10.Netty/015.Netty中有哪些解码器？.md", + "Netty中有哪些解码器？", + "/pages/59089d/" + ], + [ + "10.Netty/020.为什么Netty要自己写一个ByteBuf.md", + "为什么Netty要自己写一个ByteBuf", + "/pages/ef17ee/" + ], + [ + "10.Netty/030.ChannelPipeline和ChannelHandler.md", + "ChannelPipeline和ChannelHandler", + "/pages/f851b6/" + ], [ - "30.Mybatis/01.Mybatis.md", - "Mybatis", - "/pages/3793a5/" + "10.Netty/040.EventLoop和EventLoopGroup.md", + "EventLoop和EventLoopGroup", + "/pages/e7aa60/" + ], + [ + "10.Netty/050.Java NIO了解吗？.md", + "Java NIO了解吗？", + "/pages/bfdcc8/" ] ] }, @@ -4642,29 +10816,48 @@ export const siteData = { "collapsable": true, "children": [ [ - "40.Kafka/01.Kafka.md", + "40.Kafka/001.Kafka包含那几部分.md", "Kafka", "/pages/561f34/" - ] - ] - }, - { - "title": "Dubbo", - "collapsable": true, - "children": [ + ], + [ + "40.Kafka/010.生产者.md", + "生产者", + "/pages/fe7ca2/" + ], + [ + "40.Kafka/020.消费者.md", + "消费者", + "/pages/fed167/" + ], + [ + "40.Kafka/030.集群下的Kafka要考虑哪些事情.md", + "集群下的Kafka要考虑哪些事情", + "/pages/8d1d04/" + ], [ - "50.Dubbo/01.Dubbo.md", - "Dubbo", - "/pages/78517c/" + "40.Kafka/040.如何保证Kafka的可靠性.md", + "如何保证Kafka的可靠性", + "/pages/76a94c/" ] ] } ], "/08.系统设计/": [ [ - "01.系统设计.md", + "001.系统设计.md", "系统设计", "/pages/01b9b2/" + ], + [ + "010.什么是 CAP ？什么是最终一致性？什么是幂等操作？.md", + "什么是 CAP ？什么是最终一致性？什么是幂等操作？", + "/pages/20c647/" + ], + [ + "020.简述什么是两阶段提交？.md", + "简述什么是两阶段提交？", + "/pages/4eae5b/" ] ], "/10.非技术/": [ @@ -4680,18 +10873,6 @@ export const siteData = { "关于", "/about" ] - ], - "/20.收藏夹/": [ - [ - "01.网站.md", - "网站", - "/pages/beb6c0bd8a66cea6" - ], - [ - "02.常用的前端轮子.md", - "常用的前端轮子", - "/pages/47cf96/" - ] ] }, "author": { @@ -4699,9 +10880,9 @@ export const siteData = { "link": "https://github.com/AdmireAn/JavaDriver" }, "blogger": { - "avatar": "/img/head_photo.JPG", + "avatar": "https://tva1.sinaimg.cn/large/e6c9d24egy1h2f580pnmdj213w0u0422.jpg", "name": "YoungAnn", - "slogan": "西二旗Java老司机一枚 致力于社会主义舔砖Java" + "slogan": "西二旗Java老司机一枚 致力于社会主义添砖Java" }, "social": { "icons": [ @@ -4723,11 +10904,11 @@ export const siteData = { ] }, "footer": { - "createYear": 2019, + "createYear": 2022, "copyrightInfo": "YoungAnnn | MIT License" }, "htmlModules": { - "homeSidebarB": "" + "homeSidebarB": "问题反馈
\n![](\"https://tva1.sinaimg.cn/large/e6c9d24egy1h2h0q9m8wzj20b40b4myw.jpg\")
\n [扫码反馈] (opens new window)\n \n