《Effective Java》第6条：消除过时的对象引用

原文地址： itweknow.cn/detail?id=6… ，欢迎你们访问。

说到Java，大概不少人都知道GC。Java有自动的垃圾回收机制，固然了，在这篇文章里面就不去深究GC的具体实现了。那么之后了垃圾自动回收，咱们是否是就在也不用担忧内存泄露的问题了呢。这种问题的答案通常来说都是否认的。那么这篇文章咱们就一块儿来跟着《Effective Java》来了解一下这个问题。

过时引用

书中首先提到的就是因为过时引用而致使的内存泄露，举了一个Stack的例子：

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];
    }

    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}
复制代码

根据书中的描述，咱们在这个例子中咱们是本身管理内存，垃圾回收器并不清楚element中不活跃的部分能够被回收，解决这个问题的方式就是咱们经过手动清空这些元素来告诉垃圾回收期它们能够被回收了。

public Object pop() {
    if (size == 0) {
        throw new EmptyStackException();
    }
    Object obj = elements[--size];
    elements[size] = null;
    return obj;
}
复制代码

我尝试了使用以下的代码，测试了上面有问题的代码

public class Main {

    public static void main(String[] args) throws InterruptedException {
        Stack stack = new Stack();
        for (long i=0; i<Long.MAX_VALUE; i++) {
            doSomething(stack);
        }
    }
    private static void doSomething(Stack stack) {
        for (int i=0; i<5; i++) {
            stack.push(new User(1, "itweknow.cn"));
        }
        for (int i=0; i<5; i++) {
            stack.pop();
        }
    }
}
复制代码

惋惜并无测出来内存溢出的错误，在这里要感谢https://bbs.csdn.net/topics/391991081这个帖子给了我答案，有兴趣的同窗能够去看一下。再仔细看了一下书中的描述是随着内存占用的不断增长，程序的性能的下降会逐渐表现出来。 在极端的状况下可能会致使内存溢出。
这么看来，通常状况下Stack并不会致使内存溢出，可是因为失效的元素并不能及时的被GC回收，因此在内存接近零界值的时候会极大的影响程序的性能，因此应该尽可能避免本身管理内存。

内存的另外一个泄露来源-缓存

事实上，若是咱们将引用对象放在缓存中，很容易被遗忘，随着缓存的积累很大几率会出现溢出的可能。比方来说下面这段代码运行一下就会出现异常。不过如今的电脑广泛的配置都比较高，因此在运行的时候我设置了一下JVM参数。

public class Question {
    /** * 假如咱们如今有一个需求，须要在java内存中缓存发送给用户的短信验证码 * 这里使用HashMap来存储，测试当缓存达到1000000的时候是否会发生内存泄露。 * 启动时设置最大堆内存为10M * @param args */
    public static void main(String[] args) throws InterruptedException {
        HashMap<Integer, String> codeCache = new HashMap<Integer, String>();
        // 方便起见，使用固定验证码。
        String code = "000000";
        for (int i=0; i<1000000; i++) {
            codeCache.put(i, code);
            Thread.sleep(1);
        }
    }
}
复制代码

监听器和其余回调

在看这条以前我对监听器和回调接触的并非不少，因此此次决定研究一拨监听器却是是啥。
其实监听器和回调能够算是一种异步调用的方式。假设咱们如今有一个提问者有一个问题1+1=?须要问回答者，而后可能回答者计算这个提问须要一段时间。 为了在单位时间内提问者可以干更多的事儿，那么咱们会在提问者类里实现一个回调接口，而且回答者在问题计算完成的时候调用这个回调方法来告知提问者答案。那么监听其实也相似，在咱们实际工做中，特别是前端接触的可能比较多，好比说按钮的点击事件的监听，给按钮设置一个监听器，而后当有点击事件产生时， 监听器会调用相应的回调方法进而作相应的处理。下面是咱们这个假设的代码实现：

• 回调接口

/** * @author ganchaoyang * @date 2018/11/15 17:45 * @description 回调接口 */
public interface CallBack {

    /** * 知道答案的回调接口 * @param result */
    public void solve(String result);

}
复制代码

• 提问者

public class Questioner implements CallBack{

    /** * 提问者的姓名 */
    private String name;

    /** * 持有一个问题回答者，由于须要知道向谁提问 */
    private Author author;

    public Questioner(String name) {
        this.name = name;
    }

    /** * 设置提问者，至关于设置监听器 * @return */
    public Questioner setAuthor(Author author) {
        this.author = author;
        return this;
    }

    public void doRequest() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                author.execRequest(Questioner.this, "question");
            }
        }).start();
        // 问题问了以后，去作其余事情。
        doOtherThings();
    }

    private void doOtherThings() {
        System.out.println("do other things...");
    }

    /** * 回答者知道答案后会经过这个方法来告知提问者答案 * @param result */
    @Override
    public void solve(String result) {
        System.out.println(author.getName() + "告诉" + getName()
                + "答案是：" + result);
    }

    public String getName() {
        return name;
    }

    public Questioner setName(String name) {
        this.name = name;
        return this;
    }
}
复制代码

• 回答者

public class Author {

    private String name;

    public Author(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public Author setName(String name) {
        this.name = name;
        return this;
    }

    /** * 处理问题 * @param callBack * @param qeustion */
    public void execRequest(CallBack callBack, String qeustion) {
        // 有一个等待，模拟处理过程。
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 获得答案，调用提问者的回调方法。
        callBack.solve("solved");
    }
}
复制代码

• 调用方式

public class Main {

    public static void main(String[] args) throws InterruptedException {
        // 假设如今有10000个提问者，10000个回答者，提问者分别向回答者提问。
        for (int i=0; i< 10000 ; i++) {
            Questioner questioner = new Questioner("Q" + i);
            Author author = new Author("A" + i);
            questioner.setAuthor(author);
            questioner.doRequest();
            Thread.sleep(100);
        }
    }
}
复制代码

咱们给被监听者设置了一个监听器，若是咱们在被监听者销毁的时候没有去注销监听，那么监听器就会一直持有被监听者的引用，这个时候GC就不会去回收被监听者，长此以往也就有可能会发生内存泄漏。