Activity与Service通信引发内存泄漏问题求助

我之前处理过好几起类似的跨进程Service绑定引发的内存泄漏问题，结合你描述的场景——Activity在onStart绑定独立进程的MyService、onStop解绑并移除监听器，但LeakCanary仍检测到泄漏，核心问题大概率出在跨进程监听器的引用管理和普通ArrayList不适合跨进程场景上，下面给你一步步拆解解决方案：

1. 用RemoteCallbackList替代普通ArrayList管理监听器 #

你现在用ArrayList维护跨进程监听器，这是最大的隐患之一：

• 普通ArrayList不具备跨进程引用的自动清理能力，当客户端Activity所在进程意外终止（比如被系统回收），Service端的ArrayList仍会持有该监听器的无效引用，导致内存泄漏。
• RemoteCallbackList是Android官方专门为跨进程回调设计的容器，它会自动跟踪客户端进程的存活状态，当客户端进程死亡时，会自动移除对应的监听器，同时内部实现了线程安全的增删操作，无需你自己处理同步问题。

代码示例（Service端）： #

// 定义AIDL接口（IMyService.aidl）
interface IMyService {
    void addListener(IMyListener listener);
    void removeListener(IMyListener listener);
}

interface IMyListener {
    void onDataChanged(String data);
}

// MyService实现类
public class MyService extends Service {
    // 用RemoteCallbackList替代ArrayList
    private final RemoteCallbackList<IMyListener> mListenerList = new RemoteCallbackList<>();

    private final IMyService.Stub mBinder = new IMyService.Stub() {
        @Override
        public void addListener(IMyListener listener) throws RemoteException {
            if (listener != null) {
                mListenerList.register(listener);
            }
        }

        @Override
        public void removeListener(IMyListener listener) throws RemoteException {
            if (listener != null) {
                mListenerList.unregister(listener);
            }
        }
    };

    // 通知所有监听器的示例方法
    private void notifyListeners(String data) {
        int count = mListenerList.beginBroadcast();
        for (int i = 0; i < count; i++) {
            try {
                mListenerList.getBroadcastItem(i).onDataChanged(data);
            } catch (RemoteException e) {
                // 客户端进程可能已死亡，无需额外处理，RemoteCallbackList会自动清理
                e.printStackTrace();
            }
        }
        mListenerList.finishBroadcast();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
}

2. 避免监听器持有Activity的强引用 #

如果你的监听器是Activity的非静态内部类/匿名内部类，会默认持有Activity的强引用，而跨进程的Binder会持有监听器的引用，这就形成了一条Service -> Binder -> 监听器 -> Activity的强引用链，即使你调用了removeListener，如果跨进程通信有延迟，Activity可能已经被销毁但无法被GC回收。

解决方案： #

把监听器改成静态内部类，并用WeakReference持有Activity实例，这样即使监听器被Service端持有，也不会阻止Activity被GC回收：

public class MainActivity extends AppCompatActivity {
    private IMyService mService;
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = IMyService.Stub.asInterface(service);
            // 注册静态内部类的监听器，用WeakReference持有Activity
            try {
                mService.addListener(new MyServiceListener(MainActivity.this));
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mService = null;
        }
    };

    // 保存监听器实例，确保移除时是同一个对象
    private MyServiceListener mListener;

    // 静态内部类的监听器
    private static class MyServiceListener extends IMyListener.Stub {
        private final WeakReference<MainActivity> mActivityRef;

        public MyServiceListener(MainActivity activity) {
            mActivityRef = new WeakReference<>(activity);
        }

        @Override
        public void onDataChanged(String data) throws RemoteException {
            MainActivity activity = mActivityRef.get();
            if (activity != null && !activity.isFinishing() && !activity.isDestroyed()) {
                // 在Activity存活时处理回调
                activity.runOnUiThread(() -> {
                    // 更新UI逻辑
                });
            }
        }
    }

    @Override
    protected void onStart() {
        super.onStart();
        Intent intent = new Intent(this, MyService.class);
        bindService(intent, mConnection, BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (mService != null && mListener != null) {
            try {
                // 移除同一个监听器实例
                mService.removeListener(mListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        unbindService(mConnection);
        mService = null; // 清空Service引用
        mListener = null; // 清空监听器引用
    }
}

3. 用ViewModel管理Service连接（避免配置变更泄漏） #

如果你的Activity会经历配置变更（比如旋转屏幕），默认情况下Activity会被销毁重建，而原来的Service连接如果没处理好，旧Activity的引用会被Service端持有导致泄漏。用ViewModel来管理Service连接，可以确保配置变更时连接不会中断，同时避免旧Activity的引用泄漏：

public class ServiceConnectionViewModel extends ViewModel {
    private IMyService mService;
    private ServiceConnection mConnection;
    private MyServiceListener mListener;

    public void bindService(Context context) {
        if (mConnection == null) {
            mConnection = new ServiceConnection() {
                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {
                    mService = IMyService.Stub.asInterface(service);
                    mListener = new MyServiceListener((Activity) context);
                    try {
                        mService.addListener(mListener);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onServiceDisconnected(ComponentName name) {
                    mService = null;
                }
            };
            Intent intent = new Intent(context, MyService.class);
            context.bindService(intent, mConnection, BIND_AUTO_CREATE);
        }
    }

    public void unbindService(Context context) {
        if (mService != null && mListener != null) {
            try {
                mService.removeListener(mListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        if (mConnection != null) {
            context.unbindService(mConnection);
            mConnection = null;
        }
        mService = null;
        mListener = null;
    }
}

// 在Activity中使用ViewModel
public class MainActivity extends AppCompatActivity {
    private ServiceConnectionViewModel mViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mViewModel = new ViewModelProvider(this).get(ServiceConnectionViewModel.class);
    }

    @Override
    protected void onStart() {
        super.onStart();
        mViewModel.bindService(this);
    }

    @Override
    protected void onStop() {
        super.onStop();
        mViewModel.unbindService(this);
    }
}

4. 兜底检查：确保解绑时清理所有引用 #

• 在onStop（或onDestroy）中，除了调用unbindService，还要把mService、ServiceConnection、监听器实例等所有相关引用置为null，切断强引用链。
• 如果你的Service是START_STICKY模式，要确保在客户端解绑后，Service没有不必要的后台任务持有监听器引用。

按照上面的步骤，替换ArrayList为RemoteCallbackList，将监听器改为静态内部类+WeakReference，用ViewModel管理连接，基本就能解决LeakCanary检测到的跨进程Service绑定内存泄漏问题。

内容的提问来源于stack exchange，提问作者Cilenco