内存泄露 Memory Leaks 内存优化总结

Posted 2020-10-04

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了内存泄露 Memory Leaks 内存优化总结相关的知识，希望对你有一定的参考价值。

什么是内存泄露

内存管理一直是Java 所鼓吹的强大优点。开发者只需要简单地创建对象，而Java的垃圾收集器将会自动管理内存空间的分配和释放。

但在很多情况下，事情并不那么简单，在 Java程序中总是会频繁地发生内存泄露(Memory Leaks)。

内存泄漏就是：当某些对象不再被应用程序所使用，但是由于仍然被引用而导致垃圾收集器不能释放他们。

或者说是：我们对某一内存空间使用完成后没有释放。

用白话来说就是：该回收的内存没被回收。

要理解这个定义，我们需要理解内存中的对象状态。下图展示了什么是不使用的部分，以及未被引用的部分。

从图中可以看出，内存中存在着"有引用的对象"和"无引用的对象"。无引用的对象将被垃圾收集器所回收，而有引用的对象则不会被当做垃圾收集。 

因为没有任何其他对象所引用，所以无引用对象一定是不再使用的，但是有一部分无用对象仍然被(无意中)引用着。这就是发生内存泄露的根源。

为什么会发生内存泄露

为什么内存会泄露?

让我们看下面的实例来了解为什么内存会泄露。 

在下面的情境中，对象A引用了对象B。 A的生命周期(t1 - t4) 比 B的(t2 - t3)要长得多。 当对象B在应用程序逻辑中不会再被使用以后， 对象 A 仍然持有着 B的引用。 (根据虚拟机规范)在这种情况下垃圾收集器不能将 B 从内存中释放，这种情况很可能会引起内存问题。甚至有可能 B 也持有一大堆其他对象的引用，这些对象由于被 B 所引用，也不会被垃圾收集器所回收。所有这些无用的对象将消耗大量宝贵的内存空间。

导致内存泄漏最主要的原因就是：某些长存对象持有了一些其它应该被回收的对象的引用，导致垃圾回收器无法去回收掉这些对象。

发生内存泄漏的常见场景

静态集合类的使用

像HashMap、ArrayList等的使用最容易出现内存泄露，由于静态变量的生命周期和应用程序一致，所以他们所引用的所有的对象也不能被释放。

如

public class Test {
    static ArrayList<Person> list = new ArrayList<Person>();//list中引用的对象在应用整个生命周期中都不会被释放
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            Person person = new Person("" + i);
            list.add(person);
            person = null;//将变量person指向null，而不是指向堆内存中的Person对象；注意这时堆内存中的Person对象并没有被回收
        }
        for (Person person : list) {
            System.out.println(person);//所有Person对象都没有被回收！！！
        }
    }
}
class Person {
    public String name;
    public Person(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return name;
    }
}

在这个例子中，如果仅仅释放引用本身(person = null)，那么集合仍然引用该对象，所以这个对象对GC来说是不可回收的。因此，如果对象加入到集合后，还必须从集合中删除(移除)，最简单的方法就是将集合对象设置为null。

Listener、Receiver等监听器的引用

当注册的监听器不再使用后，如果没有被注销，那么很可能会发生内存泄露。


public class Test {
    public static void main(String[] args) {
        B b = new B();//被监听者，如Activity
        A a = new A();//监听者，如BroadcastReceiver
        b.register(a);//在b中注册【a监听器】，通常register内部的操作是：将a的引用传给b的成员变量，进而长期持有a的引用
        a = null;//虽然将监听器a设为null，但是监听器对象A并没有被回收，因为它被B引用了
        b.show();//监听器工作了
        b.unregister();//用完要注销掉
    }
}
interface Listener {
    public void listen();
}
class A implements Listener {//监听者，如BroadcastReceiver
    @Override
    public void listen() {
        System.out.println("监听器工作了");
    }
}
class B {//被监听者，如Activity
    Listener listener;
    public void register(Listener listener) {//B持有了Listener的引用，除非在B内部将其设为null，否则listener将不会被回收
        this.listener = listener;
    }
    public void unregister() {
        listener = null;
    }
    public void show() {
        if (listener != null) listener.listen();
    }
}

上述只是逻辑十分清楚、简单的监听，对于关系复杂的监听，会导致更多更严重的问题。

比如当我们在Activity中使用了registerReceiver()方法注册了一个BroadcastReceiver，如果没在Activity的生命周期内调用unregisterReceiver()方法取消注册此BroadcastReceiver，由于BroadcastReceiver不止被Activity引用，还可能会被AMS等系统服务、管理器等引用，导致BroadcastReceiver无法被回收，而BroadcastReceiver中又持有着Activity的引用(即：onReceive方法中的参数Context)，会导致Activity也无法被回收(虽然Activity回调了onDestroy方法，但并不意味着Activity呗回收了)，从而导致严重的内存泄漏。

非静态内部类的引用

（非静态）内部类的引用是比较容易遗忘的一种，而且一旦没释放可能导致一系列的后继类对象没有释放。

内部类的实现其实是通过编译器的语法糖（Syntactic sugar）实现的，通过生成相应的子类即以OutClassName$InteriorClassName命名的Class文件。并添加构造函数，在构造函数中【传入】外部类，这也是为什么内部类能使用外部类的方法与字段的原因。所以，当外部类与内部类生命周期不一致的时候很有可能发生内存泄漏。

例如在一个Activity启动一个Thread执行一个任务，因为Thread是内部类持有了Activity的引用，当Activity销毁的时候如果Thread的任务没有执行完成，造成Activity的引用不能被释放从而引起内存泄漏。

这种情况下可以通过声明一个静态内部类来解决问题，从反编译中可以看出，声明为static的内部类不会持有外部类的引用。此时，如果你想在静态内部类中使用外部类的话，可以通过软引用的方式保存外部类的引用。

在Activity里声明了一个匿名内部类，如果Activity在销毁之前，线程的任务还未完成，那么将导致Activity的内存资源无法回收，造成内存泄漏。

/**
 * 测试非静态内部类导致内存泄漏的问题
 */
public class MemoryLeaksActivity extends Activity {
	TextView textView;
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		textView = new TextView(this);
		setContentView(textView);
		String startTime = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss SSS", Locale.getDefault()).format(new Date());
		textView.setText("开始休息 " + startTime);
		
		new Thread(() -> {
			SystemClock.sleep(1000 * 5);
			String endTime = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss SSS", Locale.getDefault()).format(new Date());
			Log.i("bqt", "【结束休息】" + endTime);//即使Activity【onDestroy被回调了】，这条日志仍会打出来
			//runOnUiThread(() -> textView.append("\\n结束休息 " + endTime));
		}).start();
	}
	
	@Override
	protected void onDestroy() {
		super.onDestroy();
		Log.i("bqt", "【onDestroy被回调了】");
	}
}

解决办法就是使用静态内部类，如下：

/**
 * 测试使用静态内部类避免导致内存泄漏
 */
public class MemoryLeaksActivity extends Activity {
	TextView textView;
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		textView = new TextView(this);
		setContentView(textView);
		String startTime = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss SSS", Locale.getDefault()).format(new Date());
		textView.setText("开始休息 " + startTime);
		
		new MyThread(this).start();
	}
	
	@Override
	protected void onDestroy() {
		super.onDestroy();
		Log.i("bqt", "【onDestroy被回调了】");
	}
	
	private static class MyThread extends Thread {
		SoftReference<Activity> context;
		
		MyThread(Activity activity) {
			context = new SoftReference<>(activity);
		}
		
		@Override
		public void run() {
			SystemClock.sleep(1000 * 15);
			String endTime = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss SSS", Locale.getDefault()).format(new Date());
			Log.i("bqt", "【结束休息】" + endTime);//即使Activity【onDestroy被回调了】，这条日志仍会打出来
			if (context.get() != null) {
				context.get().runOnUiThread(() -> Toast.makeText(context.get(), "结束休息", Toast.LENGTH_SHORT).show());
			}
		}
	}
}