HeloJ的博客

原创 内存溢出、泄漏

1. 内存泄漏 程序无法释放已申请的内存空间 1.1 声明静态的集合类 如：private static Map<String> map = new HashMap(); 它们的生命周期与应用程序的生命周期相同，容易导致OOM。 1.2 ThreadLocal未主动remove ThreadLocal使用弱引用作为key，当ThreadLocal不存在外部强引用时，key会被GC回收，就导致key为null，value还存在强引用，只有在线程结束时，value的强引用才会断掉 1.

原创 垃圾收集器

1. Serial收集器 是一个单线程垃圾收集器，垃圾收集过程过程中会STW，新生代使用标记-复制算法，老年代使用标记-整理算法。 启动参数：-XX:+/-UseSerialGC，可应用于客户端模式下虚拟机。 2. ParNew收集器 Serial收集器的多线程版本，能与CMS收集器配合工作。 老年代使用CMS后（-XX:+/-UseConcMarkSweepGC），新生代模式使用ParNew。 启动参数：-XX:+/-UseParNewGC(JDK9取消)，默认开启收集线程数...

原创 HotSpot算法细节

1. 根节点枚举 类加载完成后，HotSpot使用一组OopMap数据结构来记录对象内对应偏移量上对应的数据类型，在即时编译过程中，也会在特定位置记录下栈里和寄存器里哪些位置是引用。这样，垃圾收集器在进行GC Roots扫描时就不要从方法区等GC Roots开始查找，优化引用链构建效率。 OopMap会带来其他问题：如果每条指令都生成OopMap将需要大量额外的空间，此时引出了安全点。 2. 安全点 安全点主要针对程序获取CPU时间片，执行进行垃圾收集的情况。 HotSpot只在安全点位置才会生成

原创 垃圾收集算法

1. 分代收集理论 分代收集理论建立在两个分代假说之上： 弱分代假说：绝大多数对象都是朝生夕灭的。 强分代假说：熬过越多次垃圾收集过程的对象就越难以消亡。 2. 标记-清除算法 最基础的垃圾收集算法，分为标记和清除两个阶段 标记出所有需要回收的对象 标记完成后，统一回收掉所有被标记的对象 此算法主要缺点有两个： 执行效率不稳定 如果Java堆中包含大量需回收的对象，标记和清除的执行效率将降低 内存空间碎片化 清除之后产生大量不连续的内存碎片，导致后期分配较大对象时无法找到足够内

原创 对象存活判定

1. 引用计数算法 在对象中添加一个引用计数器， 每当有一个地方引用它时，计数器就加一； 当引用失效时，计数器值就减一； 任何时刻计数器为零的对象就是不可能再被使用的。 缺点：无法解决对象之间相互循环引用的问题 2. 可达性分析算法 从GC Roots到对象不可达时，则此对象不可能再被使用 GCRoots对象： 虚拟机栈中引用的对象，如：各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等 方法区中类静态属性引用的对象，如：Java类的引用类型静态变量 方法区中常量引用的对象，

原创 对象访问定位

Java程序会通过栈帧中的reference数据来操作堆上的具体对象，主流的对象访问方式有两种： 使用句柄访问 直接指针访问 1. 使用句柄 Java堆中可能会划分处一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄包含了对象实例数据与类型数据各自具体的地址信息。 优点：对象被移动时只会改变句柄中实例数据指针，reference本身无需更改 2. 直接指针 reference中存储对象地址，HotSpot使用此种访问方式 优点：访问速度快，节省一次指针定位的时间

原创 对象内存布局

在HotSpot虚拟机中，对象在堆内存中的存储布局可以划分为三个部分： 对象头 实例数据 对齐填充 1. 对象头 对象头包含一般包含两类信息，数组对象包含三类信息 1.1 存储对象自身的运行时数据（Mark Word） 如：哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向锁ID、偏向时间戳等 1.2 类型指针（Klass） 类型指针指对象指向它的类型元数据的指针，Java虚拟机通过这个指针来确定该对象是哪个类的实例。 1.3 数组长度 仅数组对象包含，主要用来虚拟机通过普通Jav

原创 对象创建流程

原创 内存模型

1. 程序计数器 程序计数器是一块较小的内存空间，可以看做是当前线程所执行的字节码的行号指示器。 各条线程之间程序计数器互不影响，独立存储，即：线程私有。 如果执行一个Java方法，程序计数器记录正在执行的虚拟机字节码指令的地址； 如果执行一个Native方法，程序计数器记录为空（Undefined）。 《Java虚拟机规范》未对此内存区域规定任何OOM情况。 2. Java虚拟机栈 Java虚拟机栈是线程私有的，生命周期与线程相同。 虚拟机栈描述的是Java方法执行的线程内存模型：每个..

原创 职责链模式

1. 类图 Handler：定义职责的接口，通常定义处理请求的方法，可以在此处实现后继链 ConcreteHandler：实现职责的类，对职责范围内请求的处理，对职责范围外请求的转发 Client：客户端，向链上的具体处理对象提交请求，让职责链负责处理 2. 示例 分离职责，动态组合 2.1 职责接口 public abstract class Handler { // 持有后继的职责对象 protected Handler handler; public v

原创 命令模式

1. 类图 Command：命令接口，声明执行的方法 ConcreteCommand：命令接口实现，持有并调用接收者的功能 Receiver：接收者，执行命令的对象 Invoker：要求命令对象执行请求，通常持有命令对象 Client：创建具体的命令对象，并设置命令对象的接收者 2. 示例 将请求封装成对象 2.1 命令接口 public interface Command { void execute(); } 2.2 命令实现 持有命令真正执行的对象 pub

原创 解释器模式

1. 类图 AbstractExpression：解释器接口 TerminalExpression：终结符解释器，解析句子的结束符 NonterminalExpression：非终结符解释器，用来实现语法规则中非终结符相关的操作。可以有多种非终结符解释器 Context：上下文，通常包含各个解释器需要的数据或是公共的功能 Client：使用解释器的客户端，按照语言的语法表达式转换成使用解释器对象描述的抽象语法树，然后调用解释操作 2. 示例 解释器对给定语法的句子进行解析 对字符串​1

原创 迭代器模式

1. 类图 Iterator：迭代器接口。定义访问和遍历元素的接口 ConcreteIterator：迭代器实现类。实现对聚合对象的遍历，并跟踪遍历时的当前位置 Aggregate：聚合对象。定义创建相应迭代器对象的接口 ConcreteAggregate：聚合对象实现。实现创建相应的迭代器对象 2. 示例 统一访问聚合元素的方法 2.1 迭代器接口 public interface Iterator { void first(); void next();

原创 中介者模式

1. 类图 Mediator：中介者接口。定义各个同事之间交互需要的方法 ConcreteMediator：中介者实现。了解和维护各个同事，并负责协调同事间的交互关系 Colleague：同事类父类，通常为抽象类。主要负责约束同事对象的类型，并实现一些具体同事类之间的公共功能 ConcreteColleague：具体的同事类，需要与其他同事通信时，就持有中介者通信 2. 示例 将多个对象之间的交互统一封装 2.1 中介者接口 public interface Mediator {

原创 访问者模式

1. 类图 Visitor：访问者接口，为所有访问者声明一个方法，用来代表对对象结构添加的功能 ConcreteVisitor：具体访问者，实现添加的功能 Element：元素对象，对象结构的顶层接口，定义接收访问的操作 ConcreteElement：具体元素对象，回调访问者的真实功能，开放自身的数据供访问者使用 ObjectStructure：对象结构，包含多个被访问的对象 2. 示例 为可能扩展的对象预留回路，通过回调的方式进行功能扩展，避免对对象的修改 2.1 现有对象抽象类

原创 模板方法模式

1. 类图 AbstractClass：抽象类。定义算法骨架和抽象操作 ConcreteClass：具体实现类。实现抽象类中的抽象操作 2. 示例 父类固定算法框架，子类父子框架内部实现 2.1 对象实体 public class LoginModel { private String username; private String password; public String getUsername() { return username;

原创 策略模式

1. 类图 Context：上下文，和具体的策略类交互 Strategy：策略接口，约束一系列具体的策略算法 ConcreteStrategy：具体策略算法实现 2. 示例 分离算法，选择实现，算法可任意替换 2.1 策略接口 public interface Strategy { double calcPrice(double price); } 2.2 策略实现 public class NormalCustomerStrategy implements Strate

原创 状态模式

1. 类图 Context：上下文，封装不同的状态 State：封装与上下文的一个特定状态所对应的行为 ConcreteState：具体的状态处理类 2. 示例 根据状态分离和选择行为 2.1 上下文 public class VoteContext { // 存放投票结果 private Map<String,String> resultMap = new HashMap<>(); // 存放投票次数 private Map&

原创 观察者模式

1. 类图 Subject：目标对象 一个目标可以被多个观察者观察 目标提供观察者订阅和取消的维护 目标对象发生变化，通知所有有效观察者 Observer：定义观察者接口，提供目标对象变化时，对应观察者的更新方法 ConcreteObserver：具体观察者实现 ConcreteSubject：具体目标对象实现 2. 示例 修改目标的数据，触发相应通知，联动调用观察者的方法 2.1 目标对象 知道所有的观察者，并提供和维护观察者的订阅与退订逻辑 public clas

原创 备忘录模式

1. 类图 Memento：备忘录。存储原发器对象的内部状态 Orginator：原发器。使用备忘录来保存某个时刻原发器自身的状态 Caretaker：备忘录管理者。保存备忘录对象 2. 示例 保存和恢复内部状态 2.1 备忘录 // 备忘录接口 public interface Memento {} // 实现类 blod保存原发器信息 public class MementoImpl implements Memento { private int blod;

原创 享元模式

1. 类图 Flyweight：享元接口 ConcreteFlyweight：享元实现对象 UnsharedConcreteFlyweight：非共享享元实现对象 FlyweightFactory：享元工厂 Client：客户端 2. 示例 同一对象实例的重复使用 2.1 享元接口 public interface FlyWeight { void action(); } 2.2 享元实现对象 public class ChildFlyWeight implement

原创 桥接模式

1. 类图 Abstraction：抽象部分的接口。维护一个实现部分的对象引用，抽象对象里面的方法，需要调用实现部分的对象来完成 RefinedAbstraction：扩展抽象部分的接口。定义跟实际业务相关的方法，这些方法通常使用Abstraction中定义的方法，也可能需要调用实现部分的对象来完成 Implementor：定义实现部分的接口。 ConcreteImplementor：实现Implementor接口的对象 2. 示例 2.1 接口 public interface Co

原创 外观模式

1. 类图 2. 示例 封装交互，简化调用 2.1 内部对象 public class CPU { public void start(){System.out.println("cpu启动");} public void shutDown(){System.out.println("cpu关闭");} } public class Disk { public void start(){System.out.println("disk启动");} pu

原创 适配器模式

1. 类图 Target：客户端需要的功能接口 Adaptee：需要被适配的接口 Adapter：适配器，将Adaptee适配成客户端需要的Target Client：客户端，调用功能接口Target 2. 示例 2.1 默认适配器 减少子类重写的方法 2.1.1 接口 // 默认适配接口 public interface DefaultAdapter { public void testOne(); public void testTwo(); publi

原创 装饰器模式

1. 类图 Component：组件对象的接口，可以给这些对象动态地添加职责 ConcreteComponent：具体的组件对象，实现组件对象接口，通常就是被装饰器装饰的原始对象，可以给这个对象添加职责 Decorator：所有装饰器的抽象父类，需要定义一个与组件接口一致，并持有一个Component对象，即被装饰的对象 2. 示例 动态地给一个对象添加一些额外的职责 2.1 组件接口 public interface Person { void eat(); } 2.2 组

原创 代理模式

1. 类图 Proxy：代理对象 Subject：目标接口 RealSubject：具体的目标对象 2. 示例 2.1 静态代理 代理对象持有真实对象的引用，代理类和真实类实现共同的接口 2.1.1 目标接口 public interface Movie { void play(); } 2.1.2 目标对象 public class RealMovie implements Movie { public void play() {System.out.prin

原创 单例模式

1. 类图 Singleton：负责创建Singleton类自己的唯一实例，并提供一个getInstance的方法，让外部来访问这个类的唯一实例 2. 示例 2.1 懒汉式单例 /** * 饿汉式单例：初始化时直接创建 */ public class HungrySingleton { private static HungrySingleton hungrySingleton = new HungrySingleton(); private HungrySingleto

原创 原型模式

1. 类图 Protoype：声明一个克隆自身的接口，用来约束想要克隆自己的类，要求它们都要实现这里定义的克隆方法 ConcretePrototype：实现Prototype接口的类，这些类真正实现了克隆自身的功能 Client：客户端，先获取原型实例对象，然后通过原型实例克隆自身来创建新的对象实例 2. 示例 用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象 浅克隆：只负责克隆按值传递的数据 深克隆：包括浅克隆和引用类型的数据 2.1 原型类 public class

原创 建造者模式

1. 类图 Builder：创造者接口，定义创建一个Product对象所需要的各个部件的操作 ConcreteBuilder：具体的创造者实现，创建各个部件并进行组装，同时还提供一个让用户获取组装完成后的产品对象的方法 Director：指挥者，主要用来使用Builder接口，以一个统一的过程来构建所需要的Product对象 Product：具体产品，包含多个部件 2. 示例 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示 2.1 创建者接口 public

原创 抽象工厂模式

1. 类图 Abstract Factory：抽象工厂，定义创建一系列产品对象的操作接口 Concrete Factory：具体的工厂，定义抽象工厂定义的方法，具体实现一系列产品对象的创建 Abstract Product：定义一类产品对象的接口 Concrete Product：具体的产品实现对象，通常在具体工厂里面，会选择具体的产品实现对象，来创建符合抽象工厂定义的方法返回的产品类型的对象 Client：客户端，使用抽象工厂来获取一系列所需要的的产品对象，然后面向这些产品对象的接口编程，以

原创 工厂方法模式

1. 类图 Product：实际需要使用的对象的接口 ConcreteProduct：具体的Product接口的实现对象 Creator：创建器，多是抽象方法。可以在Creator里面提供工厂方法的默认实现，让工厂方法返回一个缺省的Product类型的实例对象 ConcreteCreator：具体的创建器对象，覆盖实现Creator定义的工厂方法，返回具体的Product实例 2. 示例 通过各自的工厂获取对象 2.1 工厂接口 public interface IFactory

原创 简单工厂模式

1. 类图 ​​ Api：功能接口 ImplA、ImplB：Api接口的实现类 Factory：工厂，选择合适的实现类来创建Api接口对象 Client：客户端，通过Factory获取Api接口对象，然后面向Api接口编程 2. 示例 通过工厂类的静态方法获取对象 2.1 功能接口 public abstract class Operation { Integer numberA; Integer numberB; public void setNum.

原创 设计原则&UML

1. 设计原则 目录 1. 设计原则 1.1 单一职责 1.2 里氏替换 1.3 依赖倒置 1.4 接口隔离 1.5 迪米特原则 1.6 开闭原则 2. 设计模式 2.1 创建型 2.2 结构型 2.3 行为型 3. UML 3.1 类图 3.2 关系 1.1 单一职责 一个类只负责一项职责 问题由来：类T负责两个不同的职责：P1、P2。当P1需求发生变化时，需要修改T类，可能导致P2发生故障 解决方案：将P1、P2放在两个类：T1、T2 1.2 里氏替换 所有引用基