本文参考

本篇文章参考自《Effective Java》第三版第七条"Eliminate obsolete object references"

Memory leaks in garbage-collected languages (more properly known as unintentional object retentions) are insidious

在具备垃圾回收器的语言中,内存泄漏(或称无意识对象保留)往往十分隐蔽,看下面一个自定义栈程序的例子

public class Stack {

  private Object[] elements;

  private int size = 0;

  private static final int DEFAULT_INITIAL_CAPACITY = 16;

  public Stack() {

    elements = new Object[DEFAULT_INITIAL_CAPACITY];
  }

  public void push(Object e) {

    ensureCapacity();

    elements[size++] = e;
  }

  public Object pop() {

    if (size == 0) {

      throw new EmptyStackException();
    }

    return elements[--size];
  }

  /**
   * Ensure space for at least one more element, roughly
   * doubling the capacity each time the array needs to grow.
   */

  private void
ensureCapacity() {

    if (elements.length == size) {

      elements = Arrays.copyOf(elements, 2 * size + 1);
    }
  }
}

尽管能够实现我们需要的LIFO的功能,但是在栈指针size先增长再收缩的情况下,栈的内部却始终保留着下标大于size的过期引用(obsolete references),过期引用不会被GC识别并进行回收,而实际上,我们只需要保留下标小于size 的活动部分(active portion)

注意,过期引用和活动部分只是我们自己定义的概念,GC是无法辨认的,只有我们知道过期引用是不重要的部分,所以Stack类的内存也就需要手动进行管理

我们可以看Java自己的Stack类是如何应对垃圾回收的

public synchronized E pop() {

  E obj;

  int len = size();

  obj = peek();

  removeElementAt(len - 1);

  return obj;
}

peek()方法只是读取了栈顶的元素,主要是在removeElementAt()方法

public synchronized void removeElementAt(int index) {

  modCount++;

  if (index >= elementCount) {

    throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
  }

  else if (index < 0) {

    throw new ArrayIndexOutOfBoundsException(index);
  }

  int j = elementCount - index - 1;

  if (j > 0) {

    System.arraycopy(elementData, index + 1, elementData, index, j);
  }

  elementCount--;

  elementData[elementCount] = null; /* to let gc do its work */
}

可以看到最后一行代码elementData[elementCount] = null将栈顶的元素设置为null,这样就能清空过期引用,让GC自动清理"堆"上的内存空间

Nulling out object references should be the exception rather than the norm

清空对象引用应该是一种例外而不是规范,因为在程序运行到超过某些引用的作用域(或生命周期)后,引用会被自动清除

The best way to eliminate an obsolete reference is to let the variable that contained the reference fall out of scope. This occurs naturally if you define each variable in the narrowest possible scope

上述的自定义栈就是一种例外,需要Stack类自己管理内存

Another common source of memory leaks is caches

为了防止我们遗忘缓存中的引用的清理,第一种解决方案是使用WeakHashMap,WeakHashMap含有一个继承了WeakReference弱引用类的Entry静态内部类,当某个键不再被正常使用时,该键会从WeakHashMap中被自动移除。更精确地说,对于一个给定的键,其映射的存在并不阻止垃圾回收器对该键的丢弃

Hash table based implementation of the Map interface, with weak keys. An entry in a WeakHashMap will automatically be removed when its key is no longer in ordinary use. More precisely, the presence of a mapping for a given key will not prevent the key from being discarded by the garbage collector, that is, made finalizable, finalized, and then reclaimed. When a key has been discarded its entry is effectively removed from the map

注意,只被弱引用指向的对象只能存活到下一次 JVM 执行垃圾回收动作之前,即JVM的每一次垃圾回收动作都会回收那些只被弱引用指向的对象

因此只要在缓存之外存在对某个项的键的引用(如强引用和软引用),该项就有意义,那么就可以用 WeakHashMap 代表缓存,当缓存中的项不再被引用(或称过期)之后,它们就会自动被GC删除

有关WeakHashMap的介绍可以参考这篇博文:https://blog.csdn.net/u014294681/article/details/86522487

另一种解决方案是使用LinkedHashMap,他的removeEldestEntry()方法会在插入新映射时被调用,用来移除旧的映射

This method is invoked by put and putAll after inserting a new entry into the map. It provides the implementor with the opportunity to remove the eldest entry each time a new one is added. This is useful if the map represents a cache: it allows the map to reduce memory consumption by deleting stale entries.

A third common source of memory leaks is listeners and other callbacks

如果你实现了一个 API,客户端在这个API中注册回调,却没有显式地取消注册,那么除非你采取某些动作,否则它们就会不断地堆积起来。确保回调立即被当作垃圾回收的最佳方法是只保存它们的弱引用(weak reference),例如,只将它们保存成 WeakHashMap 中的键

下面代码参考自stack overflow上的回答:https://stackoverflow.com/questions/2859464/how-to-avoid-memory-leaks-in-callback

public interface ChangeHandler {

  void handleChange();
}

public class FileMonitor {

  private File file;

  private Set<ChangeHandler> handlers = new HashSet<ChangeHandler>();
  // private WeakHashMap<ChangeHandler, ?> weakHandler = new WeakHashMap<>();

  public
FileMonitor(File file) {

    this.file = file;
  }

  public void registerChangeHandler(ChangeHandler handler) {

    this.handlers.add(handler);
  }

  public void unregisterChangeHandler(ChangeHandler handler) {

    this.handlers.remove(handler);
  }
}

public class MyClass {

  File myFile = new File("somewhere");

  FileMonitor monitor = new FileMonitor(myFile);

  public void something() {

    // do something ...
    // strong reference declaration
    // the reference will be expired after the scope of something() method ended

    ChangeHandler
myHandler = getChangeHandler();

    monitor.registerChangeHandler(myHandler);

    // if MyClass forgets to call unregisterChangeHandler() when it's done with the handler,
    // the FileMonitor's HashSet will forever reference the instance that was registered,
    // causing it to remain in memory until the FileMonitor is destroyed or the application quits.
    // do something ...

  }

  private ChangeHandler getChangeHandler() {

    return new ChangeHandler() {

      @Override

      public void handleChange() {

        // do something ...

      }
    };
  }
}

Effective Java —— 消除过期的对象引用的更多相关文章

  1. Java 消除过期的对象引用

    内存泄漏的第一个常见来源是存在过期引用. import java.util.Arrays; import java.util.EmptyStackException; public class Sta ...

  2. Effective Java 第三版——7. 消除过期的对象引用

    Tips <Effective Java, Third Edition>一书英文版已经出版,这本书的第二版想必很多人都读过,号称Java四大名著之一,不过第二版2009年出版,到现在已经将 ...

  3. 《Effective Java》 读书笔记(七)消除过期的对象引用

    大概看了一遍这个小节,其实这种感觉体验最多的应该是C/C++程序,有多杀少个new就得有多个delete. 一直以为Java就不会存在这个问题,看来是我太年轻. 感觉<Effective Jav ...

  4. Effective Java (6) - 消除过期的对象引用

    一.引言 很多人可能在想这么一个问题:Java有垃圾回收机制,那么还存在内存泄露吗?答案是肯定的,所谓的垃圾回收GC会自动管理内存的回收,而不需要程序员每次都手动释放内存,但是如果存在大量的临时对象在 ...

  5. Effective Java 之-----消除过期的对象引用

    public class Stack { private Object[] elements; private int size = 0; private static final int DEFAU ...

  6. Item 6 消除过期的对象引用

    过期对象引用没有清理掉,会导致内存泄漏.对于没有用到的对象引用,可以置空,这是一种做法.而最好的做法是,把保存对象引用的变量清理掉,多用局部变量.   什么是内存泄漏? 在Java中,对象的内存空间回 ...

  7. 《Effective java》-----读书笔记

    2015年进步很小,看的书也不是很多,感觉自己都要废了,2016是沉淀的一年,在这一年中要不断学习.看书,努力提升自己!预计在2016年要看12本书,主要涉及java基础.Spring研究.java并 ...

  8. Effective Java笔记一 创建和销毁对象

    Effective Java笔记一 创建和销毁对象 第1条 考虑用静态工厂方法代替构造器 第2条 遇到多个构造器参数时要考虑用构建器 第3条 用私有构造器或者枚举类型强化Singleton属性 第4条 ...

  9. Effective java读书笔记

    2015年进步很小,看的书也不是很多,感觉自己都要废了,2016是沉淀的一年,在这一年中要不断学习.看书,努力提升自己 计在16年要看12本书,主要涉及java基础.Spring研究.java并发.J ...

随机推荐

  1. golang线程安全

    目录 1.golang的map是线程安全的吗?怎么安全使用map 2.线程独享什么,共享什么 3.进程状态转换 4.Log包线程安全吗? 5.写的循环队列是不是线程安全? 6.go协程线程安全吗 7. ...

  2. Html简单标签

    学习html <h1> 标题标签</h1> 标题标签 <p>段落标签</p> 段落标签 换行标签</br> 换行标签 水平线标签</h ...

  3. 【C#单元测试】 开篇

    官方:https://docs.microsoft.com/zh-cn/visualstudio/test/install-third-party-unit-test-frameworks?view= ...

  4. 常见三种存储方式DAS、NAS、SAN的架构及比较

    转至:https://blog.csdn.net/shipeng1022/article/details/72862367 随着主机.磁盘.网络等技术的发展,数据存储的方式和架构也在一直不停改变,本文 ...

  5. java 执行shell命令遇到的坑

    正常来说java调用shell命令就是用 String[] cmdAry = new String[]{"/bin/bash","-c",cmd} Runtim ...

  6. VUE3 之 使用标签实现动画与过渡效果(下) - 这个系列的教程通俗易懂,适合新手

    1. 概述 毛毛虫效应: 有这样一个实验,将许多毛毛虫放在一个花盆边缘,使它们首尾相接,围成一个圈.然后在离花盆很近的地方撒了一些毛毛虫的食物. 此时,毛毛虫并不会向食物的方向爬去,而是在花盆边缘,一 ...

  7. 从零开始Pytorch-YOLOv3【笔记】(一)配置文件解读

    前言 这是github上的一个项目YOLO_v3_tutorial_from_scratch,它还有相应的blog对其详细的解读.机器之心翻译了他的tutorial:从零开始PyTorch项目:YOL ...

  8. 《前端运维》一、Linux基础--09常用软件安装

    一.软件包管理 RPM是RedHat Package Manager(RedHat软件包管理工具)类似Windows里面的"添加/删除程序".软件包有几种类型,我们一起来看下: 源 ...

  9. MariaDB开启日志审计功能

    对于MySQL.Percona.MariaDB三家都有自己的审计插件,但是MySQL的审计插件是只有企业版才有的,同时也有很多第三方的的MySQL的审计插件,而Percona和MariaDB都是GPL ...

  10. Oracle视图、存过、包、方法赋予/收回权限给用户

    oracle给某用户授权/回收视图查询 赋权: grant select on $_view to $_user; 这样 $_user用户就拥有了查询$_view视图的权限了 回收: revoke s ...