【Rxjava详解】(七)线程调度原理

最新推荐文章于 2024-05-13 14:51:57 发布
最新推荐文章于 2024-05-13 14:51:57 发布
阅读量798 收藏 8
点赞数 22
分类专栏： Rxjava 文章标签： rxjava android java 观察者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73871834/article/details/134612931
版权

rxjava最终章

// 创建一个被观察者，在后台线程执行网络请求
        Observable<String> observable = Observable.just("Network Response")
                .subscribeOn(Schedulers.io())
                .doOnNext(result -> {
                    // 模拟网络请求的耗时操作
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Network request executed on: " + Thread.currentThread().getName());
                });

        // 创建一个观察者，在新线程更新UI
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("Observer subscribed on: " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(String result) {
                System.out.println("Observer received result: " + result + " on: " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("Observer received error: " + e.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("Observer completed on: " + Thread.currentThread().getName());
            }
        };

        // 订阅观察者
        observable.observeOn(Schedulers.newThread())
                .subscribe(observer);

输出结果:

Observer subscribed on: main
Network request executed on: RxCachedThreadScheduler-1
Observer received result: Network Response on: RxNewThreadScheduler-1
Observer completed on: RxNewThreadScheduler-1

subscribeOn源码分析

直接看源码吧

public final Observable<T> subscribeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    // 创建一个新的 Observable 对象，该对象会在指定的 Scheduler 上执行订阅操作
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<>(this, scheduler));
}

// ObservableSubscribeOn 类实现了 ObservableOperator 接口，用于将订阅操作切换到指定的 Scheduler 上执行
static final class ObservableSubscribeOn<T> extends Observable<T> implements ObservableConverter<T, Observable<T>> {
    final ObservableSource<T> source;
    final Scheduler scheduler;

    ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        this.source = source;
        this.scheduler = scheduler;
    }

    @Override
    public Observable<T> apply(Observable<T> upstream) {
        return new ObservableSubscribeOn<>(upstream, scheduler);
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        // 创建一个 SubscribeOnObserver 对象，用于在指定的 Scheduler 上执行订阅操作
        SubscribeOnObserver<T> parent = new SubscribeOnObserver<>(observer);
        // 将 SubscribeOnObserver 对象传递给指定的 Scheduler，以便在 Scheduler 上执行订阅操作
        scheduler.scheduleDirect(new SubscribeTask(parent));
    }

    // SubscribeTask 实现了 Runnable 接口，用于在指定的 Scheduler 上执行订阅任务
    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver<T> parent;

        SubscribeTask(SubscribeOnObserver<T> parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            // 订阅操作的核心方法，调用 source.subscribe() 方法，执行实际的订阅操作
            source.subscribe(parent);
        }
    }

    // SubscribeOnObserver 实现了 Observer 接口，用于将订阅事件转发给实际的观察者
    static final class SubscribeOnObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        volatile boolean disposed;
        Disposable upstream;

        SubscribeOnObserver(Observer<? super T> downstream) {
            this.downstream = downstream;
        }

        @Override
        public void onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                this.upstream = d;
                downstream.onSubscribe(this);
            }
        }

        @Override
        public void onNext(T value) {
            downstream.onNext(value);
        }

        @Override
        public void onError(Throwable e) {
            downstream.onError(e);
        }

        @Override
        public void onComplete() {
            downstream.onComplete();
        }

        @Override
        public void dispose() {
            disposed = true;
            upstream.dispose();
        }

        @Override
        public boolean isDisposed() {
            return disposed;
        }
    }
}

subscribeOn 操作符返回一个新的 Observable 对象 ObservableSubscribeOn，该对象包装了原始的 Observable 对象和指定的 Scheduler。

当调用 subscribe 方法时，会创建一个 SubscribeOnObserver 对象，并将其传递给指定的 Scheduler 的 scheduleDirect 方法。SubscribeOnObserver 实现了 Observer 接口，用于将订阅事件转发给实际的观察者。

在 SubscribeTask 的 run 方法中，调用 source.subscribe(parent) 方法执行实际的订阅操作。这样，订阅操作就会在指定的 Scheduler 上执行，从而实现了切换订阅操作的线程。

总结：subscribeOn 操作符通过创建一个新的 Observable 对象，并在指定的 Scheduler 上执行订阅操作，从而实现了切换订阅操作线程

observeOn源码分析

高能预警长文来袭！

public final Observable<T> observeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    // 创建一个新的 Observable 对象，该对象会在指定的 Scheduler 上执行观察操作
    return RxJavaPlugins.onAssembly(new ObservableObserveOn<>(this, scheduler));
}

// ObservableObserveOn 类实现了 ObservableOperator 接口，用于将观察操作切换到指定的 Scheduler 上执行
static final class ObservableObserveOn<T> extends Observable<T> implements ObservableConverter<T, Observable<T>> {
    final ObservableSource<T> source;
    final Scheduler scheduler;

    ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler) {
        this.source = source;
        this.scheduler = scheduler;
    }

    @Override
    public Observable<T> apply(Observable<T> upstream) {
        return new ObservableObserveOn<>(upstream, scheduler);
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        // 创建一个 ObserveOnObserver 对象，用于在指定的 Scheduler 上执行观察操作
        Observer<? super T> target = scheduler.createWorker().schedule(new ObserveOnObserver<>(observer, scheduler), 0, TimeUnit.MILLISECONDS);
        // 调用 source.subscribe() 方法，将 ObserveOnObserver 对象传递给原始的 Observable 对象，执行实际的观察操作
        source.subscribe(target);
    }

    // ObserveOnObserver 实现了 Observer 接口，用于将观察事件转发给实际的观察者
    static final class ObserveOnObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        final Scheduler scheduler;
        Disposable upstream;
        // 用于存放观察事件的队列
        final SimpleQueue<T> queue;
        // 用于标识观察者是否已经完成
        volatile boolean done;
        // 用于标识观察者是否已经取消订阅
        volatile boolean disposed;
        Throwable error;

        ObserveOnObserver(Observer<? super T> downstream, Scheduler scheduler) {
            this.downstream = downstream;
            this.scheduler = scheduler;
            // 使用 SpscLinkedArrayQueue 创建一个无界队列
            this.queue = new SpscLinkedArrayQueue<>(bufferSize());
        }

        @Override
        public void onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                this.upstream = d;
                downstream.onSubscribe(this);
            }
        }

        @Override
        public void onNext(T value) {
            if (done) {
                return;
            }
            // 将观察事件放入队列
            queue.offer(value);
            // 调度队列中的观察事件进行消费
            schedule();
        }

        @Override
        public void onError(Throwable e) {
            if (done) {
                RxJavaPlugins.onError(e);
                return;
            }
            error = e;
            done = true;
            // 调度队列中的观察事件进行消费
            schedule();
        }

        @Override
        public void onComplete() {
            if (done) {
                return;
            }
            done = true;
            // 调度队列中的观察事件进行消费
            schedule();
        }

        @Override
        public void dispose() {
            disposed = true;
            upstream.dispose();
            scheduler.dispose();
        }

        @Override
        public boolean isDisposed() {
            return disposed;
        }

        // 调度队列中的观察事件进行消费
        void schedule() {
            // 如果已经在调度中，则直接返回
            if (getAndIncrement() != 0) {
                return;
            }
            // 循环消费队列中的观察事件
            for (;;) {
                if (disposed) {
                    return;
                }
                // 从队列中取出观察事件
                T v;
                try {
                    v = queue.poll();
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    disposed = true;
                    upstream.dispose();
                    onError(e);
                    scheduler.dispose();
                    return;
                }
                // 如果观察事件为空，表示队列已经消费完毕
                if (v == null) {
                    // 检查是否已经完成观察
                    if (done) {
                        Throwable ex = error;
                        if (ex != null) {
                            downstream.onError(ex);
                        } else {
                            downstream.onComplete();
                        }
                        scheduler.dispose();
                    }
                    return;
                }
                // 将观察事件发送给实际的观察者
                downstream.onNext(v);
                // 如果队列中还有更多的观察事件，则继续消费
            }
        }
    }
}

在 subscribeActual 方法中，创建一个 ObserveOnObserver 对象，并使用指定的 Scheduler 的 createWorker 方法创建一个 Worker。然后，调用 schedule 方法将 ObserveOnObserver 对象传递给 Worker，以便在指定的 Scheduler 上执行观察操作。最后，调用 source.subscribe 方法，将 ObserveOnObserver 对象传递给原始的 Observable 对象，执行实际的观察操作。

在 ObserveOnObserver 中，使用 SpscLinkedArrayQueue 创建一个无界队列 queue，用于存放观察事件。当收到观察事件时，将其放入队列，并调用 schedule 方法进行消费。schedule 方法首先判断当前是否已经在调度中，如果是，则直接返回；否则，循环从队列中取出观察事件，并发送给实际的观察者。如果队列中已经没有观察事件，则检查是否已经完成观察，如果是，则发送 onError 或 onComplete 事件给实际的观察者

总结：observeOn 操作符通过创建一个新的 Observable 对象，并在指定的 Scheduler 上执行观察操作，同时，使用无界队列缓存观察事件，通过循环消费队列中的观察事件，实现异步观察

Schedulers类

Schedulers 类是用于提供不同类型的调度器（Scheduler）的工具类，前面的文章提到过他的几个相关方法和参数的使用。

public final class Schedulers {
    // 静态内部类，用于实现调度器的工厂方法
    static final class Factory {
        final AtomicReference<Scheduler> computationScheduler = new AtomicReference<>();
        final AtomicReference<Scheduler> ioScheduler = new AtomicReference<>();
        final AtomicReference<Scheduler> newThreadScheduler = new AtomicReference<>();
        final AtomicReference<Scheduler> singleScheduler = new AtomicReference<>();

        Scheduler createComputationScheduler() {
            // 创建计算调度器，如果已经存在则直接返回，否则创建新的计算调度器
            for (;;) {
                Scheduler current = computationScheduler.get();
                if (current != null) {
                    return current;
                }
                // 创建新的计算调度器
                Scheduler newInstance = createComputationScheduler0();
                if (computationScheduler.compareAndSet(null, newInstance)) {
                    return newInstance;
                }
            }
        }

        Scheduler createComputationScheduler0() {
            // 创建计算调度器
            return new ComputationScheduler();
        }

        Scheduler createIoScheduler() {
            // 创建 IO 调度器，如果已经存在则直接返回，否则创建新的 IO 调度器
            for (;;) {
                Scheduler current = ioScheduler.get();
                if (current != null) {
                    return current;
                }
                // 创建新的 IO 调度器
                Scheduler newInstance = createIoScheduler0();
                if (ioScheduler.compareAndSet(null, newInstance)) {
                    return newInstance;
                }
            }
        }

        Scheduler createIoScheduler0() {
            // 创建 IO 调度器
            return new IoScheduler();
        }

        Scheduler createNewThreadScheduler() {
            // 创建新线程调度器，如果已经存在则直接返回，否则创建新的新线程调度器
            for (;;) {
                Scheduler current = newThreadScheduler.get();
                if (current != null) {
                    return current;
                }
                // 创建新的新线程调度器
                Scheduler newInstance = createNewThreadScheduler0();
                if (newThreadScheduler.compareAndSet(null, newInstance)) {
                    return newInstance;
                }
            }
        }

        Scheduler createNewThreadScheduler0() {
            // 创建新线程调度器
            return new NewThreadScheduler();
        }

        Scheduler createSingleScheduler() {
            // 创建单线程调度器，如果已经存在则直接返回，否则创建新的单线程调度器
            for (;;) {
                Scheduler current = singleScheduler.get();
                if (current != null) {
                    return current;
                }
                // 创建新的单线程调度器
                Scheduler newInstance = createSingleScheduler0();
                if (singleScheduler.compareAndSet(null, newInstance)) {
                    return newInstance;
                }
            }
        }

        Scheduler createSingleScheduler0() {
            // 创建单线程调度器
            return new SingleScheduler();
        }
    }

    // 创建调度器工厂
    private static final Schedulers.Factory DEFAULT_SCHEDULER_FACTORY = new Schedulers.Factory();

    // 私有构造函数，防止实例化
    private Schedulers() {
        throw new IllegalStateException("No instances!");
    }

    // 获取计算调度器
    public static Scheduler computation() {
        return DEFAULT_SCHEDULER_FACTORY.createComputationScheduler();
    }

    // 获取 IO 调度器
    public static Scheduler io() {
        return DEFAULT_SCHEDULER_FACTORY.createIoScheduler();
    }

    // 获取新线程调度器
    public static Scheduler newThread() {
        return DEFAULT_SCHEDULER_FACTORY.createNewThreadScheduler();
    }

    // 获取单线程调度器
    public static Scheduler single() {
        return DEFAULT_SCHEDULER_FACTORY.createSingleScheduler();
    }

    // 获取当前线程调度器
    public static Scheduler trampoline() {
        return TrampolineScheduler.instance();
    }
}
xoliu1
关注
  • 22
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RxJava线程控制详细解说
u012366540的博客
01-03 242
以Android为例, 一个Activity的所有动作默认都是在主线程中运行的, 比如我们在onCreate中打出当前线程的名字: Log.w(TAG, “observable-----Thread” + Thread.currentThread().getName()); 结果是 observable-----Threadmain 线程控制 —— Scheduler (一) 在不指定线程的情况下...
RxJava线程切换代替Thread和Handler
Lange0x0的博客
07-09 4266
在我们的日常开发中，我们可能会经常涉及到线程的切换，比如：需要在子线程中加载数据库中的数据，一般情况下，我们会这样做： new Thread(new Runnable() { @Override public void run() { //do something } }).sta
RXJava——线程控制 —— Scheduler (一)
jushenziao的博客
06-27 4740
原文链接：http://gank.io/post/560e15be2dca930e00da1083 在不指定线程的情况下， RxJava 遵循的是线程不变的原则，即：在哪个线程调用 subscribe()，就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。如果需要切换线程，就需要用到 Scheduler （调度器）。 1) Scheduler 的 API (一)
Android函数响应式编程——RxJava的4大subject和线程控制
qq_36523667的博客
12-10 626
Subject Subject既可以是一个Observer也可以是一个Observable，它用来连接两者。所以Subject被认为是Subject=Observable+Observer 1.PublishSubject PublishSubject在被创建完成之后立刻开始发射数据，所有有一个风险：在所有的订阅者订阅之前，数据可能已经发送了 。 解决方法：1.确保所有订阅者的订阅比这
RxJava(三) — 线程调度实现原理
Elson的博客
05-31 981
RxJava 是一个响应式编程框架，里面代码比较复杂，本系列文章将从以下几个角度来分析这个框架。 1. RxJava 的链路调用流程。 2. RxJava 的常用操作符 `map、flatmap`。 3. RxJava 的线程调度。 4. 自己实现一个简易版的响应式框架。
给Android开发者的RxJava详解
02-25
我从去年开始使用RxJava，到现在一年多了。今年加入了Flipboard后，看到Flipboard的Android项目也在使用RxJava，并且使用的场景越来越多。而最近这几个月，我也发现国内越来越多的人开始提及RxJava。有人说『RxJava...
kubernetes调度原理详解
04-19
kubernetes 调度原理详解 Kubernetes 调度原理是 Kubernetes 集群中资源的核心组件，负责将容器分配到合适的节点上，以便高效地使用资源。调度原理是保证 Kubernetes 集群高可用和高效的重要组件。 1. Limit Range...
给 Android 开发者的 RxJava 详解
09-26
Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，现在已经支持几乎全部的流行编程语言了
rxjava详解
05-15
给 Android 开发者的 RxJava 详解,它扩展了观察者模式以支持数据和/或事件序列，并增加了运算符，使您可以声明性地组合序列，同时抽象出对低级线程，同步，线程安全性，并发数据结构和非线程等事物的关注阻塞I / O
面试：Rxjava线程调度使用
王温暖的博客
12-13 1053
RxJava2线程调度使用： 最简单易懂的RxJava2.0学习教程之RxJava2的线程调度（二）_简简单单_zz的博客-CSDN博客 使用RxJava的时候，在没有切换线程的情况下, 上游==被观察者(observable)和下游==观察者(observer)是工作在同一个线程中的,即都在主线程中。 话不多说上代码： Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Int
线程池参考
06-04
线程池参考，给出线程池相关方面的最佳建议，这也是从别的地方粘贴的，说得还不错
最简单易懂的RxJava2.0学习教程之RxJava2的线程调度（二）
08-29
最简单易懂的RxJava2.0学习教程之RxJava2的线程调度
RxJava线程切换操作符
tinysakura的博客
02-25 320
转载自安德雷士的RxJava线程切换——ObserveOn和SubscribeOn的区别 RxJava很优势的一个方面就是他的线程切换，基本是依靠ObserveOn和SubscribeOn这两个操作符来完成的。 先来看看什么是ObserveOn和SubscribeOn，官方对他们的定义是这样的： ObserveOn specify the Scheduler on which an observ...
Rxjava线程操作
路漫漫其修远兮
07-25 2928
目录 (一)：Rx简介 (二)：Rxjava基础知识 (三)：Rxjava创建操作符
RxJava中线程调度用法，指定在主/子线程中执行
一条小船的博客
05-03 4140
终于到了这个时刻，Android中的定律，主线程不做耗时操作，子线程不更新ui。 这次也是根据给初学者的RxJava2.0教程(二)进入下面的学习。 直接上代码 private TextView mTextView; public RxJavaThread(TextView textView) { mTextView = textView; } ...
详解 RxJava 的消息订阅和线程切换原理
weixin_34268753的博客
06-13 289
本文由玉刚说写作平台提供写作赞助 原作者：四月葡萄 版权声明：本文版权归微信公众号 玉刚说 所有，未经许可，不得以任何形式转载 1.前言 本文主要是对RxJava的消息订阅和线程切换进行源码分析，相关的使用方式等不作详细介绍。 本文源码基于rxjava:2.1.14。 2. RxJava简介 RxJava is a Java VM implementation of Reactive Ext...
RxJava（十五）RxJava 线程的自由切换
热门推荐
Chiclaim
04-21 1万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
RxJava线程调度源码解析
0-0Xuan的专栏
12-28 1377
转载请保留原文链接:http://blog.csdn.net/u010593680/article/details/53911475先看一个简单的使用,下例子在io线程中模拟获取了图片,并在主线程(Android)中输出了该图片: Observable.create(new Observable.OnSubscribe<String>() { @Override
QLExpress入门及实战总结
最新发布
Myron_007的博客
05-13 807
研究学习QLExpress在低代码领域的使用
详解Geardown实现原理
06-01
Geardown模式是DDR5协议中一种使用2N模式的技术，它的实现原理和应用条件如下： 1. 原理 Geardown模式的实现原理是在DDR5内部使用2倍频率的时钟进行操作。在这种模式下，Command/Address bus的速度被设置为2倍频率，然后在DRAM内部使用2倍频率的时钟进行读写等操作。这样可以有效地减少Command/Address bus的速度，从而提高稳定性。 2. 应用条件 Geardown模式需要特殊的DRAM支持，并且只能在支持7200及以上数据速率的DRAM上使用。此外，Geardown模式还需要进行相关的设置才能启用。具体来说，启用Geardown模式需要在DRAM上电时使用MPC命令进行设置，并且在从自刷新中退出时根据DRAM的设置进行相应的操作。同时，为了保证系统的稳定性，需要在任何上电初始化后完成CSTM和CATM操作。 总的来说，Geardown模式是DDR5协议中一种有效提高Command/Address bus稳定性的技术，但是需要特殊的DRAM支持和相关的设置才能使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xoliu1

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值