add && fix

Author: DogerRain

docs/01.LearnJavaToFindAJob/02.【初级】6~12k档/01.Java基础/Java基础面试题.md

@@ -45,7 +45,7 @@ tags:
 
 5. 接口隔离原则——ISP
 
-> 把接口分成满足依赖关系的最小接口，实现类中不能有不需要的方法。
+> 把接口分成满足依赖关系的最小接口，实现类中不能有不需要的方法。简单来说就是大接口拆开变成小接口
 
 6. 迪米特原则——LOD
 
@@ -59,24 +59,24 @@ tags:
 
 常见的有 抽象工厂模式、工厂方法模式、建造者模式、单例模式。
 
-![ ](https://cdn.jsdelivr.net/gh/DogerRain/image@main/img-20210401/401339-20170928225241215-295252070.png)
+![ ](http://rainyudianxx.baimuxym.cn/HelloCoder/blog/401339-20170928225241215-295252070.png)
 
 
 
 ### 2、8种基本数据类型
 
 > String不是基本类型。
 
-双等号（==），比较的是他们的值。基本数据类型没有equals方法。
+双等号（==），比较的是他们的值。**基本数据类型没有equals方法。**
 
-![ ](https://images-1253198264.cos.ap-guangzhou.myqcloud.com/clipboard-1601965896460.png)
+![ ](http://rainyudianxx.baimuxym.cn/HelloCoder/blog/clipboard-1601965896460.png)
 
 拆箱和装箱：
 
 ```java
 //自动装箱
 Integer total = 99;
-//自定拆箱
+//自动拆箱
 int totalprim = total;
 ```
 
@@ -117,12 +117,16 @@ Integer的默认值是null；int的默认值是0。
 
 ### 3、访问修饰符
 
-![ ](https://images-1253198264.cos.ap-guangzhou.myqcloud.com/7010483_1495588925759_ACED241801E307EE7A39612F85A94EBF.png)
+| 访问修饰符       | 当前类 | 同一个包 | 不同包的子类 | 不同包的非子类 | 通俗理解                          |
+| :--------------- | :----- | :------- | :----------- | :------------- | :-------------------------------- |
+| `public`         | ✔️      | ✔️        | ✔️            | ✔️              | **完全开放** - 对所有类可见       |
+| `protected`      | ✔️      | ✔️        | ✔️            | ❌              | **家族共享** - 对子类和同包类开放 |
+| `default` (不写) | ✔️      | ✔️        | ❌            | ❌              | **内部资料** - 仅同包内可见       |
+| `private`        | ✔️      | ❌        | ❌            | ❌              | **个人隐私** - 仅本类内可见       |
+
+
+
 
-public：所有地方的类都可以访问。
-private：只能在当前类中进行访问。
-protected：可以在当前类、当前包、子类中进行访问
-不写默认为default：可以在当前类，当前包中进行访问。
 
 
 
@@ -159,6 +163,7 @@ protected：可以在当前类、当前包、子类中进行访问
 方法的重载和重写都是实现多态的方式，区别在于：
 
 重载实现的是编译时的多态性。
+
 重写实现的是运行时的多态性。
 
 - 重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；**重载对返回类型没有特殊的要求，但不能根据返回类型进行区分。**
@@ -237,7 +242,7 @@ public interface People {
 | 实例化       | 不是具体类，不能实例化                                       | 不是类，不能实例化                                           |
 | 方法体       | 抽象方法访问类型**不能是private**，不能是 static、final修饰（需要实现的~），而且默认是 abstract 修饰 | 接口中方法默认是`public abstract`（只能是这两个关键字，或其中一个或都省略）。因为要被继承，所以是public的。 |
 
-> 接口可以看作一个更特殊的抽象类，修饰符和限制都更多了，但是自从1.8中及以后，接口的**普通方法**要比抽象类要灵活了，跟普通类一样使用；而抽象类不能使用static其他基本无异
+> 接口可以看作一个更特殊的抽象类，修饰符和限制都更多了，但是自从1.8中及以后，接口的**普通方法**要比抽象类要灵活了，跟普通类一样使用；抽象类除了不能使用static，其他基本无异
 
 
 
@@ -251,7 +256,9 @@ public interface People {
 
 ### 8、switch中能否使用string做参数?
 
-在JDK 1.7之前,switch只能支持byte,short,char,int或者其对应的包装类以及Enum类型.从JDK 1.7之后switch开始支持String类型.但到目前为止,switch都不支持long类型。
+在JDK 1.7之前,switch只能支持byte,short,char,int或者其对应的包装类以及Enum类型。
+
+从JDK 1.7之后switch开始支持String类型、枚举类型，但到目前为止，switch都不支持long类型。
 
 **还有break的坑：**
 
@@ -282,10 +289,8 @@ public class SwitchCaseTest {
 ### 9、String、StringBuffer、StringBuilder区别
 
 - 可变性
-  简单的来说：String 类中使用 final 关键字字符数组保存字符串， `private final char value[]` ，所以 String
-  对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder
-  中也是使用字符数组保存字符串`char[] value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。
-
+  简单的来说：String 类中使用 final 关键字字符数组保存字符串， `private final char value[]` ，所以 String对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串`char[] value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。
+  
 - 安全性
 
   String 是一个字符串常量，final修饰，当创建之后即不能更改，不可被继承，线程安全 
@@ -315,6 +320,17 @@ public class SwitchCaseTest {
 
 
 
+| 特性         | String                 | StringBuffer               | StringBuilder            |
+| :----------- | :--------------------- | :------------------------- | :----------------------- |
+| **可变性**   | ❌ 不可变               | ✅ 可变                     | ✅ 可变                   |
+| **线程安全** | ✅ 线程安全             | ✅ 线程安全（synchronized） | ❌ 非线程安全             |
+| **性能**     | 最低（频繁创建新对象） | 中等（有同步开销）         | **最高**（无同步开销）   |
+| **使用场景** | 字符串常量、不需要修改 | 多线程环境下的字符串操作   | 单线程环境下的字符串操作 |
+
+
+
+
+
 留个题目：
 
 ```Java
@@ -344,6 +360,18 @@ Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。
 
 
 
+或者你可以这样理解：
+
+> 简单来说：离目标小数近的整数；中间的（即  .5）往右靠
+
+```shell
+往右  ——————————>
+
+ -11.7 -- -11.5 —— -11 —— 0 —— 11.5 —— 12
+```
+
+
+
 ### 11、String s = "xyz"和String s = new String("xyz");区别
 
 `String s = new String("hello");`**可能创建两个对象也可能创建一个对象**。如果常量池中有`hello`字符串常量的话，则仅仅在堆中创建一个对象。如果常量池中没有`hello`对象，则堆上和常量池都需要创建。
@@ -381,7 +409,7 @@ System. out. println(str==str2); //false
 
 ### 12、 异常
 
-![](https://cdn.jsdelivr.net/gh/DogerRain/image@main/Home/image-20210115172917862.png)
+![](http://rainyudianxx.baimuxym.cn/HelloCoder/blog/image-20210115172917862.png)
 
 Throwable 分为Exception（异常） 和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
 
@@ -419,7 +447,7 @@ Java 的所有异常可以分为受检异常（checked exception）和非受检
 
 ### 13、Throw 和 throws 的区别：
 
-​	  **位置不同：**
+**位置不同：**
 
 1. throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的是异常对象。
 
@@ -433,6 +461,13 @@ Java 的所有异常可以分为受检异常（checked exception）和非受检
 
 
 
+```java
+public static void main(String[] args) throws Exception,InterruptedException {}
+
+    
+throw new ZkSerializerException(e);
+```
+
 
 
 ### 14、java中4种类型的流
@@ -453,13 +488,15 @@ Java 的所有异常可以分为受检异常（checked exception）和非受检
 
 
 
- 字节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。因此在输出时，字节流不调用colse()方法时，信息已经输出了，而字符流只有在调用close()方法关闭缓冲区时，信息才输出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。
+字节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。因此在输出时，字节流不调用colse()方法时，信息已经输出了，而字符流只有在调用close()方法关闭缓冲区时，信息才输出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。
+
+- 读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
+
+- 处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
 
-·    读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
 
-·    处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
 
-**结论：只要是处理纯文本数据，就优先考虑使用字符流。除此之外都使用字节流。**
+**结论：只要是处理纯文本数据，就优先考虑使用字符流。除此之外都使用字节流。** 但是字节流可以处理字符流，反之不能。
 
 
 

docs/01.LearnJavaToFindAJob/02.【初级】6~12k档/01.Java基础/Java多线程面试题.md

@@ -44,21 +44,21 @@ synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得
 
 多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞。
 
-volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
+**volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。**
 
-volatile关键字主要用于解决变量在多个线程之间的**可见性**，而 synchronized关键字解决的是多个线程之间访问资源的同步性。
+**volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。**
 
 synchronized 保证三大性：**原子性，有序性，可见性**，
 
-volatile 保证**有序性，可见性，不能保证原子性**。
+volatile 保证：**有序性，可见性，不能保证原子性**。
 
 
 
 ### 4、sleep方法和wait方法有什么区别
 
 sleep方法和wait方法都可以用来放弃CPU一定的时间暂停当前运行的线程，不同点在于如果线程持有某个对象的监锁，**sleep方法不会释放这个对象的锁，wait方法会释放这个对象的锁**，sleep必须要设定时间，而wait可以设定也可以不设定。
 
-Sleep属于Thread类，wait属于Object类。
+sleep属于Thread类，wait属于Object类。
 
 
 
@@ -104,7 +104,7 @@ https://mp.weixin.qq.com/mp/appmsgalbum?action=getalbum&album_id=151964076808745
 
 1. start（）方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码。
 
-2. 通过调用 Thread 类的 start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。
+2. 通过调用 Thread 类的 start()方法来启动一个线程， **此时线程是处于就绪状态， 并没有运行。**
 
 3. 方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了运行状态，开始运行 run 函数当中的代码。 Run 方法运行结束， 此线程终止。然后 CPU 再调度其它线程。
 
@@ -117,6 +117,7 @@ https://mp.weixin.qq.com/mp/appmsgalbum?action=getalbum&album_id=151964076808745
 1.  都是用来协调多线程对共享对象、变量的访问
 2.  都是可重入锁，同一线程可以多次获得同一个锁
 3.  都保证了可见性和互斥性
+4.  synchronized 和 ReentrantLock 都是悲观锁（假设一定会发生冲突，先加锁再操作）
 
 异：
 
@@ -126,8 +127,6 @@ https://mp.weixin.qq.com/mp/appmsgalbum?action=getalbum&album_id=151964076808745
 3.  ReentrantLock 是 API 级别的，synchronized 是 JVM 级别的
 4.  ReentrantLock 可以实现公平锁
 5.  ReentrantLock 通过 Condition 可以绑定多个条件
-6.  底层实现不一样， synchronized 是同步阻塞，使用的是悲观并发策略，lock 是同步非阻
-塞，采用的是乐观并发策略
 7.  Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言
 实现。
 8.  synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；
@@ -140,6 +139,10 @@ https://mp.weixin.qq.com/mp/appmsgalbum?action=getalbum&album_id=151964076808745
 
 
 
+中断interrupt 只影响线程的状态，不影响 synchronized\ReentrantLockDeadLock 的锁持有
+
+
+
 ### 11、线程的调度策略
 
 线程调度器选择优先级最高的线程运行，但是，如果发生以下情况，就会终止线程的运行：
@@ -153,14 +156,3 @@ https://mp.weixin.qq.com/mp/appmsgalbum?action=getalbum&album_id=151964076808745
 （4）另外一个更高优先级线程出现
 
 （5）在支持时间片的系统中，该线程的时间片用完
-
-
-
-### 12、如何停止一个正在运行的线程？
-
-1. 使用退出标志（比如return），使线程正常退出，也就是当run方法完成后线程终止。
-2. 使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend及resume一样都是过期作废的方法。
-3. 使用interrupt方法中断线程。
-
-
-

docs/01.LearnJavaToFindAJob/大厂面试题/synchronized锁升级.md

@@ -0,0 +1,94 @@
+锁升级过程：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁。
+
+
+
+### 各jdk版本锁
+
+
+
+> 在jdk1.5版本（包含）之前，锁的状态只有两种状态：“无锁状态”和“重量级锁状态”，只要有线程访问共享资源对象，则锁直接成为重量级锁。因为加锁和释放锁的过程JVM的底层都是由操作系统mutex lock来实现的，其中会涉及上下文的切换（即用户态和内核态的转换），性能消耗极其高，所以在当时synchronized锁是公认的重量级锁。性能消耗非常大。后来JVM开发团队为解决性能问题，在jdk1.5版本中加入了JUC并发包，包下开发了很多Lock相关的锁。
+>
+> 
+>
+> jdk1.6版本后，对synchronized锁进行了优化，新加了“偏向锁”和“轻量级锁”，偏向锁是默认开启的，用来减少上下文的切换以提高性能，通过锁的升级来解决不同并发场景下的性能问题。所以锁就有了4种状态。
+>
+> 
+>
+> 在 JDK 15 中，但由于偏向锁其撤销成本较高，偏向锁被默认禁用了。因为很多开发者发现，对于竞争激烈的场景，偏向锁带来的收益小于其撤销成本。
+
+对象头（Mark Word）存储的内容： 
+
+![](http://rainyudianxx.baimuxym.cn/HelloCoder/blog/image-20251126111334471.png)
+
+> 解释： 
+>
+> 无锁：对于共享资源，不涉及多线程的竞争访问，就不会加锁
+
+
+
+
+
+### 锁升级流程
+
+**第一阶段：无锁 -> 偏向锁**
+
+- 触发条件：一个线程第一次进入同步块。
+
+- 目标：在没有竞争的情况下，消除同步原语的开销。这个锁会“偏向”于第一个获取它的线程。
+
+- 过程：
+
+  - 线程 A 访问同步块，检查锁标志位为 01，且偏向锁位为 0（表示可偏向）。
+  - 使用 CAS 操作，尝试将 Mark Word 中的 ThreadID 替换为自己的线程 ID。
+  - 如果 CAS 成功，线程 A 就持有了偏向锁。之后，只要线程 A 再次进入这个同步块，它只需要检查 Mark Word 中的 ThreadID 是否是自己，如果是，则无需任何同步操作，直接执行。
+
+- 优点：对于同一个线程重复获取锁的场景，性能极高，几乎没有额外开销。
+
+- 撤销：当有另一个线程 B 来尝试竞争这个锁时，偏向模式就宣告结束。JVM 需要撤销偏向锁。这个过程需要等待全局安全点，然后暂停持有偏向锁的线程 A，检查 A 是否存活或已退出同步块。然后根据情况，将锁升级为轻量级锁或恢复到无锁状态。
+
+  > 注意：在 JDK 6 之后，偏向锁是默认开启的，但由于其撤销成本较高，在 JDK 15 中，偏向锁被默认禁用了。因为很多开发者发现，对于竞争激烈的场景，偏向锁带来的收益小于其撤销成本。
+
+
+
+
+
+**第二阶段：偏向锁 -> 轻量级锁**
+
+- 触发条件：当偏向锁被撤销后，如果有线程竞争，但竞争是轻度的（即线程交替执行同步块，没有同时竞争）。
+- 目标：在线程交替执行的场景下，避免直接使用重量级锁带来的用户态/内核态切换开销。
+- 过程：
+  - 线程 A 持有偏向锁，线程 B 来竞争。
+  - 偏向锁被撤销。
+  - 线程 A 和 B 都会在自己的栈帧中创建一个名为 锁记录（Lock Record） 的空间。
+  - 线程 A 首先将当前 Mark Word 的内容复制到自己的锁记录中（称为 Displaced Mark Word）。
+  - 然后，线程 A 尝试用 CAS 操作将对象头的 Mark Word 替换为指向自己锁记录的指针。
+  - 如果成功，线程 A 就获取了轻量级锁。
+  - 此时，线程 B 也会进行同样的 CAS 操作来尝试获取锁，但会失败（因为 Mark Word 已被线程 A 修改）。失败后，线程 B 会自旋（循环重试 CAS）一小段时间来尝试获取锁。
+  - 如果在线程 B 自旋期间，线程 A 释放了锁（通过 CAS 将 Displaced Mark Word 写回对象头），那么线程 B 的 CAS 就可能成功，从而获取到锁。这样，线程间就没有发生阻塞。
+- 优点：竞争的线程不会阻塞，通过自旋来提高响应速度。
+
+升级：如果线程 B 自旋了一定次数后（JDK 6 引入了自旋适应的策略，一般默认锁10次 ？），还没能获取到锁，或者此时有第三个线程来竞争，说明竞争加剧了。此时，轻量级锁就会升级为重量级锁。
+
+
+
+**第三阶段：轻量级锁 -> 重量级锁**
+
+- 触发条件：轻量级锁竞争失败（自旋失败或有多线程竞争）。
+- 目标：处理重度竞争的场景。
+- 过程：
+  - JVM 会申请一个操作系统层面的 互斥量（Mutex Lock），也称为监视器锁（Monitor）。
+  - 将 Mark Word 的内容替换为指向这个互斥量的指针。
+  - 此时，所有未竞争到锁的线程（如线程 B），都会被挂起，进入操作系统的等待队列中。
+  - 等待锁被释放后，操作系统会负责唤醒这些被挂起的线程，让它们重新竞争。
+- 缺点：开销巨大。涉及到操作系统内核态的切换，线程的挂起和唤醒都是很耗时的操作。
+- 优点：在激烈竞争下，避免了 CPU 空转（无休止的自旋）。
+
+
+
+
+
+
+
+
+
+![](http://rainyudianxx.baimuxym.cn/HelloCoder/blog/image-20251126112248887.png)