RxJava observeOn currentThread调用opengl函数
RxJava是一个基于观察者模式的异步编程库，它可以帮助开发者更方便地处理异步任务和事件流。在RxJava中，observeOn操作符用于指定观察者在哪个线程上接收事件。currentThread是RxJava中的一个调度器，它表示当前线程。
当调用observeOn(currentThread)时，意味着观察者将在当前线程上接收事件。这种情况下，事件的发射和接收都在同一个线程上进行，不会引入线程切换的开销。这在某些场景下是非常有用的，比如在UI线程中进行UI更新操作。
关于OpenGL函数，它是一套用于渲染2D和3D图形的API。在移动开发和游戏开发中，OpenGL被广泛应用于图形渲染和图形加速。使用OpenGL函数可以实现各种图形效果和交互操作。
对于RxJava中的observeOn(currentThread)调用opengl函数的情况，可以考虑以下几点：
- 线程安全：OpenGL函数通常需要在特定的线程上调用，比如OpenGL ES中的渲染线程。因此，在使用RxJava时，需要确保在正确的线程上调用OpenGL函数，以避免线程安全问题。
- 线程切换：如果在observeOn(currentThread)之后调用OpenGL函数，那么事件将在当前线程上接收，而OpenGL函数需要在特定的线程上调用。在这种情况下，需要进行线程切换，将事件切换到OpenGL渲染线程上执行OpenGL函数。
- 腾讯云相关产品：腾讯云提供了一系列云计算产品和服务，可以帮助开发者构建和管理云端应用。在与RxJava和OpenGL结合使用时，可以考虑使用腾讯云的云服务器、云数据库、云存储等产品，以满足应用的需求。
请注意，以上答案仅供参考，具体的实现方式和产品选择应根据具体需求和场景来确定。
相关·内容
这是我在Kotlin的测试代码：
fun main() {
rxjava()
}
fun rxjava() {
val queuSubject = PublishSubject.create<String>()
queuSubject
.map { t ->
val a = t.toLong()
Thread.sleep(6000 / a)
println("map $a called ${Thread.currentThread().name} "
浏览 2提问于2021-07-02得票数 1
回答已采纳
2回答
我对rxJava/Android很陌生，我的onError lambda有时在主线程上被调用，有时不被调用，尽管我使用.observeOn(AndroidSchedulers.mainThread())。
示例1:主线程上的onError
这与预期的一样工作:在主线程上调用onError。
Observable.error(new RuntimeException("RTE"))
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscri
浏览 3提问于2016-10-03得票数 9
回答已采纳
我正面临来自RxJava的这个错误
Android“只有创建视图层次结构的原始线程才能触摸其视图”。
我用的代码
Log.d(TAG, "stratObserving:qw ${Thread.currentThread()}")
(application as? App)?.relayPages
?.doAfterNext{
hideLoading()
}
?.observeOn(AndroidSchedulers.mainThread())
浏览 4提问于2020-05-09得票数 0
回答已采纳
1回答
假设我有一个区间，我给它一个computationScheduler。如下所示：
Observable
.interval(0, 1, TimeUnit.SECONDS, computationScheduler)
.flatMap { ... }
那么，平面图{.}中发生的所有事情也会在计算线程上调度吗？
在Observable.interval(长initialDelay，长周期，TimeUnit单元，调度器)的源程序中，它说：
* @param scheduler
* the Scheduler on which the waiting happens and ite
浏览 4提问于2020-08-24得票数 1
回答已采纳
5回答
我使用RxJava可观察的api编写了以下代码：
Observable<Info> observable = fileProcessor.processFileObservable(processedFile.getAbsolutePath());
observable
.buffer(10000)
.observeOn(Schedulers.computation())
.subscribe(recordInfo -> {
_logger.info("Running stage2 on thread wit
浏览 3提问于2016-02-16得票数 39
回答已采纳
我正在尝试使用RxJava2异步启动Firebase作业分派器。
@Override
public boolean onStartJob(JobParameters job) {
Completable.fromAction(new Action() {
@Override
public void run() throws Exception {
startMethod();
}
}).subscribeOn(mSchedulerProvider.io())
浏览 10提问于2018-01-17得票数 1
1回答
我有一个非常简单的RxJava示例
List<Integer> arrayIntegers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Observable.fromIterable(arrayIntegers).map(i -> {
Log.d("RxJava", "map i = " + i);
return i;
}).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainT
浏览 5提问于2017-11-01得票数 1
回答已采纳
我有一个调用webservice的方法，我认为这个方法在IO线程上运行，直到服务停止，UI冻结。
所以我开始了一些简单的测试来检查线程
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
implementation 'io.reactivex.rxjava2:rxjava:2.1.8'
public void test() {
disposableRx.add(
Observable.just(1, 2)
.subscribeO
浏览 0提问于2018-01-19得票数 8
回答已采纳
我正在运行RxJava并创建一个使用onNext()方法生成数据的subject。我正在使用Spring。
这是我的设计：
@Component
public class SubjectObserver {
private SerializedSubject<SomeObj, SomeObj> safeSource;
public SubjectObserver() {
safeSource = PublishSubject.<SomeObj>create().toSerialized();
**safeSource.subs
浏览 3提问于2016-10-25得票数 1
回答已采纳
我正在处理这个问题。
我试图以同步的方式调用RxJava，但是这样做会导致阻塞主线程。
以下是我的代码
@Override
public Single<SettingsBundle> getSettings() {
SettingsBundle settingsModel = mSettingsManager.getSettings();
return Single.just(settingsModel).map(mSettingsMapper);
}
这是我的同步电话
@Override
public Setti
浏览 1提问于2017-10-07得票数 8
1回答
我希望从flatMap发出的每一项都在自己的线程上运行。
这是一个简化的实际使用示例，其中每个项目都将是一个url请求。
在每个线程上添加subscribeOn(Schedulers.io())仍然在单个线程上运行
这里的规矩是什么？
Integer[] array= new Integer[100];
for (int i = 0; i < 100; i++){
array[i] = i+1;
}
Observable.fromArray(array)
.flatMapSingle(new Function<Integer, SingleSource&l
浏览 2提问于2020-12-17得票数 2
回答已采纳
我用的是RxJava2和SQLite房间。我的刀：
@Dao
public interface HeroDao {
@Insert
long create(Hero hero);
}
我就是这样在RxJava2中使用它的：
Observable.just((int) heroDao.create(hero))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(id -
浏览 2提问于2018-02-09得票数 4
回答已采纳
我有一个Rxjava程序集，如下所示：
val observable = dialogPresenter.show(dialogData, viewContext!!)
.subscribeOn(mainScheduler)
.observeOn(mainScheduler)
.doOnDispose(dialogData::dismiss)
当订阅被释放时，对dialogData::dismiss的调用发生在mainScheduler使用的线程以外的线程上，顾名思义，该线程为运行代码的特定平台使用主线程。doOn
浏览 1提问于2018-06-25得票数 0
大家好，我是反应式编程的新手，我只想知道如何使用此代码实现和处理一个新按钮。如果你知道答案，请写正确的代码。所以我要求的是用第二个按钮来实现这段代码，它可以做任何你想做的事情。我只需要看到用第二个按钮实现的这段代码。 package pcd.lab08.rx;
import javax.swing.*;
import io.reactivex.rxjava3.core.Scheduler;
import io.reactivex.rxjava3.schedulers.Schedulers;
import io.reactivex.rxjava3.subjects.PublishSub
浏览 10提问于2021-04-27得票数 3
回答已采纳
我在安卓系统上使用RxJava和Retroeft2.0来处理网络请求。
当我创建可观察的内容时，我会添加以下内容：
observable = observable
.observeOn(AndroidSchedulers.mainThread())
.subscribeOn(Schedulers.io())
.unsubscribeOn(Schedulers.io())
如果我加一个：
observable = observable.doOnTerminate(new Action0() {
@Override
浏览 1提问于2015-11-02得票数 7
回答已采纳
1回答
如何与RxJava并发处理文本行
、、、、
我想知道如何将文本行与RxJava并发处理。现在，我所拥有的是一个可以观察到的入口集，以及一个在每个条目上处理onNext调用中的条目的订阅者。订阅者使用这一行代码订阅可观察到的内容。
obs.observeOn(Schedulers.io()).subscribe(sub);
但是当我运行它时，它的运行速度和顺序版本一样慢，并且似乎是按顺序处理的。我怎样才能做到这一点呢？
浏览 6提问于2015-06-26得票数 2
回答已采纳
1回答
假设我想显示服务器上的一些用户数据。我会搜索服务器，缓存它，然后将它呈现给用户。所以我的初始RxJava代码应该是这样的：
ApiClient.getUser(userId), //An Observable that will spit out a UserResponse
.subscribeOn(Schedulers.io()) //for the API observable (Do i need this?)
.flatMap(new Func1<UserResponse, Observable<DatabasePutResult>>() {
浏览 1提问于2015-11-09得票数 1
回答已采纳
嗨，我刚开始学习使用RxJava2的反应性编程。如何创建在后台线程中运行的任务，然后使用RxJava2在主线程上完成任务。
在Android中，我们使用AsyncTask，如下所示
private class MyTask extends AsyncTask<String, Integer, Boolean>
{
@Override
protected Boolean doInBackground(String... paths)
{
for (int index = 0; index < paths.length; index++)
浏览 3提问于2017-04-21得票数 7
回答已采纳
我在玩rxJava/rxAndroid，有些非常基本的东西不像我期望的那样表现。我有一个可观察的和两个订户：
Observable<Integer> dataStream = Observable.just(1, 2, 3).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
Log.d(TAG, "subscribing sub1...");
dataStream.subscribe(v -> System.out.println("Subscriber #
浏览 2提问于2017-01-28得票数 21
回答已采纳
1回答
我有一个实现，其中我有两个单线程，它们是对数据库的并行调用，以获取对象。然后我使用rxjava zip运算符来聚合结果。如下所示： ...
(other code)
Single<A> a = Single.fromCallable(() -> {
System.out.println("Inside single a, running in thread " + Thread.currentThread().getName());
}).subscribeOn(Schedulers.io);
Single<B> b = Si
浏览 10提问于2021-05-07得票数 0
回答已采纳
我的问题是操作成本，特别是Kotlin、数据类copy()操作和RxJava observeOn()线程切换的成本。
我有一个在Schedulers.mainThread上产生事件的系统。事件是Kotlin数据类。接下来是业务逻辑，最后，该链通过copy()操作生成新的数据类。所有结果都必须在Schedulers.mainThread上使用。所以，一条链子看起来会是这样的：
eventSource() //Events are produced on Schedulers.mainThread
.observeOn(Schedulers.computation)
.map { event -&
浏览 1提问于2017-12-27得票数 0
回答已采纳
2回答
你好，RxJava大师，
在我当前的Android项目中，我在使用RxJava和SQLite时遇到了一些死锁问题。我的问题是：
我在线程上启动一个事务。
调用web服务并在数据库中保存一些内容
concat映射另一个可观测函数
尝试在数据库上编写其他内容
这是我的代码：
//define a scheduler for managing transaction in the same thread
private Scheduler mScheduler = Schedulers.from(Executors.newSingleThreadExecutor());
浏览 2提问于2016-07-06得票数 4
我正在尝试为Firebase Firestore调用创建一个可观察到的反应性。我正面临一个线程问题。我正在使用rxjava2来处理线程，我不希望Firestore为我这样做。似乎Fi还原调用是异步的，因此在主线程上调用OnSuccess方法。
下面是一个简单的例子，展示了这个问题：
Single<Integer> firestoreSingle = Single.create(emitter -> {
Log.d("TAG", Thread.currentThread().getName()); // -> RxCachedThreadSchedu
浏览 0提问于2019-06-24得票数 0
我面临着下一种情况。我用onHadleIntent方法启动我的代码，部分代码在IntentService线程中工作，但是getInfoAboutUser()中的Observable.zip方法在RxJava线程中工作。
@Override
protected void onHandleIntent(@Nullable Intent intent) {
LOG.debug(Thread.currentThread().getName());
Call<String> call= mRepository.getInfo();
try {
浏览 1提问于2018-01-20得票数 1
回答已采纳
考虑以下可观察的链
Observable.just(1).
doOnSubscribe(disposable -> Log.d("ThreadInDoSub", Thread.currentThread().getName())).
subscribe();
日志报告线程是主线程。这样就好了。现在
Observable.just(1).
doOnSubscribe(disposable -> Log.d("ThreadInDoSub", Thread.curren
浏览 2提问于2018-06-04得票数 0
回答已采纳
我是RxJava的新手，在一个(我猜)简单的问题上苦苦挣扎。我想在三个线程中简单地处理订阅部分。这就是为什么我使用FixedThreadPool。示例代码：
Observer.just("one", "two", "three", "four")
.observeOn(Schedulers.io())
.subscribeOn(Schedulers.from(Executors.newFixedThreadPool(3))
.subscribe(new Observer<String>() {
public
浏览 2提问于2015-10-21得票数 4
回答已采纳
1回答
请大家看一下下面的代码，让我知道为什么这是不同的行为：
package com.example.rxjava;
import rx.Observable;
import rx.functions.Action1;
import rx.schedulers.Schedulers;
public class MyRxJava {
public static void main(String[] args) {
System.out.println("getting sum ... by thread: " +
Thread.cur
浏览 0提问于2015-09-10得票数 0
回答已采纳
我有这个AsyncSubject
val asyncSubject = AsyncSubject.create<Int>()
observable.observeOn(AndroidSchedulers.mainThread())
.subscribeOn(Schedulers.newThread())
.subscribe(asyncSubject)
如果我在测试环境中这样做(androidTest文件夹)
asyncSubject.subscribe{
// enter only in test environment
}
它只在
浏览 16提问于2019-07-07得票数 0
1回答
订阅RxJava的第四个参数
、、、、
compositeDisposable.add(
myUseCase
.getData()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(
{
println(it)
},
浏览 4提问于2022-02-26得票数 0
嗨，我正在尝试使用rxjava repeatUntil轮询一个请求，但是遇到了一些错误。
下面是我的代码
accountDelegator.signUpReady(signUpRequest)
.observeOn(Schedulers.io())
.subscribeOn(AndroidSchedulers.mainThread())
.repeatUntil { response ->
if (response.isSuccesfull){
浏览 0提问于2018-03-23得票数 0
回答已采纳
由于Schedulers.trampoline()使作业在当前线程上工作，所以我无法找到使用Schedulers.trampoline()的情况与没有调度程序设置的情况之间的区别。
使用Schedulers.trampoline()
Observable.from(1, 2, 3)
.observeOn(Schedulers.trampoline())
.subscribe(System.out::println)
不使用调度程序：
Observable.from(1, 2, 3)
.subscribe(System.out::println)
我认为以上代码的作用是一
浏览 5提问于2016-10-25得票数 14
回答已采纳
1回答
我在Scala项目中使用RxJava，并说我有这个简单的Observable
Observable[String](observer => while (true) observer onNext "hi")
.subscribe(v => println(v))
println("hello")
我永远不会收到"hello“消息，因为while阻塞了一个线程。如何在单独的线程中运行Observable以避免阻塞？
==================================
我在想observeOn可以帮上忙，但它没有帮助。运
浏览 2提问于2014-06-04得票数 1
回答已采纳
1回答
我正在使用retrofit、rxjava和王国来构建一个应用程序。这就是我想要达到的目标：
从本地数据库加载数据，同时发出网络请求
第一次只显示加载程序
如果数据已经存在于DB中，则显示它并在某个地方显示小型加载程序。
当网络结果准备就绪时，更新列表并将结果保存到磁盘
如果网络结果失败，则显示要使用的消息，说明数据可能已经过时。
我知道如何使用领域，适当地对其进行改造，但rxjava部分令人困惑。有什么简单的方法可以用rxjava来完成这个任务呢？
当前的代码库是这样的：
CategoryRepository.java
public Observable<Li
浏览 2提问于2017-05-31得票数 1
我使用的是MVVM架构，我的数据层/存储库使用的是RxJava，而视图层的视图模型使用的是LiveData。
在我的视图模型中，我使用rxjava Observable.interval轮询服务器。
目前我的问题是，当底层视图(片段)进入暂停状态时，如何暂停轮询？
如果我删除rxjava到liveData的转换并直接在视图上观察rxjava，会不会使事情变得更容易呢？
public class MyViewModel extends ViewModel {
private final CompositeDisposable disposables = new CompositeDis
浏览 0提问于2018-04-10得票数 2
回答已采纳
我对doOnSuccess在rxJava中的用例感到困惑。
让我们看看代码：
案例1：
networkApi.callSomething()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.doOnSuccess(__ -> showLog(SUCCESS))
.doOnError(__ -> showLog(ERROR))
.subscribeBy(
onSuccess = {//Do
浏览 1提问于2019-03-15得票数 7
回答已采纳
1回答
Coroutines and RxJava3 我有以下方法，首先调用suspend方法，然后在相同的启动范围内调用RxJava。 我想知道是否有一种方法可以将Rxjava代码从viewModelScope.launch作用域中移除并返回fetchRecentUseCase.execute()的结果。 基本上，viewModelScope.launch是否有可能返回listOfProducts，而不是在启动范围内执行所有操作？ fun loadRecentlyViewed() {
viewModelScope.launch {
val listOfProducts =
浏览 45提问于2021-08-03得票数 0
回答已采纳
我有一个创建新的可观察性的用例：
Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
final RequestFuture<String> futureRequest = RequestFuture.newFuture();
try{
//getResult() is a sync time consumin
浏览 3提问于2016-02-23得票数 2
回答已采纳
使用"observeOn(Scheduler)"，Rxjava可观察到的seemes在从不同线程发出项时有时会遗漏一些项。
这是代码
val subject = PublishSubject.create<String>()
subject
.observeOn(Schedulers.io())
.subscribe { x: String? -> println(x) }
val t1 = Thread { subject.onNext("1") }
val t2 = Thread { subject.onNext(
浏览 3提问于2020-11-05得票数 0
回答已采纳
1回答
RxJava调用一次性处置()
、、、、
我正在使用rxjava进行改造。在下面的代码中，subscribeOn()和observeOn()继续运行。该应用程序的终止和自己不断推出。
disposable = api.getUsers("135")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe({
users -> showResult(users)
})
如
浏览 0提问于2018-09-08得票数 3
下面的MissingBackpressureException发生在OperatorOnBackpressureDrop应用于OperatorObserveOn之前
rx.exceptions.MissingBackpressureException
at rx.internal.operators.OperatorObserveOn$ObserveOnSubscriber.onNext(OperatorObserveOn.java:162) ~[rxjava-1.1.10.jar:1.1.10]
at rx.internal.operators.OperatorOnBackpressur
浏览 3提问于2016-10-18得票数 1
回答已采纳
1回答
我对RxJava非常陌生，所以我仍然很难使用它。我读了很多博客之类的文章，我还是有点迷茫。
所以-我想要一个清单，所有安装的应用程序。很简单。我不是在异步任务中运行它，而是尝试更花哨一点，使用RxJava。
我的想法是这样做：
private void test(){
Observable.from(getInstalledApps(true))
.observeOn(Schedulers.newThread())
.map(s -> s.appname)
.subscribe
浏览 2提问于2015-03-04得票数 1
回答已采纳
我在安卓系统中使用BehaviourSubject和RxJava2。在下面的链中，我接收一个NetworkOnMainThreadException，即使我是subscribeOn(schedulers.background())。
如果我在ObserveOn之后使用searchRequestSubject (schedulers.background())，我正确地进入了一个后台线程。
我希望使用subscribeOn会将所有的链都放到所提供的线程中？为什么它不这样工作？
private BehaviorSubject<SearchRequest> searchRequestSu
浏览 4提问于2017-04-19得票数 0
回答已采纳
4回答
WAnt使用RxJava2筛选列表。不知怎么起作用了。但问题是，它在Consumer回调中只返回列表中的一个项(大小总是1)。
以下是代码：
Observable.fromIterable(arraylist)
.filter(new Predicate<BasicListModel>() {
@Override
public boolean test(BasicListModel model) throws Exception {
浏览 1提问于2018-02-13得票数 1
回答已采纳
我在android中使用了RxJava和Retrofit 2，并且在订阅()之前调用了subscribeOn(Schedulers.io())、android observeOn(AndroidSchedulers.mainThread())全局。但是，有时我想调用subscribeOn(Schedulers.immediate()) android observeOn(Schedulers.immediate())来覆盖之前设置的调度器以获得同步进程。但是我发现它不起作用，android仍将在io()线程上进行处理，而android结果则由mainThread()处理。为什么？
浏览 1提问于2016-02-27得票数 5
回答已采纳
1回答
如何在安卓rxJava出现网络错误时重试网络调用。
下面是我的rxJave代码：
RxTextView.textChanges(searchInput)
.debounce(500, TimeUnit.MILLISECONDS)
.map(CharSequence::toString)
.filter(s -> !s.isEmpty())
.subscribeOn(AndroidSchedulers.mainThread())
.observeOn(Schedulers
浏览 7提问于2016-09-24得票数 0
这段代码开始于主线程，但我在Schedulers.io上使用了subscribeOn和observeOn
disposableBag.add(Single.just(HardOperation.get())
.doOnSuccess(it -> {
Log.i("123", Thread.currentThread() + " current"); // Thread[RxCachedThreadScheduler-1,5,main]
})
.sub
浏览 0提问于2020-04-03得票数 0
我想在我的kotlin应用程序中使用coroutine作为必须的。但是这个应用在很大程度上依赖于一个返回rxjava2类型对象的服务(所以我们的输入将是所有的rxjava类型)。我们怎么还能在这个模型应用中使用协程而不是rxjava2。我们是否应该创建一个只将rxjava对象转换为普通对象(或协程对象？)的层。或者我们可以将这两个一起使用，比如：
SomeObservable
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { value->
浏览 9提问于2021-10-06得票数 0
2回答
我尝试实现一个非常简单的RxAndroid2示例。当我试图运行这段代码时，它让我感到困惑。
ArrayList<Integer> arr = new ArrayList<>();
arr.add(0);
arr.add(1);
arr.add(2);
arr.add(3);
arr.add(4);
arr.add(5);
arr.add(6);
Observable.fromIterable(arr)
.subscribeOn(Schedulers.newThread())
浏览 6提问于2017-07-26得票数 2
回答已采纳
2回答
我正在努力理解rxJava，我正在寻找一位专家或有经验的人来尝试解决我的问题，问题是我已经使用RxJava一年了，但只针对Retrofit调用，我一直在使用Disposable，并做了一些类似的事情：
disposable = myService.myInterface.getData()
.observeOn(AndroidSchedulers.mainThread())
.subscribeOn(Schedulers.io())
.subscribe(this::handleResponse,
浏览 0提问于2019-05-06得票数 0
我有一个非常简单的RxJava示例
List<Integer> arrayIntegers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Observable.fromIterable(arrayIntegers).map(i -> {
Log.d("RxJava", "map i = " + i);
return i;
}).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainT
浏览 4提问于2017-11-01得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
