内存优化

内存泄露的原因

内存优化中非常关键的一点，就是避免内存泄露，因为内存泄露会严重的导致内存浪费。

无用的对象引用一直未被释放，就会导致内存泄露。
如果代码中，无用的对象的引用一直没有被清除掉，就会造成内存泄露。

当按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引用的持有，防止内存泄漏。