add

Author: IQQcode

java/0-JavaSE/c-集合类/2-Map集合.md

@@ -333,57 +333,9 @@ key: Person{id=1002, name='李四', age=20}   value: 2020-02
 
 ![](https://iqqcode-blog.oss-cn-beijing.aliyuncs.com/img/20200525112147.png)
 
-## 6. Map集合的遍历
+<br>
 
-**【方式一】通过map.keySet()获取key，通过key找到value**
-
-![](https://iqqcode-blog.oss-cn-beijing.aliyuncs.com/img/20200525110552.png)
-
-**【方式二】通过Map.Entry(String,String)获取，然后使用entry.getKey()获取到键，通过entry.getValue()获取到值**
-
-![](https://iqqcode-blog.oss-cn-beijing.aliyuncs.com/img/20200525111456.png)
-
-**【方式三】先放入Set集合中，Iterator遍历获取**
-
-![](https://iqqcode-blog.oss-cn-beijing.aliyuncs.com/img/20200525111943.png)
-
-**【方式四】只遍历键或者值，通过加强for循环**
-
-![](https://iqqcode-blog.oss-cn-beijing.aliyuncs.com/img/20200525112035.png)
-
-----------------------------------------------------------------------------------
-
-**计算一个字符串中每个字符出现次数**
-
-解题思路：
-
-1. 使用 Scanner获取用户输入的字符串  
-
-2. 创建Map集合，key是字符串中的字符， value是字符的个数  
-
-3. 遍历字符串获取每一个字符  
-
-4. 使用获取到的字符，去Map集合判断key是否存在  
-   
-    - key存在：  
-      
-       - 通过字符（key），获取vaue（字符个数）  
-       
-       - value++  
-       
-       - put（key, value）把新的 value存储到Map集合中  
-      
-    - key不存在：  
-      
-       - put（key, 1）  
-
-5. 遍历Map集合，输出结果
-
-![](https://iqqcode-blog.oss-cn-beijing.aliyuncs.com/img/20200525114532.png)
-
-
-
-## 7. 表格数据存储
+## 6. 表格数据存储
 
 > 使用容器来存储表格数据
 
@@ -488,7 +440,7 @@ Student{id=1002,  name='李四',  age=20,  graduation=2021-07}
 Student{id=1003,  name='王五',  age=22,  graduation=2017-07}
 ```
 
-## 8. 是否可以存储null
+## 7. 是否可以存储null
 
 |   结构    | null |
 | :-------: | :--: |

java/0-JavaSE/c-集合类/3-HashMap.md

@@ -380,10 +380,12 @@ loadFactor = size / capacity
 - 0.75为加载因子
 - 创建新数组，2倍扩容，浅拷贝原数组
 
-HashMap在进行扩容时，**不需要重新计算hash值**。`rehash`方式非常巧妙，因为每次扩容都是翻倍，与原来计算的`(n-1)&hash`的结果相比，只是多了一个bit位，所以节点要么就在**原来**的位置，要么就被分配到**原位置+旧容量**这个位置
+HashMap在进行扩容时，**不需要重新计算hash值**。`rehash`方式非常巧妙，因为每次扩容都是翻倍，与原来计算的`(n-1)&hash`结果相比，只是多了一个bit位，所以节点要么就在**原来**的位置，要么就被分配到**原位置+旧容量**这个位置
 
 ![](3-HashMap.assets/20200812101302.png)
 
+<img src="3-HashMap.assets/image-20200829163933608.png" alt="image-20200829163933608" style="zoom:67%;" />
+
 **<font color = red>【注意】：</font>**
 
 - 扩容并不是直接将数组对应`hash`下的链表直接复制，而是节点逐个移动，*重新计算Hash值*
@@ -400,6 +402,15 @@ HashMap在进行扩容时，**不需要重新计算hash值**。`rehash`方式非
 
 - JDK7扩容采用头插法，导致数据-移动到扩容后的数组顺序发生变化	
 
+<br>
+
+## 5. 删除remove
+
+- 若为树，查找为`O(logn)`
+- 若为链表，查找为`O(n)`
+
+<br>
+
 ## 6. 并发问题
 
 ### 问题复现
@@ -496,3 +507,11 @@ public static void main(String[] args) {
 }
 ```
 
+
+
+## 7. JDK7多线程下扩容产生循环链表
+
+> https://www.bilibili.com/video/BV1x741117jq?p=2
+>
+> - 37:40开始
+

java/0-JavaSE/d-多线程/JUC/4.Java内存模型JMM详解.md

@@ -280,7 +280,7 @@ MESI缓存一致性协议，通过对总线的侦听机制，很好地解决了
 
 > 由于汇编代码比较长，虽然俺学了微机原理，但真的是看不懂😭。就挑最重要的一句摘录出来解释
 
-    
+   
 
 ```java
 0x0000000002c860bf：lock add dword ptr [rsp], Oh ; *putstatic initFlag 
@@ -544,19 +544,49 @@ CPU为了提高执行效率，这三步操作的顺序可以是123，也可以
 
 - sfence：即写屏障(Store Barrier)，在写指令之后插入写屏障，能让写入缓存的最新数据写回到主内存，以保证写入的数据立刻对其他线程可见。
 
-- mfence，即全能屏障，具备ifence和sfence的能力。
+	
 
 - [ ] Lock前缀：Lock不是一种内存屏障，但是它能完成类似全能型内存屏障的功能。
 
 `volatile`会给代码添加一个内存屏障，指令重排序的时候不会把后面的指令重排序到屏障的位置之前
 
 ![](https://iqqcode-blog.oss-cn-beijing.aliyuncs.com/img/20200613084031.png)
 
-> PS😐：只有一个CPU的时候，这种内存屏障是多余的。只有多个CPUI访问同一块内存的时候，就需要内存屏障了。
+> PS😐：只有一个CPU的时候，这种内存屏障是多余的。只有多个CPU访问同一块内存的时候，就需要内存屏障了
+
+
+
+### 读写屏障
+
+**写屏障**：保证 `屏障之前`的代码**不会**进行重排序
+
+**读屏障**：保证 `屏障之后`的代码**不会**进行重排序
+
+```java
+static volatile boolean read;
+
+public void actor1() {
+    num = 2;
+    ready = true; // 写屏障
+}
+
+public void actor2() {
+    // 读屏障
+    if(ready) {
+        res = num + num;
+    } else {
+        res = 1;
+    }
+}
+```
+
+通过读写屏障来保证内存之间的有序性，禁止指临重排。
+
+<br>
 
 ### JMM的Happens-Before原则
 
-Happens-Before 是java内存模型中的语义规范，来阐述操作之间内存的可见性，可以确保一条语句的所有“写内存”操作对另一条语句是可见的。
+Happens-Before 是java内存模型中的语义规范，来**保证内存操作之间的可见性**，可以确保一条语句的所有“写内存”操作对另一条语句是可见的。
 
 **Happens-Before原则如下：**
 
@@ -568,13 +598,13 @@ Happens-Before 是java内存模型中的语义规范，来阐述操作之间内
 
 4. 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；
 
-5. 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
+5. 线程启动规则：Thread对象的`start()`方法先行发生于此线程的每个一个动作；
 
-6. 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
+6. 线程中断规则：对线程`interrupt()`方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
 
 7. 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；
 
-8. 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；
+8. 对象终结规则：一个对象的初始化完成先行发生于他的`finalize()`方法的开始；
 
 以上的happens-before原则为volatile关键字的可见性提供了强制保证。
 

java/0-JavaSE/d-多线程/Thread/5.synchnized原理及优化.md

@@ -162,31 +162,22 @@ synchronized的操作都是互斥的，Monitor机制是由操作系统来提供
 
 **优化的思想：让每个线程通过同步代码块时的速度提高**
 
-----
+### 锁升级的过程
 
-### CAS自旋
+面：前面你提到synchronized是个重量级锁，那它的优化有了解嘛？
 
-CAS自旋，无锁实现的同步----乐观锁Compare And Swap
+应：为了减少获得锁和和释放锁带来的性能损耗引入了偏向锁、轻量级锁、重量级锁来进行优化，锁升级的过程如下：
 
-![在这里插入图片描述](https://img-blog.csdnimg.cn/20200530181502532.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzIzMjk1NQ==,size_16,color_FFFFFF,t_70)
-`Compare And Swap(O, V, N)`
+首先是一个**无锁**的状态，当线程进入同步代码块的时候，会检查对象头内和栈帧中的锁记录里是否存入存入当前线程的ID，如果没有使用**CAS **进行替换。以后该线程进入和退出同步代码块不需要进行CAS 操作来加锁和解锁，只需要判断对象头的Mark word内是否存储指向当前线程的偏向锁。如果有表示已经获得锁，如果没有或者不是，则需要使用CAS进行替换，如果设置成功则当前线程持有偏 向锁，反之将偏向锁进行撤销并升级为轻量级锁。
+  
+轻量级锁加锁过程，线程在执行同步块之前，JVM会在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头的Mark Word复制到锁记录(Displaced Mark Word)中，然后线程尝试使用CAS 将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，反之表示其他线程竞争锁，当前线程便尝试使用自旋来获得锁。
+  
+轻量级锁解锁过程，解锁时，会使用CAS将Displaced Mark Word替换回到对象头，如果成功，则表示竞争没有发生，反之则表示当前锁存在竞争锁就会膨胀成重量级锁。
 
-**自旋带来的问题： ABA问题**
+**升级过程流程图**
+![在这里插入图片描述](5.synchnized原理及优化.assets/20200901222222643.png)
 
-- 解决方法： 添加版本号 A.1----> B.2
 
-自旋在CPU上跑无用指令，虽然减少了操作系统的开销，但是浪费了CPU资源
-
-**JVM自适应自旋 ：** 根据以往自旋等待时能否获取锁，来动态调整自旋的时间(循环数)
-
-- JVM尝试自旋一段时间，若在此时间内线程成功获取到锁，在下次获取锁时，适当延长自旋时间；
-- 若在此时间内线程没有获取到锁，在下次获取锁时，适当缩短自旋时间
-
-**公平性问题**
-
-- 处于阻塞状态的线程可能一直无法获取到锁，自旋状态的线程更容易获取到锁
-
-- Lock锁可以实现公平性，synchronized是非公平锁
 
 ----------
 

java/0-JavaSE/d-多线程/Thread/7.死锁.md

@@ -1,6 +1,6 @@
 ## 1. 死锁
 
-死锁的产生：细粒度的多把锁🔒下，要同时获取多个锁资源可能会产生
+死锁的产生：细粒度的多把锁🔒下，要同时获取对方的锁资源
 
 有这样的情况：一个线程需要同时获取多把锁，这时就容易发生死锁
 
@@ -95,7 +95,7 @@ public class DeadLock {
 
 **2. jstack查看当前线程信息**
 
- ![image-20200823135835637](7.死锁及Lock锁体系.assets/image-20200823135835637.png)
+![image-20200823135835637](7.死锁及Lock锁体系.assets/image-20200823135835637.png)
 
 【日志显示】
 
@@ -173,7 +173,13 @@ Found 1 deadlock.
 
 **破坏死锁占有且等待的条件，让两个线程不再同时拿到对方想要的锁**
 
-在Lock接口出现之前，java程序主要是靠`synchronized`关键字实现锁功能。而JDK5之后，并发包中增加了Lock接口，它提供了与synchronized一样的锁功能。虽然它失去了像synchronize隐式加锁解锁的便捷性(Lock锁为显式)，但是却拥有了获取锁和释放锁的可操作性，可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性（synchronized锁是互斥的）
+Lock解决死锁，**破坏不可抢占**：
+
+1. 响应中断`lockInterruptibly`
+2. 支持超时`boolean tryLock(long time, TimeUnit unit)`
+3. 非阻塞式获取锁，线程若获取不到锁，线程直接退出`boolean tryLock()`
+
+在Lock接口出现之前，Java程序主要是靠`synchronized`关键字实现锁功能。而JDK5之后，并发包中增加了Lock接口，它提供了与synchronized一样的锁功能。虽然它失去了像synchronize隐式加锁解锁的便捷性(Lock锁为显式)，但是却拥有了获取锁和释放锁的可操作性，可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性（synchronized锁是互斥的）
 
 <br>
 

java/0-JavaSE/d-多线程/Thread/9.线程池.md

@@ -1,4 +1,4 @@
-> 线程池：4大方法、7大参数、4种拒绝策略
+> 线程池：4大方法、7大参数、4种拒绝策略
 
 ## 1. 线程池
 
@@ -14,7 +14,7 @@
 
 ### 线程池概述
 
-程序启动一个新的线程的成本是比较高的，因为它要与操作系统来交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量<font color=green>生命周期很短的线程时</font>，更应该考虑使用**线程池**。
+程序启动一个新的线程的成本是比较高的，因为它要与操作系统来交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量<font color=green>**生命周期很短的线程时**</font>，更应该考虑使用**线程池**。
 
 **线程池里的每一个线程在调用结束后，并不会死亡，而是再次回到线程池中成为空闲状态，再次等待调度**
 
@@ -93,13 +93,13 @@ public ThreadPoolExecutor(int corePoolSize,
 
 2. int maximumPoolSize：最大核心池大小
 
-3. long keepAliveTime：超时不调用就会释放
+3. long keepAliveTime：生存时间，超时不调用就会释放（针对救急线程）
 
-4. TimeUnit unit：超时单位
+4. TimeUnit unit：超时单位（针对救急线程）
 
 5. BlockingQueue<Runnable> workQueue：阻塞队列
 
-6. ThreadFactory threadFactory：线程工厂，创建线程
+6. ThreadFactory threadFactory：线程工厂，创建线程并为线程命名
 
 7. RejectedExecutionHandler handler：拒绝策略
 
@@ -275,7 +275,7 @@ public class Test {
 
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200530003622555.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzIzMjk1NQ==,size_16,color_FFFFFF,t_70)
 
-![\[外链图片转存失败(img-4QrjGqJw-1565343912034)(C:\Users\j2726\AppData\Roaming\Typora\typora-user-images\1564904750301.png)\]](https://img-blog.csdnimg.cn/20190809192817740.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzIzMjk1NQ==,size_16,color_FFFFFF,t_70)
+![](https://img-blog.csdnimg.cn/20190809192817740.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzIzMjk1NQ==,size_16,color_FFFFFF,t_70)
 
 当一个任务提交给线程池时
 

java/0-JavaSE/g-JVM/a-类加载系统/类加载系统.md

@@ -4,7 +4,7 @@
 
 **Java程序，由编译到运行期间的过程是怎样的？**（概念简述）
 
-- 首先，通过编译器将`.java`程序编译成`.class`文件
+- 首先，通过编译器将`.jav a`程序编译成`.class`文件
 
 - 然后通过**Class Loader**类加载器加载到内存中，生成`Class`对象
 
@@ -88,7 +88,11 @@
 
 此方法不需定义，是 javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来 
 
--------------------
+<br>
+
+**类加载时，JVM确保了类加载的过程是线程安全的。只有当前类加载完成，其他类才会被加载**
+
+<hr>
 
 ## 3. 类加器的分类
 
@@ -238,10 +242,23 @@ public class String {
 
 **【双亲委派模型优势】**
 
-- <font color="pink">避免类的重复加载</font>
-
+- <font color="pink">隔离加载类，避免类的重复加载</font>
 - <font color="pink">保护程序安全、防止核心API被篡改</font>
 
+<br>
+
+### Tomcat的类加载机制
+
+<img src="类加载系统.assets/image-20200905003423993.png" alt="image-20200905003423993" style="zoom:40%;" />
+
+每一个部署在Tomcat服务器上的应用的类加载器是WebappClassLoader，有多少个应用，就有多少个这样独立的加载器。
+
+**Tomcat默认的类加载机制并不是双亲委派模型**（可以改）。
+
+Tomcat破坏双亲委派模型，是为了**将各个Web应用隔离开**。
+
+> 例如JDK7和JDK8下，同一个jar包属于不同的版本，我们需要隔离加载不同的版本。
+
 ## 5. Class对象是否相等
 
 怎么样判断类加载器加载到内存中的两个Class对象是否相等？

java/0-JavaSE/g-JVM/b-运行时数据区/04.虚拟机栈.md

@@ -8,7 +8,7 @@
 
 【基于栈的优势】：跨平台，指令集小，编译器容易实现；
 
-【劣势】：性能下降，实现的同样的功能指令多
+【劣势】：相比基于寄存器的方式，性能下降，实现的同样的功能指令多
 
 ### 内存中的栈与堆
 
@@ -42,9 +42,9 @@ Java虚拟机规范允许<font color = red>Java栈的大小是动态的或者固
 
 - 如果线程请求的栈的深度大于虚拟机所允许的最大深度，抛出`StackOverflowError`
 
-- 如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法中请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那JVM将会抛出`OutOfMemoryError`异常
+- 如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法中请到足够的内存，或者在**创建新的线程时**没有足够的内存去创建对应的虚拟机栈，那JVM将会抛出`OutOfMemoryError`异常
 
-> HotSpot虚拟机栈容量不可以动态扩展，但是申请失败是仍会产生OOM
+> HotSpot虚拟机栈容量不可以动态扩展，但是申请失败（并未拓展）仍会产生OOM，就是在创建新的线程时，已经没有足够内存为其分配空间来创建。
 
 【手动设置虚拟机栈的容量大小】
 
@@ -96,7 +96,7 @@ Java虚拟机规范允许<font color = red>Java栈的大小是动态的或者固
 
 局部变量表Local Variables（局部变量数组或者本地变量表）。
 
-1. 局部变量表是一个<font color = pink>数字数组</font>，主要用于存储方法参数和定义在方法体内的局部变量。
+1. 局部变量表是一个<font color = pink>数字数组</font>，主要用于存储方法参数 和 定义在方法体内的局部变量。
 
     - 数据类型包括：基本数据类型、引用类型、返回值类型
 
@@ -201,7 +201,7 @@ public class LocalVariablesTest01 {
 
 > 局部变量表和操作数栈底层都是采用数组实现的，所以一旦初始化后，长度是固定不变的
 
-这些数据类型在局部变量表中的存储空间用局部**变量槽（Slot）**来表示，`long`和`double`是64位占两个槽，其余占一个。
+这些数据类型在局部变量表中的存储空间用局部 **变量槽（Slot）**来表示，`long`和`double`是64位占两个槽，其余占一个。
 
 > 所以局部变量表的容量就是槽的个数，在编译期间就是确定的
 

java/2-Java EE/1-Spring/Spring核心思想.md

@@ -1 +1 @@
-![timg](Spring核心思想.assets/timg.jpeg)
+ ![timg](Spring核心思想.assets/timg.jpeg)