设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

理解Java垃圾回收

2016-8-29 13:50| 发布者: zhangjf| 查看: 658| 评论: 0

摘要: 当程序创建对象、数组等引用类型的实体时，系统会在堆内存中为这一对象分配一块内存，对象就保存在这块内存中，当这块内存不再被任何引用变量引用时，这块内存就变成垃圾，等待垃圾回收机制进行回收。垃圾回收机制具 ...

当程序创建对象、数组等引用类型的实体时，系统会在堆内存中为这一对象分配一块内存，对象就保存在这块内存中，当这块内存不再被任何引用变量引用时，这块内存就变成垃圾，等待垃圾回收机制进行回收。垃圾回收机制具有三个特征：

垃圾回收机制只负责回收堆内存中的对象，不会回收任何物理资源（例如数据库连接，打开的文件资源等），也不会回收以某种创建对象的方式以外的方式为该对像分配的内存，（例如对象调用本地方法中malloc的方式申请的内存）
程序无法精确控制垃圾回收的运行，只可以建议垃圾回收进行，建议的方式有两种System.gc() 和Runtime.getRuntime().gc()
在垃圾回收任何对象之前，总会先调用它的finalize()方法，但是同垃圾回收的时机一致，调用finalize()方法的时机也不确定。
针对以上三个特征，有三个问题：

1、必须手动的进行清理工作，释放除创建对象的方式以外的方式分配的内存和其它的物理资源。并且要注意消除过期的对象引用，否则可能引起OOM。

手动清理通常用到try...finally...这样的代码结构。

示例如下：

  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4. import java.io.IOException;
  6. public class ManualClear {
  8. public static void main(String[] args) {
  9. FileInputStream fileInputStream = null;
  10. try {
  11. fileInputStream = new FileInputStream("./src/ManualClear.java");
  12. } catch (FileNotFoundException e) {
  13. System.out.println(e.getMessage());
  14. e.printStackTrace();
  15. return;
  16. }
  18. try {
  19. byte[] bbuf = new byte[1024];
  20. int hasRead = 0;
  21. try {
  22. while ((hasRead = fileInputStream.read(bbuf)) > 0) {
  23. System.out.println(new String(bbuf, 0, hasRead));
  24. }
  25. } catch (IOException e) {
  26. e.printStackTrace();
  27. }
  28. } finally {
  29. try {
  30. fileInputStream.close();
  31. } catch (IOException e) {
  32. e.printStackTrace();
  33. }
  34. }
  35. }
  37. }
复制代码

对于过期对象的引用，引起的OOM通常有三种常见的情况，这三种情况通常都不易发现，短时间内运行也不会有什么问题，但是时间久了后，泄漏的对象增加后终会引起程序崩溃。

类自己管理内存时，要警惕内存泄漏
示例如下：

  2. import java.util.Arrays;
  3. import java.util.EmptyStackException;
  5. class Stack{
  6. private Object[] elements;
  7. private int size;
  8. private static final int DEFAULT_INITAL_CAPACITY = 16;
  10. public Stack() {
  11. elements = new Object[DEFAULT_INITAL_CAPACITY];
  12. }
  14. public void push(Object e){
  15. ensureCapacity();
  16. elements[size++] = e;
  17. }
  19. public Object pop() {
  20. if (size == 0) {
  21. throw new EmptyStackException();
  22. }
  24. return elements[--size];
  25. }
  27. private void ensureCapacity() {
  28. if (elements.length == size) {
  29. elements = Arrays.copyOf(elements, 2 * size + 1);
  30. }
  31. }
  32. }
  34. public class StackDemo {
  36. public static void main(String[] args) {
  37. Stack stack = new Stack();
  39. for (int i = 0; i < 10000; i++) {
  40. stack.push(new Object());
  41. }
  43. for(int i = 0; i < 10000; i++) {
  44. stack.pop();
  45. }
  46. }
  48. }
复制代码

之所以会内存泄漏，是因为那些出栈的对象即使程序其它对象不再引用，但是Stack类中的elements[]数组依然保存着这些对象的引用，导致这些对象不会被垃圾回收所回收，所以，当需要类自己管理内存事，要警惕内部维护的这些过期引用是否被及时解除了引用，本例中只需在出栈后，显示的将

elements[size] = null;即可。

缓存是要警惕内存泄漏
出现这样情况通常是一旦将对象放入缓存，很可能长时间不使用很容易遗忘，通常可以用WakeHashMap代表缓存，在缓存中的项过期后，他们可以被自动删除。或者可以由一个后台线程定期执行来清除缓冲中的过期项。

监听器或回调的注册，最好可以显示的取消注册。
2、不要手动调用finalize()，它是给垃圾回收器调用的

3、避免使用finalize()方法，除非用来作为判断终结条件以发现对象中没有被适当清理的部分；用来作为安全网在手动清理忘记调用的情况下清理系统资源，延后清理总别永不清理要强，并且如果同时记录下忘记清理资源的信息的话，也方便后面发现错误，并及时修改忘记清理的代码；释放对象中本地方法获得的不是很关键的系统资源。

finalize()方法由于其执行时间以及是否确定被执行都不能准确确保，所以最好不用来释放关键资源，但是可用于上面所说的三种情况。其中第一种情况，示例如下：

  2. class Book {
  3. boolean checkout = false;
  4. public Book(boolean checkout) {
  5. this.checkout = checkout;
  6. }
  8. public void checkin(){
  9. checkout = false;
  10. }
  12. @Override
  13. protected void finalize() throws Throwable {
  14. if (checkout) {
  15. System.out.println("Error: check out");
  16. }
  17. }
  18. }
  20. public class FinalizeCheckObjectUse {
  22. public static void main(String[] args) {
  23. new Book(true);
  24. System.gc();
  25. }
  27. }
复制代码

执行结果：

Error: check out
例子中的Book对象，在释放前必须处于checkIn的状态，否则不能释放，finalize中的实现可以帮助及时发现不合法的对象，或者更直接的，在finalize中直接使用某个引用变量引用，使其重新进入reachable的状态，然后再次对其进行处理。

另一点需要注意的时，子类如果覆盖了父类的finalize方法，但是忘了手工调用super.finalize或者子类的finalize过程出现异常导致没有执行到super.finalize时，那么父类的终结方法将永远不会调到。

如下：

  2. class Parent{
  3. @Override
  4. protected void finalize() throws Throwable {
  5. System.out.println(getClass().getName() + " finalize start");
  6. }
  7. }
  9. class Son extends Parent{
  10. @Override
  11. protected void finalize() throws Throwable {
  12. System.out.println(getClass().getName() + " finalize start");
  13. }
  14. }
  15. public class SuperFinalizeLost {
  17. public static void main(String[] args) {
  18. new Son();
  19. System.gc();
  20. }
  22. }
复制代码

运行结果：

Son finalize start
或者

  2. class Parent{
  3. @Override
  4. protected void finalize() throws Throwable {
  5. System.out.println(getClass().getName() + " finalize start");
  6. }
  7. }
  9. class Son extends Parent{
  10. @Override
  11. protected void finalize() throws Throwable {
  12. System.out.println(getClass().getName() + " finalize start");
  13. int i = 5 / 0;
  14. super.finalize();
  15. }
  16. }
  17. public class SuperFinalizeLost {
  19. public static void main(String[] args) {
  20. new Son();
  21. System.gc();
  22. }
  24. }
复制代码

执行结果：

Son finalize start
对于第二种情况，可以使用try...finally...结构解决，但是对于第一种情况，最好使用一种叫终结方法守护者的方式。示例如下

  2. class Parent2{
  3. private final Object finalizeGuardian = new Object() {
  4. protected void finalize() throws Throwable {
  5. System.out.println("在此执行父类终结方法中的逻辑");
  6. };
  7. };
  8. }
  10. class Son2 extends Parent2{
  11. @Override
  12. protected void finalize() throws Throwable {
  13. System.out.println(getClass().getName() + " finalize start");
  14. int i = 5 / 0;
  15. super.finalize();
  16. }
  17. }
  19. public class FinalizeGuardian {
  21. public static void main(String[] args) {
  22. new Son2();
  23. System.gc();
  24. }
  26. }
复制代码

执行结果：

在此执行父类终结方法中的逻辑
Son2 finalize start
这样可以保证父类的终结方法中所需做的操作执行到。

以上就是本文的全部内容，希望对大家的学习有所帮助。

收藏 邀请
上一篇：详解Java实现多线程的三种方式下一篇：Hibernate批量处理海量数据的方法

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-7 08:08

Copyright 2015-2025 djqfx

返回顶部