内存分配与回收策略

1. 对象优先在Eden分配
2. 大对象直接进入老年代
   • -XX:PretenureSizeThreshold大于这个设置值的对象直接在老年代分配，此参数支队Serial和ParNew两款收集器有效
3. 长期存活的对象经进入老年代
   • -XX:MaxTenuringThreshold经历多少次MinorGC进入老年代
4. 动态对象年龄判定
5. 空间分配担保

垃圾回收器

Serial收集器

1. 概念：单线程收集器，在进行垃圾收集时会暂停其他所有的工作线程，直到收集结束。
2. 优点：简单高效
3. 适用区域：新生代

ParNew收集器

1. 概念：Serial收集器的多线程版本
2. 可用参数：
   • -XX:SurvivorRatio
   • -XX:PretenureSizeThreshold
   • -XX:HandlePromotionFailure
3. 适用：新生代收集器，只能与CMS收集器配合适用

Parallel Scavenge收集器

1. 概念：使用复制算法并行的多线程收集器
2. 特点：关注于达到一个可控制的吞吐量，吞吐量=运行用户代码时间/（运行用户代码时间+垃圾收集时间）
3. 可用参数：
   • -XX:GCTimeRatio
   • -XX:MaxGCPauseMillis
   • -XX:UseAdaptiveSizePolicy
4. 适用：新生代

Serial Old收集器

1. 概念：使用标记-整理算法的单线程收集器
2. 用途：
   • 与Parallel Scavenge配合适用
   • 作为CMS收集器的后备预案
3. 适用：老年代

Parallel Old收集器

1. Parallel Scavenge收集器的老年代版本，使用多线程和标记-整理算法。
2. 适用：在注重吞吐量及CPU资源敏感的场合，优先考虑Parallel Scavenge加Parallel Old收集器。

CMS收集器

1. 概念：一种以获取最短回收停顿时间为目标的收集器，使用标记-清除算法
2. 收集过程：
   • 初始标记：Stop the World,标记GC Roots能直接关联到的对象
   • 并发标记：GC Roots Tracing
   • 重新标记：修正并发标记阶段产生变化的标记记录
   • 并发清除
3. 缺点：
   • 对CPU资源敏感
   • 无法处理浮动垃圾
   • 产生大量的空间碎片
4. 可用参数：
   • -XX:UseCMSCompactAtFullCollection
   • -XX:CMSFullGCsBeforeCompaction

G1收集器

未完待续。

垃圾判断算法

引用计算法

1. 概念：给对象添加一个引用计算器，每当有一个地方引用它时，计算器就加1；当引用失效时，计算器值就减1；当计数器值为0时视为失效。
2. 缺陷：很难解决对象之间的相互循环引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class ReferenceCountingGC {

    public Object instance = null;

    private static final int _1MB = 1024 * 1024;

    private byte[] bigSize = new byte[2 * _1MB];

    public void test() {

        ReferenceCountingGC referenceCountingGC_A = new ReferenceCountingGC();
        ReferenceCountingGC referenceCountingGC_B = new ReferenceCountingGC();

        referenceCountingGC_A.instance = referenceCountingGC_B;
        referenceCountingGC_B.instance = referenceCountingGC_A;

        referenceCountingGC_A = null;
        referenceCountingGC_B = null;

        System.gc();
    }

    public static void main(String[] args) {
        ReferenceCountingGC referenceCountingGC = new ReferenceCountingGC();
        referenceCountingGC.test();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

CommandLine flags: -XX:InitialHeapSize=134217728 -XX:MaxHeapSize=2147483648 -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseParallelGC 
0.269: [GC (System.gc()) [PSYoungGen: 9519K->2880K(38400K)] 9519K->2888K(125952K), 0.0028893 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.272: [Full GC (System.gc()) [PSYoungGen: 2880K->0K(38400K)] [ParOldGen: 8K->2766K(87552K)] 2888K->2766K(125952K), [Metaspace: 3310K->3310K(1056768K)], 0.0043064 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
Heap
 PSYoungGen      total 38400K, used 333K [0x0000000795580000, 0x0000000798000000, 0x00000007c0000000)
  eden space 33280K, 1% used [0x0000000795580000,0x00000007955d34a8,0x0000000797600000)
  from space 5120K, 0% used [0x0000000797600000,0x0000000797600000,0x0000000797b00000)
  to   space 5120K, 0% used [0x0000000797b00000,0x0000000797b00000,0x0000000798000000)
 ParOldGen       total 87552K, used 2766K [0x0000000740000000, 0x0000000745580000, 0x0000000795580000)
  object space 87552K, 3% used [0x0000000740000000,0x00000007402b3890,0x0000000745580000)
 Metaspace       used 3318K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 365K, capacity 388K, committed 512K, reserved 1048576K

从GC日志看，对象由PSYoungGen转移至ParOldGen中。

根搜索算法

1. 概念：通过一系列名为GC Roots的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连时，则此对象视为不可用。
2. 可被视为GC Roots的对象
   • 虚拟机栈（栈帧中的本地变量表）中引用的对象
   • 方法区中的类静态属性引用的对象
   • 方法区中的常量引用的对象
   • 本地方法栈中Native方法引用的对象

引用分级

• 强引用（Strong Reference）：永远不会回收
• 软引用（Soft Reference）：在内存溢出前回收
• 弱引用（Weak Reference）：垃圾收集时回收
• 虚引用（Phantom Reference）：无影响，用于系统通知

垃圾收集算法

标记-清除算法

1. 概念：首先标记出所有需要回收的对象，在标记完成后统一回收掉所有被标记的对象。
2. 缺点：
   • 效率问题：标记和清除过程的效率都不高
   • 空间问题：标记清除后会产生不连续内存碎片，当有对象需要分配时可能会导致非必要垃圾收集。

复制算法

1. 概念：将可用内存按容量分成大小相同两块，当其中一块内存用完了，就将存活着的对象复制到另一块上面，再清理已经用完的内存空间。
2. 优点：无内存碎片，运行高效
3. 缺点：将可用内存缩减为原内存一半
4. 改进：在回收新生代时，设置一块Eden区和两块Survivor区，每次使用Eden和其中一块Survivor，回收时将存活的对象拷贝到另一块Survivor上，当Survivor区不够时，需要依赖其他内存（老年代）进行分配担保。Hotspot默认Eden:Survivor=8:1

标记-整理算法

​ 标记整理算法与标记—>清除算法的不同在于增加一步整理的过程：标记—>整理—>清除

分代收集算法

1. 概念：根据对象的存活周期的不同将内存划分为几块。
2. 分代：一般分为年轻代，老年代，永久代，对不同的分区采用不同的垃圾回收算法，提高效率

前言

​ 为了研究一下bitcoin的原理，为自己用java实现区块链作准备。

C++语法

引言

机器学习可以创造未来，拥抱变化吧。