Android 内存泄漏二：View.post

View.post(Runnable action) 方法在 Android 开发中经常用于在 UI 线程上执行代码，
尤其是当需要在某个视图的绘制或布局操作完成后立即执行某些操作时。
这个方法确实与内存泄漏的潜在风险有关，但主要是基于其如何被使用，而不是方法本身直接导致的。

1、关于内存泄漏

内存泄漏通常发生在以下情况：
当一个对象不再被应用中的其他对象引用时，它仍然被某些活跃的对象（如静态变量、全局变量、长时间运行的线程等）
持有引用，导致垃圾回收器无法回收它。在 Android 中，这可能导致应用占用的内存持续增长，最终可能导致 OutOfMemoryError。

2、View.post 与内存泄漏

1. View.post 方法本身：
   这个方法本身并不直接持有 View 实例的强引用。
   它只是将 Runnable 添加到消息队列中，等待 UI 线程（主线程）执行。
   如果 Runnable 内部没有持有对外部对象的非必要引用（特别是那些生命周期长于当前 View 的对象），
   那么使用 post 方法本身不会导致内存泄漏。

2. 错误的使用方式：
   比如postDelayed延迟执行的Runnable里面，调用View.post。
   可能Runnable 内部直接或间接持有对外部Activity的引用，而Activity在delay时间之前销毁了。
   这里Runnable 仍被消息队列持有，这就可能导致内存泄漏。

3. 避免内存泄漏：

   • 确保 Runnable 内部不持有对外部对象的非必要引用。
   • 如果必须持有引用，考虑使用弱引用（WeakReference）或软引用（SoftReference），这样可以在垃圾回收时允许这些对象被回收。
   • 在 Activity 或 Fragment 的 onDestroy 或 onDetach 方法中取消所有未完成的 post 操作，尤其是那些可能会持有 Activity 或 Fragment 引用的操作。

结论

View.post 方法本身不会导致内存泄漏，但错误的使用方式（如在 Runnable 内部持有对长生命周期对象的强引用）可能会导致内存泄漏。因此，开发者在使用此方法时需要谨慎处理其中的引用，确保不会无意中延长对象的生命周期。

---

3、View.post泄露示例

// 存在内存泄漏，Runnable持有外部TextView应用隐式强引用，间接持有Activity的引用

public class LeakyActivity extends AppCompatActivity {  
  
    private TextView textView;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_leaky);  
  
        textView = findViewById(R.id.text_view);  
  
        // 假设有一个按钮，点击后启动一个耗时操作，并在操作完成后更新TextView  
        // 但为了简化，我们直接在onCreate中模拟这个场景  
        startLongRunningOperation();  
    }  
  
    private void startLongRunningOperation() {  
        // 模拟耗时操作（例如，网络请求、文件IO等）  
        new Handler().postDelayed(() -> {  
            // 耗时操作完成后，使用View.post来更新UI  
            textView.post(new Runnable() {  
                // 注意：这里Runnable匿名内部类隐式持有对外部类LeakyActivity的引用  
                @Override  
                public void run() {  
                    // 更新TextView文本  
                    textView.setText("操作完成");  
  
                    // 假设这里有更多的逻辑，比如监听器注册等，这些都可能延长Activity的生命周期  
                    // ...  
  
                    // 关键点：如果此时Activity已经不可见或即将被销毁，  
                    // 但Runnable仍然持有对Activity的引用，那么Activity就无法被垃圾回收  
                }  
            });  
        }, 5000); // 假设耗时操作需要5秒  
  
        // 注意：这里没有提供取消或清理Runnable的机制  
    }  
  
    @Override  
    protected void onDestroy() {  
        super.onDestroy();  
        // 正常情况下，我们可能希望在这里取消所有未完成的Runnable或操作  
        // 但在这个例子中，我们没有这样做，所以可能会导致内存泄漏  
    }  
}

---

4、View.post泄露修复示例

解决方案一：在Activity的onDestroy中调用removeCallbacks

这种方法适用于当您确实需要在某个View上执行耗时操作后更新UI，但希望在Activity销毁时取消这些操作。

public class LeakyActivity extends AppCompatActivity {

    private TextView textView;
    private Handler handler = new Handler();
    private Runnable pendingUpdate;

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

        textView = findViewById(R.id.text_view);

        // 初始化Runnable，但先不执行
        pendingUpdate = new Runnable() {
            @Override
            public void run() {
                // 更新UI
                textView.setText("操作完成");

                // 清理引用，虽然在这个简单的例子中可能不是必需的
                pendingUpdate = null;
            }
        };

        // 模拟耗时操作
        handler.postDelayed(pendingUpdate, 5000);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 取消所有待处理的Runnable
        handler.removeCallbacks(pendingUpdate);

        // 清理Handler，虽然不是必需的，但好习惯
        handler = null;
    }
}

解决方案二：View.post访问数据但不更新UI

如果您只是想在View.post中访问Activity中的数据，但不直接更新UI（可能是为了在其他地方或稍后更新），并且想避免内存泄漏，您可以确保Runnable不持有对Activity的强引用，或者使用弱引用来访问数据。但在这个场景中，由于我们只是想访问数据，而不是更新UI，因此可能不需要使用View.post（除非您想在UI线程上同步执行某些操作）。不过，为了示例，我们仍然可以展示如何在Runnable中安全地访问数据。

但请注意，如果您只是想要访问数据而不更新UI，并且不担心线程同步问题（即数据访问是线程安全的），那么您可能根本不需要使用View.post。然而，如果您确实需要在UI线程上访问数据（可能是为了后续的UI更新或其他线程安全原因），并且想避免内存泄漏，可以这样做：

public class DataAccessActivity extends AppCompatActivity {

    private MyDataModel dataModel; // 假设这是您的数据模型

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

        // 初始化数据模型
        dataModel = new MyDataModel();

        // 使用View.post来在UI线程上访问数据（尽管这在这个场景中可能不是必需的）
        final View someView = findViewById(R.id.some_view);
        someView.post(new Runnable() {
            @Override
            public void run() {
                // 在UI线程上访问数据
                String data = dataModel.getData();

                // 注意：这里没有更新UI，只是访问了数据
                // 如果您需要更新UI，请确保Activity仍然有效或使用其他机制来检查

                // 由于Runnable没有持有对Activity的强引用（除非它通过其他方式获得），
                // 因此这里不太可能直接导致内存泄漏
                // 但是，如果MyDataModel或类似对象持有对Activity的强引用，并且没有被正确清理，
                // 那么仍然可能发生内存泄漏
            }
        });
    }

    // 确保在适当的时候清理数据模型，如果它持有对Activity的引用
    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 清理数据模型，防止内存泄漏（如果它是问题的根源）
        dataModel = null;

        // 注意：在这个特定的例子中，dataModel的清理可能不是必需的，
        // 除非它持有对Activity或其他需要被垃圾回收的对象的强引用
    }
}

请注意，在这个解决方案二中，我假设了MyDataModel是一个简单的数据模型类，它本身不持有对Activity的引用。如果MyDataModel（或类似的数据持有者）确实持有对Activity的引用，并且这个引用没有被正确管理（例如在onDestroy中清理），那么仍然可能发生内存泄漏。

另外，请注意，即使您没有直接在Runnable中更新UI，但如果Runnable（或其持有的任何对象）以某种方式持有对Activity的强引用，并且这个引用在Activity不再需要时没有被清理，那么仍然可能发生内存泄漏。因此，总是好的做法是在Activity的生命周期结束时清理所有不必要的引用。