Rxjava Realm从错误的线程访问

4 回答

• -1

  您只能在事务中操作Realm对象，或者只能在读/写这些对象的线程中操作 . 在您的情况下，您从readData方法获取RealmResult并使用RxJava切换导致异常的线程 . 使用copyFromRealm从realm获取数据，它将它们作为普通对象而不是realm对象返回 .

  回复于 2024-05-03T18:45:00+08:00
• 6

  The only rule to using Realm across threads is to remember that Realm, RealmObject or RealmResults instances cannot be passed across threads .

  如果要从不同的线程访问相同的数据，只需获取 a new Realm instance （即 Realm.getDefaultInstance() ）并通过查询获取对象（然后在线程末尾关闭Realm） .

  对象将映射到磁盘上的相同数据，并且可以从任何线程读取和写入！您也可以使用 realm.executeTransactionAsync() （如this）在后台线程上运行代码 .

  回复于 2024-05-03T18:45:00+08:00
• 2

  我如何使用正确的线程来遵循这个逻辑？

  通过不尝试在 Schedulers.io() 上读取您的UI线程（Realm提供自动更新延迟加载的代理视图，毕竟为UI线程上的数据提供更改通知） .

  ---

  所以不要这样

  mSubscribe = Observable.just(readData())
          .delay(DELAY, TimeUnit.SECONDS)
          .filter(value -> !value.isEmpty())
          .switchIfEmpty(createRequest())
          .subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread()).subscribe(data -> {
              getView().hideLoading();
              writeData(data);
          }, 
         (throwable -> {
          }));
  
  private List<CategoryModel> readData() {
      Realm defaultInstance = Realm.getDefaultInstance();
      List<CategoryModel> title = defaultInstance.where(CategoryModel.class).findAllSorted("title");
  
      defaultInstance.close();
      return title;
  }
  
  private void writeData(List<CategoryModel> categoryModels) {
      try {
          Realm defaultInstance = Realm.getDefaultInstance();
          defaultInstance.executeTransactionAsync(realm -> realm.insertOrUpdate(categoryModels));
          defaultInstance.close();
      } finally {
          getView().notifyActivity(categoryModels);
      }
  }
  

  你应该有类似的东西

  private Observable<List<CategoryModel>> readData() { // Flowable with LATEST might be better.
      return io.reactivex.Observable.create(new ObservableOnSubscribe<List<CategoryModel>>() {
          @Override
          public void subscribe(ObservableEmitter<List<CategoryModel>> emitter)
                  throws Exception {
              final Realm observableRealm = Realm.getDefaultInstance();
              final RealmResults<CategoryModel> results = observableRealm.where(CategoryModel.class).findAllSortedAsync("title");
              final RealmChangeListener<RealmResults<CategoryModel>> listener = results -> {
                  if(!emitter.isDisposed() && results.isLoaded()) {
                      emitter.onNext(results);
                  }
              };
  
              emitter.setDisposable(Disposables.fromRunnable(() -> {
                  if(results.isValid()) {
                      results.removeChangeListener(listener);
                  }
                  observableRealm.close();
              }));
              results.addChangeListener(listener);
          }
      }).subscribeOn(AndroidSchedulers.mainThread())
              .unsubscribeOn(AndroidSchedulers.mainThread());
  }
  
  private void setSubscription() {
      mSubscribe = readData()
              .doOnNext((list) -> {
                  if(list.isEmpty()) {
                      Single.fromCallable(() -> this::createRequest)
                              .subscribeOn(Schedulers.io())
                              .subscribe((data) -> {
                                  writeData(data);
                              });
                  }
              }).subscribe(data -> {
                  if(!data.isEmpty()) {
                      getView().hideLoading();
                      getView().notifyActivity(data);
                  }
              }, throwable -> {
                  throwable.printStackTrace();
              });
  }
  
  private void writeData(List<CategoryModel> categoryModels) {
      try(Realm r = Realm.getDefaultInstance()) {
          r.executeTransaction(realm -> realm.insertOrUpdate(categoryModels));
      }
  }
  
  void unsubscribe() {
      mSubscribe.dispose();
      mSubscribe = null;
  }
  

  这样（如果我没有弄乱任何东西），你最终会得到here和here所描述的被动数据层，除非没有映射出整个结果的额外开销 .

  EDIT:

  从Realm 4.0开始，可以直接将RealmResults公开为Flowable（在UI线程或后台循环线程上） .

  public Flowable<List<MyObject>> getLiveResults() {
      try(Realm realm = Realm.getDefaultInstance()) {
          return realm.where(MyObject.class) 
                      .findAllAsync()
                      .asFlowable()
                      .filter(RealmResults::isLoaded);
      }
  }
  

  回复于 2024-05-03T18:45:00+08:00
• 0

  您需要从领域对象中提取所需的数据到POJO并使用map运算符发出POJO，以便使用Android主线程上的pojo从视图对象中更新 .

  回复于 2024-05-03T18:45:00+08:00