Java 将映射域对象从主线程切换到后台线程

我使用RxJava的原始领域包装器。这样：

Flowable<RealmResult<RealmUser> result =
realm.where(RealmUser.class)
.findAllAsync()
.asFlowable();

---

Flowable如果您不想微观管理实际执行查询的后台循环线程的存在：

private Observable<List<User>> createResults() {
    return Observable.create((ObservableOnSubscribe<List<User>>) emitter -> {
        Realm realm = Realm.getDefaultInstance();
        final RealmResults<RealmUser> results = realm.where(RealmUser.class).findAllAsync();

        final RealmChangeListener<RealmResults<RealmUser>> realmChangeListener = element -> {
            if(element.isLoaded() && !emitter.isDisposed()) {
                List<User> users = mapFrom(element);
                if(!emitter.isDisposed()) {
                    emitter.onNext(users);
                }
            }
        };
        emitter.setDisposable(Disposables.fromAction(() -> {
            if(results.isValid()) {
                results.removeChangeListener(realmChangeListener);
            }
            realm.close();
        }));
        results.addChangeListener(realmChangeListener);
    }).subscribeOn(looperScheduler.getScheduler()).unsubscribeOn(looperScheduler.getScheduler());
}

私有可观察createResults（）{
返回可观察的。创建（（ObservableOnSubscribe）发射器->{
Realm Realm=Realm.getDefaultInstance（）；
最终RealmResults results=realm.where（RealmUser.class）.findalsync（）；
最终RealmChangeListener RealmChangeListener=元素->{
if（element.isLoaded（）&&！emitter.isDisposed（））{
列表用户=mapFrom（元素）；
如果（！emitter.isDisposed（））{
emitter.onNext（用户）；
}
}
};
发射器.设置一次性（一次性.来自动作（（）->{
if（results.isValid（））{
结果：removeChangeListener（realmChangeListener）；
}
realm.close（）；
}));
结果：addChangeListener（realmChangeListener）；
}).subscribeOn（looperScheduler.getScheduler（））.unsubscribeOn（looperScheduler.getScheduler（））；
}

然后，您可以执行以下捷径，尽管它会对查询求值两次：

Flowable<RealmResult<RealmUser> result =
    realm.where(RealmUser.class)
         .findAllAsync()
         .asFlowable()
         .subscribeOn(AndroidSchedulers.mainThread())
         .unsubscribeOn(AndroidSchedulers.mainThread())
         .filter(RealmResults::isLoaded)
         .observeOn(Schedulers.from(singleThreadedExecutor))
         .map((ignored) -> {
             RealmConfiguration configuration = realm.getConfiguration();
             try(Realm realm = Realm.getInstance(configuration)) {
                 RealmResults<RealmUser> results = realm.where(RealmUser.class).findAll();
                 return mapToUsersList(results);
             }
         })
         .observeOn(AndroidSchedulers.mainThread())
         .subscribe((users) -> { ...

可流动{
RealmConfiguration配置=realm.getConfiguration（）；
try（Realm=Realm.getInstance（配置））{
RealmResults results=realm.where（RealmUser.class）.findAll（）；
返回MapToUserList（结果）；
}
})
.observeOn（AndroidSchedulers.mainThread（））
.subscribe（（用户）->{。。。
一个可能的选择是使用我调用的库，它将数据公开为LiveData，在后台线程上观察查询更改，并允许在所述后台线程上进行映射。为什么不切换到另一个带有observeOn的调度程序并映射模型，然后在主线程上使用它们呢again@elmorabea请阅读我的问题再次打开。您还原我需要的内容。RealmResult无法切换到不同的线程（从主线程到后台）。第一个示例中的LoopersScheduler是什么？
AndroidScheduler.from（handlerThread.GetLoop（））
，但您可以查看