在Android中，内存泄漏的现象十分常见；而内存泄漏导致的后果会使得应用crash

定义：Memory Leak
指程序在申请内存后，当该内存不需要再使用但却无法被释放&归还给程序得现象。
内存回收策略
步骤1：Application Framwork决定回收得进程类型Android中的进程是托管的；当进程空间紧张时，会按照进程优先级低到高的顺序自动回收进程
优先级：
空进程->后台进程->服务进程->可见进程->前台进程
步骤2：
Linux内核真正回收具体进程
1.ActivityManagerService对所有进程进行评分（评分存放在变量adj中）
2.更新评分到linux内核
3.由linux内核完成真正的内存回收

常见的内存泄露原因&解决方案
1.集合类
2.Static关键字修饰的成员变量
3.非静态内部类/匿名类
4.资源对象使用后没有关闭

1.集合类

List<Object> objectList new ArrayList<>();
for(int i = 0;i < 10;i++){
	Object o = new Object();
	objectList.add(o);
	o = null;
}

//虽然设防了集合元素本身：o = null，但是集合list仍然引用该对象，故垃圾回收GC依然不可回收该对象

解决方案：集合类添加集合元素对象，在使用后必须从集合中删除

//释放objectList
objectList.clear();
objectList = null;

2.static关键字修饰的成员变量
被static关键字修饰的成员变量的生命周期 = 应用程序的生命周期

泄漏原因：若static关键字修饰的成员变量引用海飞资源过多的实例（如context），则容易出现该成员变量的生命周期大于引用实例生命周期的情况，当引用实例需结束生命周期销毁时，会因为静态变量的持有而无法被回收，从而出现内存泄漏

public class ClassName{
	private static Context mContext;
	//引用Activity的context
	mContext = context;
	//当Activity需销毁时，由于mContext = 静态 & 生命周期 = 应用程序的生命周期，故Activity无法被回收，从而出现内存泄漏

}

解决方案：
1.尽量避免static成员变量引用资源耗费过多的实例（如context），若需引用Context，则尽量使用Application的Context
2.使用弱引用weakReference代替强引用持有实例
注意：静态成员变量有个非常典型的例子->单列模式

// 创建单例时，需传入一个Context
// 若传入的是Activity的Context，此时单例 则持有该Activity的引用
// 由于单例一直持有该Activity的引用（直到整个应用生命周期结束），即使该Activity退出，该Activity的内存也不会被回收
// 特别是一些庞大的Activity，此处非常容易导致OOM

public class SingleInstanceClass {    
    private static SingleInstanceClass instance;    
    private Context mContext;    
    private SingleInstanceClass(Context context) {        
        this.mContext = context; // 传递的是Activity的context
    }  

    public SingleInstanceClass getInstance(Context context) {        
        if (instance == null) {
            instance = new SingleInstanceClass(context);
        }        
        return instance;
    }
}

解决方案：

解决方案
public class SingleInstanceClass {    
    private static SingleInstanceClass instance;    
    private Context mContext;    
    private SingleInstanceClass(Context context) {        
        this.mContext = context.getApplicationContext(); // 传递的是Application 的context
    }    

    public SingleInstanceClass getInstance(Context context) {        
        if (instance == null) {
            instance = new SingleInstanceClass(context);
        }        
        return instance;
    }
}

3.非静态内部类/匿名类
非静态内部类/匿名类 默认持有外部类的引用；而静态内部类则不会

解决方案
将非静态内部类设置为：静态内部类（静态内部类默认不持有外部类的引用）
该内部类抽取出来封装成一个单例
尽量 避免 非静态内部类所创建的实例 = 静态

4.多线程的使用方法 = 非静态内部类 / 匿名类；即 线程类 属于 非静态内部类 / 匿名类
泄露原因
当 工作线程正在处理任务 & 外部类需销毁时， 由于 工作线程实例 持有外部类引用，将使得外部类无法被垃圾回收器（GC）回收，从而造成 内存泄露

多线程主要使用的是：AsyncTask、实现Runnable接口 & 继承Thread类
前3者内存泄露的原理相同，此处主要以继承Thread类 为例说明

 /** 
     * 方式1：新建Thread子类（内部类）
     */  
        public class MainActivity extends AppCompatActivity {

        public static final String TAG = "carson：";
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            // 通过创建的内部类 实现多线程
            new MyThread().start();

        }
        // 自定义的Thread子类
        private class MyThread extends Thread{
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    Log.d(TAG, "执行了多线程");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

   /** 
     * 方式2：匿名Thread内部类
     */ 
     public class MainActivity extends AppCompatActivity {

    public static final String TAG = "carson：";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 通过匿名内部类 实现多线程
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    Log.d(TAG, "执行了多线程");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }.start();
    }
}

分析：
工作线程Thread类属于非静态内部类/匿名类，运行时默认持有外部类的引用
当工作线程运行时，若外部类MainActivity需销毁，由于此时工作线程类实例持有外部类的引用，将使得外部类无法被垃圾回收GC回收掉，从而造成泄漏

解决方案：

/** 
     * 解决方式1：静态内部类
     * 原理：静态内部类 不默认持有外部类的引用，从而使得 “工作线程实例 持有 外部类引用” 的引用关系 不复存在
     * 具体实现：将Thread的子类设置成 静态内部类
     */  
        public class MainActivity extends AppCompatActivity {

        public static final String TAG = "carson：";
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            // 通过创建的内部类 实现多线程
            new MyThread().start();

        }
        // 分析1：自定义Thread子类
        // 设置为：静态内部类
        private static class MyThread extends Thread{
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    Log.d(TAG, "执行了多线程");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

   /** 
     * 解决方案2：当外部类结束生命周期时，强制结束线程
     * 原理：使得 工作线程实例的生命周期 与 外部类的生命周期 同步
     * 具体实现：当 外部类（此处以Activity为例） 结束生命周期时（此时系统会调用onDestroy（）），强制结束线程（调用stop（））
     */ 
     @Override
    protected void onDestroy() {
        super.onDestroy();
        Thread.stop();
        // 外部类Activity生命周期结束时，强制结束线程
    }

5.消息传递机制

消息传递机制
解决方案：
1.建议写成private static Handler handler = new Handler
2.在外部类结束生命周期时间，清空Handler内消息队列

@Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacksAndMessages(null);
        // 外部类Activity生命周期结束时，同时清空消息队列 & 结束Handler生命周期
    }

使用LeakCanary 监测内存泄漏
添加链接描述