内存泄露的原因
内存优化中非常关键的一点，就是避免内存泄露，因为内存泄露会严重的导致内存浪费。
无用的对象引用一直未被释放，就会导致内存泄露。
如果代码中，无用的对象的引用一直没有被清除掉，就会造成内存泄露。
当按Back键关掉一个Activity时，此Activity就暂时没用了。
但是，如果某个后台任务一直持有着该Activity对象的引用，此时就会导致内存泄露。
四种引用类型
1. 强引用
对象类型 对象名 = new 对象构造方法();
如：String str = new String("Test");
清除强引用对象中的引用如下：
str = null;
强引用对象一般不会被GC回收，它宁愿被抛出OOM异常，想要回收就要置空引用。
2. 软应用 SoftReference
private void demo() {
String str = new String("");
SoftReference<String> softReference = new SoftReference<>(str);
}
当系统内存不足时，软引用对象会被GC回收。
清除软引用对象中的引用链，可以通过模拟系统内存不足来清除，也可以手动清除，手动清除如下：
SoftReference<String> softReference = new SoftReference<String>(str);
softReference.clear();
3. 弱引用 WeakReference
private void demo() {
String str = new String("");
WeakReference<String> softReference = new WeakReference<>(str);
}
当每次GC时，弱可及对象就会被回收。
清除弱引用对象中的引用链可以通过手动调用gc代码来清除，如下：
private void demo() {
String str = new String("");
WeakReference<String> softReference = new WeakReference<>(str);
softReference.get();//获取引用
softReference.clear();
System.gc();
}
4. 虚引用 PhantomReference
虚引用在代码中出现的频率极低，主要目的是为了检测对象是否已经被系统回收。
PhantomReference phantomReference = new PhantomReference<>(arg0, arg1);
补充
一个对象的可及性由最强的那个来决定。
System.gc()只会回收堆内存中存放的对象。
String str = "demo";
WeakReference<String> weakReference = new WeakReference<>(str);
System.gc();
"demo"被存放在常量池里，所以gc()不会去回收。
常见的内存泄露
1.内部类导致内存泄露
1. 内部类导致内存泄漏的原因
内部类实例会 隐式引用 外部类的引用。
内部类如果没有持有外部类的引用，是没办法去调用外部类的属性和方法的。
然而，内部类没有明显的去指定和声明引用，所以称之为 隐式引用。
泄露原因：
比如在Activity中创建一个内部类，然后在内部类中去执行一些耗时操作。
操作在执行过程中，Activity被关掉，此时Activity对象也不会被释放
因为那个内部类还持有着对Activity的引用。
在Activity中创建一个 内部类 去继承Thread
然后让该Thread执行一些后台任务，未执行完，关闭Activity，就造成会内存泄露。
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startThread();
}
});
}
private void startThread() {
Thread thread = new Thread() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
SystemClock.sleep(1000);
}
}
};
thread.start();
}
}
当点击页面按钮执行startThread()后，再按下back键关闭Activity
几秒后LeakCanary就会提示内存泄露了。
2. 内部类内存泄漏解决方案
声明这个内部类为静态类，避免这个内部类去隐式引用外部类Activity即可。
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
...与先前相比未做变化，不再描述
}
private void startThread() {
Thread thread = new MyStaticThread();
thread.start();
}
将内部类声明为静态类
private static class MyStaticThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
SystemClock.sleep(1000);
}
}
}
}
2.1 控制后台任务
为了效率和优化，建议通过一个boolean类型的标志位来控制后台任务。
在外部类Activity的onDestory()中，将boolean值进行修改，使后台任务退出循环。
public class MainActivity extends AppCompatActivity {
...
//Activity页面是否已经destroy
private static boolean isDestroy = false;
private static class MyStaticThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if(!isDestroy){
SystemClock.sleep(1000);
}
}
}
}
@Override
protected void onDestroy() {
super.onDestroy();
isDestroy = true;
}
}
2.3 通过声明 引用 调用外部类属性，方法。
当该内部类声明为静态时，将不再持有外部类Activity的引用
此时也不能再直接使用外部类中的方法、变量。
此时就需要通过引用调用
public class MainActivity extends AppCompatActivity {
private boolean isDestroy = false;
private void startThread() {
Thread thread = new MyStaticThread(MainActivity.this);
thread.start();
}
private static class MyStaticThread extends Thread {
private WeakReference<MainActivity> softReference = null;
MyStaticThread(MainActivity mainActivity){
this.softReference = new WeakReference<>(mainActivity);
}
@Override
public void run() {
MainActivity mainActivity = softReference.get();
for (int i = 0; i < 200; i++) {
//使用前最好对MainActivity对象做非空判断
//如果它已经被回收，就不再执行后台任务
if(mainActivity != null && !mainActivity.isDestroy){
SystemClock.sleep(1000);
}
}
}
}
@Override
protected void onDestroy() {
super.onDestroy();
isDestroy = true;
}
}
Handler
public class MainActivity extends AppCompatActivity {
private static final int MESSAGE_DELAY = 0;
private Button mButton;
private void startDelayTask() {
//发送一条消息，该消息会被延时10秒后才处理
...
}
private Handler mHandler = new InsideHandler(MainActivity.this);
private static class InsideHandler extends Handler {
private WeakReference<MainActivity> mSoftReference;
InsideHandler(MainActivity activity) {
mSoftReference = new WeakReference<MainActivity>(activity);
}
@Override
public void handleMessage(Message msg) {
MainActivity mainActivity = mSoftReference.get();
if (mainActivity != null) {
switch (msg.what) {
case MESSAGE_DELAY:
//通过软引用中的mainActivity可以拿到那个非静态的button对象
mainActivity.mButton.setText("延时修改了按钮的文本");
break;
}
}
}
}
}
当Activity页面退出时，将handler中的所有消息进行移除，做到滴水不漏。
其实就是在onDestroy中写上：
@Override
protected void onDestroy() {
super.onDestroy();
//参数为null时，handler中所有消息和回调都会被移除
mHandler.removeCallbacksAndMessages(null);
}
总结
1. 将内部类声明为静态的
2. 通过引用获取外部属性，方法
3. 注意判断引用获取是否为空
4. 在Activity销毁方法内注销Handler等
2.Context导致内存泄露
有时候我们会创建一个静态类，比如说AppManager、XXXManager。
这些静态类可能还会以单例模式存在。
当需要做关于UI的处理，所以传递了一个Context进来。
public class ToastManager {
private Context mContext;
ToastManager(Context context){
mContext = context;
}
private static ToastManager mManager = null;
public void showToast(String str){
if(str == null){
return;
}
Toast.makeText(mContext, str, Toast.LENGTH_SHORT).show();
}
public static ToastManager getInstance(Context context){
if(mManager == null){
synchronized (ToastManager.class){
if(mManager == null){
mManager = new ToastManager(context);
}
}
}
return mManager;
}
}
使用时
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
...
ToastManager instance = ToastManager.getInstance(MainActivity.this);
}
}
此时会发生内存泄露
因为静态实例比Activity生命周期长，在使用静态类时将Activity作为context参数传了进来
当Activity被关掉，但是静态实例中还保有对它的引用
会导致Activity没法被及时回收，造成内存泄露
解决方案：
在传Context上下文参数时，尽量传跟Application应用相同生命周期的Context。
比如getApplicationContext()，因为静态实例的生命周期跟应用Application一致。
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ToastManager instance = ToastManager.getInstance(getApplicationContext());
}
}
Context的作用域
Context的具体实现子类
Activity、Application、Service
1.Activity
出于安全原因的考虑，Android是不允许Activity或Dialog凭空出现的。
一个Activity的启动，必须要建立在另一个Activity的基础上，以此形成的返回栈。
Dialog则必须在一个Activity上面弹出。
在这种场景下，只能使用Activity类型的Context，否则将会出错。
总结
1. 凡是跟UI相关的，都建议使用Activity做为Context来处理.
2. 注意Context引用的持有，防止内存泄漏。
