文章目录
- 对象引用
- 强引用
- 软引用（SoftReference）
- 弱引用（WeakReference）
- 考一考
- 虚引用（PhantomReference）
- 总结
- 垃圾回收
- 新生代
- 老年代
- 永生代
- 内存管理小技巧
- 尽量使用直接量
- 使用StringBuilder和StringBuffer进行字符串拼接
- 尽早释放无用对象的引用
- 尽量少用静态变量
- 避免在循环中创建对象
- 缓存经常使用的对象
- 避免使用finalize()方法
- 使用SoftReference
注：本文是对《疯狂Java面试讲义》的小结。
对象引用
Java通过 new 关键字来创建对象实例，JVM会在堆内存中为对象分配空间。当对象失去引用时，JVM的垃圾回收机制会自动清理对象，回收内存空间。
可以把对象的引用关系理解为有向图。如果某个对象在图中处于不可达状态，则认为该对象不再被引用。
Java的对象引用方式有：
- 强引用
- 软引用
- 弱引用
- 虚引用
下面举例说明各种引用方式。
准备：已知类 Person 定义如下：
public class Person {
private String name;
private int age;
......
}
强引用
强引用是最普通、最常见的引用方式。
Person person = new Person("Tom", 20);
强引用的对象，一定不会被JVM回收。
对于强引用，当内存占用过多时，就会出现 OutOfMemoryError 。
Person[] arr1 = new Person[80000];
for (int i = 0; i < arr1.length; i++) {
arr1[i] = new Person("Tom" + i, i % 20);
System.out.println(arr1[i]);
}
正常情况下运行结果OK。为了模拟内存被占满的情况，我们把JVM的内存设置为较低值：
-Xmx8m -Xms8m
如果是在命令行下运行：
java -Xmx8m -Xms8m xxxxxx
如果是IntelliJ IDEA，右键，More Run/Debug -> Modify Run Configuration…：
在弹出的对话框里，点击“Modify options”，在子菜单中确保勾选了“Add VM options”，然后填入 -Xmx8m -Xms8m ：
运行结果如下：
......
Person{name='Tom61694', age=14}
Person{name='Tom61695', age=15}
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at java.base/jdk.internal.misc.Unsafe.allocateUninitializedArray(Unsafe.java:1375)
at java.base/java.lang.StringConcatHelper.newArray(StringConcatHelper.java:494)
......
可见，在创建到大约60000个对象的时候，内存就会溢出。
软引用（SoftReference）
软引用的作用是，当内存空间充足时，它不会被系统回收，但是当内存空间不足时，它就会被系统回收。
软引用的用法如下：
SoftReference<Person> person = new SoftReference<>(new Person("Tom", 20));
......
person.get();
把上面强引用的代码稍作修改，如下：
SoftReference<Person>[] arr1 = new SoftReference[80000];
for (int i = 0; i < arr1.length; i++) {
arr1[i] = new SoftReference<>(new Person("Tom" + i, i % 20));
System.out.println(arr1[i].get());
}
System.out.println(arr1[1].get());
System.out.println(arr1[3].get());
System.out.println(arr1[79999].get());
运行结果如下（别忘了设置JVM内存）：
......
Person{name='Tom79998', age=18}
Person{name='Tom79999', age=19}
null
null
Person{name='Tom79999', age=19}
可见，80000个对象依次创建成功，内存没有溢出，但是创建完毕后，再访问这些对象时，发现前面一部分对象已经变成null了。这是由于在创建后面的对象时，内存不够，触发了垃圾回收，前面的软引用对象被清除了。
多次运行代码，最后一行，有时也会打印出 null ，这说明每次垃圾回收的时机和回收的对象数量是不一定的。
弱引用（WeakReference）
弱引用和软引用类似，区别在于，不管内存是否充足，只要有垃圾回收，弱引用对象就会被回收。
弱引用的用法如下：
WeakReference<Person> person = new WeakReference<>(new Person("Tom", 20));
System.out.println(person.get());
System.gc();
System.runFinalization();
System.out.println(person.get());
运行结果如下（无需设置JVM内存）：
Person{name='Tom', age=20}
null
可见，垃圾回收时，弱引用对象被回收了。
与 WeakReference 功能类似的还有 WeakHashMap 。
对于map里的key值，如果其对象是弱引用，则在垃圾回收时，会把该对象回收，并把该key值从map里移除。
WeakHashMap<Person, String> map = new WeakHashMap<>();
map.put(new Person("Tom", 20), "aaa");
map.put(new Person("Jerry", 30), "bbb");
System.out.println(map);
System.gc();
System.runFinalization();
System.out.println(map);
运行结果如下：
{Person{name='Jerry', age=30}=bbb, Person{name='Tom', age=20}=aaa}
{}
考一考
下面的代码，运行结果是什么？
WeakHashMap<Person, String> map = new WeakHashMap<>();
Person person1 = new Person("Tom", 20);
map.put(person1, "aaa");
// person1 = null;
Person person2 = new Person("Jerry", 30);
map.put(person2, "bbb");
// person2 = null;
System.out.println(map);
System.gc();
System.runFinalization();
System.out.println(map);
乍一看，似乎跟前一个例子没什么太大区别，但运行结果是不同的：
{Person{name='Jerry', age=30}=bbb, Person{name='Tom', age=20}=aaa}
{Person{name='Jerry', age=30}=bbb, Person{name='Tom', age=20}=aaa}
这两个key对象为什么没有被回收掉呢？其实原因很简单，因为person1和person2还在引用它们。这是强引用，所以不会被垃圾回收。要想被垃圾回收，只需解除强引用（参见被注释掉的那两行代码）。
虚引用（PhantomReference）
虚引用的主要作用是跟踪对象被垃圾回收的状态。
虚引用不能单独使用，必须和引用队列（ReferenceQueue）一起使用。引用队列保存了被回收后对象的引用。它和软引用、弱引用等联合使用，这些对象被回收时，会把引用添加到相关联的引用队列中。
ReferenceQueue<Person> queue = new ReferenceQueue<>();
PhantomReference<Person> phantomReference = new PhantomReference<>(new Person("Tom", 20), queue);
// 虚引用的 get() 方法总是返回null
System.out.println(phantomReference.get());
// 还没做垃圾回收，所以队列为空
System.out.println(queue.poll());
System.gc();
System.runFinalization();
// 垃圾回收后，虚引用对象在队列中
System.out.println(queue.poll());
运行结果如下：
null
null
java.lang.ref.PhantomReference@36baf30c
既然虚引用都get不到实际对象，那它到底有什么用呢？
看起来，虚引用的用处，就是会触发一个事件。我们可以另起一个线程，对队列进行监听，比如：
remove()：阻塞方法poll()：非阻塞方法
这样，当对象被回收时，我们就会得到通知，做相应的处理（比如清理资源）。
总结
| 强引用 | 软引用 | 弱引用 | |
|---|---|---|---|
| 垃圾回收时，不会被回收 | Y | N | N |
| 垃圾回收时，若内存不足，就会被回收 | N | Y | Y |
| 只要有垃圾回收，就会被回收 | N | N | Y |
垃圾回收
垃圾回收机制主要做两件事：
- 跟踪每个Java对象的可达状态，回收不可达对象的内存
- 清理分配和回收过程中产生的内存碎片
垃圾回收的设计思想：
- 串行和并行：使用单CPU还是多CPU来做回收
- 并发和停止（stop-the-world）：回收时，应用是否暂停
- 紧凑和不紧凑：如果只是回收对象，则内存可能会产生很多碎片。把所有活着的对象复制到一起，可以避免内存碎片
回收方式：
- 复制：把内存分成两个相同的空间A和B，以A空间为例，从根开始，把每个可达对象复制到B空间，最后把整个A空间重置
- 标记清除（mark-sweep）：从根开始，标记每个可达对象，最后回收所有没有标记可达的对象
- 标记清除紧凑（mark-sweep-compact）：从根开始，标记每个可达对象，最后把所有活着的对象搬迁在一起，并回收其它内存空间
分代内存：
- 新生代（Young）：大部分对象存活时间不会很长，处于新生代
- 老年代（Old）：少量对象存活时间很长，处于老年代
- 永生代（Permanent）：主要用于存放Class对象，方法等信息
新生代
新生代又分为Eden（伊甸园）区和Survivor区。
绝大部分对象先分配到Eden区，而Survivor区的对象至少熬过一次垃圾回收。
Survivor区又分为From区和To区，参见上面提到的“复制”回收方式。
垃圾回收时，将Eden区和From区的可达对象复制到To区，然后清空Eden区和From区，最后把From和To互换一下。
老年代
如果一个对象熬过了数次垃圾回收，就可能会被转入老年代。
老年代的垃圾回收频率无需太高，因为老年代的对象都很能熬。
- 次要回收：新生代的垃圾回收，频率较高
- 主要回收：新生代和老年代的垃圾回收，频率较低
老年代的垃圾回收通常采用标记清除紧凑算法。
永生代
主要用于存放Class对象，方法等信息，默认为64MB。
内存管理小技巧
尽量使用直接量
String str1 = "hello"; // 在字符串缓存池里缓存了hello字符串
String str2 = new String("hello"); //同上，此外还多创建了一个char[]数组
使用StringBuilder和StringBuffer进行字符串拼接
String字符串是不可变的，如果直接对字符串拼接，将产生大量的临时字符串。
String str1 = "hello";
String str2 = "world";
String str3 = "!!!";
String result1 = str1 + str2 + str3; // 产生大量的临时字符串
System.out.println(result1);
StringBuilder result2 = new StringBuilder();
result2.append(str1);
result2.append(str2);
result2.append(str3);
System.out.println(result2.toString());
StringBuffer result3 = new StringBuffer();
result3.append(str1);
result3.append(str2);
result3.append(str3);
System.out.println(result3.toString());
尽早释放无用对象的引用
Person person = new Person("Tom", 20);
person.doSomething();
// person = null;
......
本例中，创建并使用完person对象后，最好将其释放（参见注释处代码），否则，person变量在其作用域范围内，会一直持有对象引用，导致对象无法被系统回收。
尽量少用静态变量
class A {
static B b = new B();
}
本例中，b是A类的静态变量，其生命周期与A类一致（存入永生代）。
避免在循环中创建对象
for (int i = 0; i < 100; i++) {
Person person = new Person("Tom", 20);
......
}
创建了100个Person对象，它们的生存时间都很短。系统需要不断的分配和回收内存。
缓存经常使用的对象
典型的例子是数据库连接池。
避免使用finalize()方法
垃圾回收的工作量已经很大了，尤其是新生代，对象很多，回收频繁，若再使用finalize()方法清理资源，更加重了垃圾回收的负担。
使用SoftReference
参见前面的介绍。
注意SoftReference和WeakReference的不确定性，在使用对象时，应检查其是否为空。
