Android常见内存泄漏

内存泄漏场景：

1. 静态变量引用非静态内部类/匿名类实例。
2. 子线程相关的非静态内部类/匿名内部类引用。
3. Handler导致的泄漏。
4. 不正确使用上下文。
5. 广播资源未取消注册。
6. 绑定服务后，未解绑服务。
7. 使用静态View。
8. File，Cusor等需要关闭的资源对象，未关闭。
9. Bitmap未及时回收。
10. WebView。
11. 集合中的对象未及时清理。

Java匿名类实例和内部类实例会持有外部类实例的引用，内部类实例的引用不释放，外部类实例也不会释放。
Java中创建的对象很多都是根对象（例如静态引用，线程等），当根对象的生命周期长时，被它直接或间接持有的对象不会被释放，引发内存泄漏。

泄漏场景实例分析

1. 静态变量引用非静态内部类/匿名类实例。

• 静态变量引用非静态内部类实例。
• 静态变量引用匿名类实例。

静态变量引用非静态内部类，泄漏样例代码：

public class MainActivity extends AppCompatActivity {

    private static View.OnClickListener listener;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //创建内部类实例，listener静态变量引用这个实例
        listener = new MyListener();
        findViewById(R.id.btn_click).setOnClickListener(listener);
    }

    class MyListener implements View.OnClickListener {
        @Override
        public void onClick(View v) {
            System.out.println("Onclick");
        }
    }
}

静态变量引用匿名类实例，泄漏样例代码：

public class MainActivity extends AppCompatActivity {

    private static View.OnClickListener listener;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //listener静态变量引用匿名类实例
        listener = new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                System.out.println("Onclick");
            }
        };

        findViewById(R.id.btn_click).setOnClickListener(listener);
    }
}

解决方法：

• 方法一：listener改成非静态成员（推荐），只作为Activity对象中的一个普通成员。
• 方法二：listener主动置null，此示例引用的是普通实例，置空可被回收（假如引用一个内部类/匿名类线程实例，依然泄漏）。
• 方法三：MyListener使用static修饰，即静态类，不间接持有Activity实例。
• 方法四：匿名类使用Lambda替代，或使用静态内部类，不间接持有Activity实例。

后面两种方法虽然Activity不泄漏，但是listener对象无法被回收，第一种解决方法更佳。

2. 子线程相关的非静态内部类/匿名内部类引用。

• 子线程为非静态的内部类。
• 子线程为匿名类。
• 子线程中引用非静态内部类实例。
• 子线程中引用匿名类实例。

子线程为非静态的内部类，泄漏样例代码：

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private MyThread thread = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        thread = new MyThread();
        thread.start();
    }

    class MyThread extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

如果thread为静态变量，即使在onDestroy方法中，主动置空thread变量，依然会有内存泄漏。因为此时泄漏包含了静态变量和子线程为非静态内部类实例两种情况，他们都持有Activity，且生命周期比Activity更长，线程相关的下面三种泄露情况也是一样的。

子线程为匿名类实现，泄漏样例代码：

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private Thread thread = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();
    }
}

子线程中引用非静态内部类实例，泄漏样例代码：

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        findViewById(R.id.btn_click).setOnClickListener(v ->
                SingleTest.getInstant().setListener(new MyCallback())
        );
    }

    class MyCallback implements SingleTest.Callback {

        @Override
        public void onResult(boolean success) {
            Log.d(TAG, "Callback result=" + success);
        }
    }
}

子线程中引用匿名类实例，泄漏样例代码：

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

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

        findViewById(R.id.btn_click).setOnClickListener(v ->
                SingleTest.getInstant().setListener(new SingleTest.Callback() {
                    @Override
                    public void onResult(boolean success) {
                        Log.d(TAG, "Callback result=" + success);
                    }
                }));
    }
}

子线程在SingleTest单例中：

public class SingleTest {

    private static volatile SingleTest instance;

    private SingleTest() {

    }

    public static SingleTest getInstant() {
        if (instance == null) {
            synchronized (SingleTest.class) {
                if (instance == null) {
                    instance = new SingleTest();
                }
            }
        }
        return instance;
    }

    public void setListener(Callback callback) {
        new Thread(() -> {
            try {
                Thread.sleep(120000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (callback != null) {
                callback.onResult(true);
            }
            String aa = callback == null ? "null" : "none null";
            Log.d("SingleTest callback=", aa);
        }).start();
    }

    interface Callback {
        void onResult(boolean success);
    }
}

解决方法：

• ‘子线程为非静态的内部类’，使用静态内部类。
• ‘子线程为匿名类’，Lambda替代，或使用静态内部类。
• ‘子线程中引用非静态内部类实例’，使用静态内部类。
• ‘子线程中引用匿名类实例’，Lambda替代，或使用静态内部类。

注意：

1. 使用静态内部类，只是让线程实例不持有Activity，从而线程即使仍在执行任务，不会引起Activity泄漏，但是线程执行所需要的内存依然会被占据，
   管理好线程的存活也很重要，及时取消不必要的执行线程。

3. Handler导致的泄漏。

Handler + Runnable循环调用。

样例代码：

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private int count = 0;
    private final Handler handler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        handler.postDelayed(runnable, 1000);
    }

    private final Runnable runnable = new Runnable() {
        @Override
        public void run() {
            count++;
            if (runnable != null) {
                Log.d(TAG, "count=" + count);
                handler.postDelayed(runnable, 1000);
            }
        }
    };
}

解决方法：

1. 调用handler.removeCallbacks(runnable)(推荐)。
2. Handler，Runnable定义为静态内部类，handler变量使用static修饰。

4. 不正确使用上下文。

• 单例中直接持有上下文。
• 单例中间接持有上下文。

单例中直接持有Activity，代码示例：

单例：

public class SingleTest {

    private static volatile SingleTest instance;

    private Context context = null;

    private SingleTest() {

    }

    public static SingleTest getInstant() {
        if (instance == null) {
            synchronized (SingleTest.class) {
                if (instance == null) {
                    instance = new SingleTest();
                }
            }
        }
        return instance;
    }

    public void setContext(Context context) {
        this.context = context;
    }
}

Activity:

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //将Activity传给了单例
        SingleTest.getInstant().setContext(this);
    }
}

单例中间接持有上下文。

单例：

public class SingleTest {

    private static volatile SingleTest instance;
    private Callback callback = null;

    private SingleTest() {

    }

    public static SingleTest getInstant() {
        if (instance == null) {
            synchronized (SingleTest.class) {
                if (instance == null) {
                    instance = new SingleTest();
                }
            }
        }
        return instance;
    }

    public void setCallback(Callback callback) {
        this.callback = callback;
    }

    interface Callback {
        void onResult(boolean result);
    }
}

Activity:：

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //单例间接持有Activity
        SingleTest.getInstant().setCallback(new SingleTest.Callback() {
            @Override
            public void onResult(boolean result) {
            }
        });
    }
}

解决方法：

• 方法一：在Activity销毁时，将单例中会持有上下文的变量置空。
• 方法二：单例中使用Application上下文，代替Context上下文。
• 方法三：Callback类用静态类方式实现，不让单例间接持有Activity上下文。

5. 广播资源未取消注册。

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    private final BroadcastReceiver mReceiver = new MyReceiver();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyFilter intentFilter = new MyFilter(Intent.ACTION_USER_PRESENT);
        registerReceiver(mReceiver, intentFilter);
    }

    static class MyFilter extends IntentFilter {
        MyFilter(String action) {
            super(action);
        }
    }

    static class MyReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d(TAG, "MyReceiver, " + intent.getAction());
        }
    }
}

解决方法：

• Activity销毁时，取消注册。

还有一种情况，把registerReceiver(mReceiver, intentFilter)改成getApplication().getApplicationContext().registerReceiver(mReceiver, intentFilter)，即Application代替Activity注册广播，如果MyReceiver和MyFilter也都是静态类，不取消注册不会导致Activity泄露，因为使用的是Application的上下文。但如果它哥俩有一个是内部类或者匿名类，也等于AMS间接持有Activity，则仍会引发Activity泄露。最好还是注册广播后，在销毁时主动取消注册。

6. 绑定服务后，未解绑服务。

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    private final MyConnection conn =  new MyConnection();

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(this, MyService.class);
        bindService(intent, conn, BIND_AUTO_CREATE);
    }
    
    static class MyConnection implements ServiceConnection {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }

        @Override
        public void onBindingDied(ComponentName name) {

        }
    }
}

解决方法：

• Activity销毁时，解除绑定。
  如果用Application绑定服务，情况和注册广播一样。

7. 使用静态View

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    private static Button btnClick;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btnClick = findViewById(R.id.btn_click);
    }
}

解决方法：

• 方法一：移除static修饰符，使用非静态View。
• 方法二：Activity销毁时，将对象置null。

8. File，Cusor等需要关闭的资源对象，未关闭。

及时close资源。

9. Bitmap未及时回收。

调用bitmap.recycle()回收。

10.WebView。

• 方法一：使用一个全局的Webview。
• 方法二：销毁。

    mWebViewContainer.removeView(mWebView);
    mWebView.stopLoading();
    mWebView.getSettings().setJavaScriptEnabled(false);
    mWebView.clearHistory();
    mWebView.removeAllViews();
    mWebView.destroy();

11. 集合中的对象未及时清理。

及时清空集合中的对象。