Android RXJava2内存性能

我创建了一个可观察的（RxJava2+截击），每5秒重复一次，
它可以工作，但是当我转储Java堆（内存）时，我的模型Java类有很多实例，每次可观察到的重复出现时，它都会增加。
为什么要创建我的模型的多个实例？如何仅使用一个实例

型号

public RequestFuture<String> getLiveRefreshFuture() {
        RequestFuture<String> future = RequestFuture.newFuture();
        VolleyStringRequest request = new VolleyStringRequest(Request.Method.POST
                , REFRESH_URL
                , future
                , future) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                return getRefreshParams();
            }
        };

        VolleySingleton.getInstance().addToRequestQueue(request);
        return future;
    }    

public RequestFuture getLiveRefreshFuture（）{
RequestFuture=RequestFuture.newFuture（）；
VolleyStringRequest=新的VolleyStringRequest（request.Method.POST
，刷新URL
，未来
，未来）{
@凌驾
受保护的映射getParams（）引发AuthFailureError{
返回getRefreshParams（）；
}
};
VolleySingleton.getInstance（）.addToRequestQueue（请求）；
回归未来；
}    

---

活动

    private final CompositeDisposable disposables = new CompositeDisposable();

final LiveRemoteModel model = DaggerLiveComponent.builder().build().getModel();

        Observable<LiveResponse> observable = Observable
                .interval(Constants.TOOLBAR_BADGES_REFRESH_DELAY, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .map(dummy -> model.getLiveRefreshFuture())
                .map(RequestFuture::get)
                .map(LiveResponse::new)
                .observeOn(AndroidSchedulers.mainThread());

        DisposableObserver<LiveResponse> disposableObserver =
                new DisposableObserver<LiveResponse>() {
                    @Override
                    public void onNext(@NonNull LiveResponse liveResponse) {
                        setToolbarBadges(liveResponse.getToolbarBadges());
                    }

                    public void onError(@NonNull Throwable e) {
                        Log.e("RX", "onError: ", e);
                    }

                    @Override
                    public void onComplete() {
                        Log.d("RX", "onComplete: ");
                    }
                };

        disposables.add(observable.subscribeWith(disposableObserver));    

private final CompositeDisposable disposables=新CompositeDisposable（）；
最终LiveRemoteModel模型=DaggerLiveComponent.builder（）.build（）.getModel（）；
可观察的，可观察的
.interval（常数.TOOLBAR\u标记\u刷新\u延迟，时间单位为秒）
.subscribeOn（Schedulers.io（））
.map（虚拟->模型.getLiveRefreshFuture（））
.map（RequestFuture:：get）
.map（LiveResponse:：新建）
.observeOn（AndroidSchedulers.mainThread（））；
可处置的观察员可处置的观察员=
新的可处置观察员（）{
@凌驾
public void onNext（@NonNull LiveResponse LiveResponse）{
setToolbarBadges（liveResponse.getToolbarBadges（））；
}
公共无效onError（@NonNull可丢弃e）{
Log.e（“RX”，“onError:”，e）；
}
@凌驾
未完成的公共空间（）{
Log.d（“RX”，“onComplete:”）；
}
};
可处置的。添加（可观察的。可处置的观察者）；

为什么要创建我的模型的多个实例？如何仅使用一个实例

如果仔细查看heapdump中的对象是

LiveRemoteModel$2

，这表明它是

LiveRemoteModel

中的匿名类

---

查看您的代码，这可能是每次调用

model.getLiveRefreshFuture（）

时创建的

VolleyStringRequest

对象。RX管道中没有保留该对象的内容，因此Volley中一定有保留该对象的内容。

这可能对某些人有用，我将所有局部变量转换为WeakReference，并安装LeakCanary库以监控内存泄漏。至少现在一切都好了，所有LiveRemoteModel实例在GC事件发生后都会释放出来