willwaywang6
willwaywang6

Android筑基——RxJava框架学习笔记

目录

  • 1. 前言
  • 2. 正文
    • 2.1 RxJava 里的观察者模式和普通的观察者模式有什么区别？
    • 2.2 RxJava 观察者模式的订阅流程
      • 2.2.1 创建自定义 `Observer` 对象
      • 2.2.2 创建 `ObservableOnSubscribe` 对象
      • 2.2.3 创建 `ObservableCreate` 对象
      • 2.2.4 调用`Observable.subscribe()` 订阅方法
      • 2.2.5 创建 `CreateEmitter` 对象
      • 2.2.6 发送 `onNext()` 以及 `onComplete()` 事件
    • 2.3 RxJava 的 map 操作符的流程是什么样子的？
      • 2.3.1 创建自定义`Observer` 对象
      • 2.3.2 创建 `ObservableOnSubscribe` 对象
      • 2.3.3 创建 `ObservableCreate` 对象
      • 2.3.4 创建封装了变换操作的`Function` 对象
      • 2.3.5 创建 `ObservableMap` 对象
      • 2.3.6 调用 `ObservableMap` 的 `subscribe` 方法
      • 2.3.7 创建 `MapObserver` 对象
      • 2.3.8 调用 `ObservableCreate` 对象的 `subscribe` 方法
      • 2.3.9 创建 `CreateEmitter` 对象
      • 2.3.10 调用 `MapObserver` 对象的 `onSubscribe` 方法
      • 2.3.11 `CreateEmitter` 对象调用 `onNext` 以及 `onComplete` 方法
      • 2.3.12 `MapObserver` 对象调用 `onNext` 以及 `onComplete` 方法
    • 2.4 `subscribeOn()` 流程分析
      • 2.4.1 创建自定义`Observer` 对象
      • 2.4.2 创建 `ObservableOnSubscribe` 对象
      • 2.4.3 创建 `ObservableCreate` 对象
      • 2.4.4 调用 `Schedulers.io()` 方法
      • 2.4.5 调用 `ObservableCreate` 对象的 `subscribeOn`方法
      • 2.4.6 调用 `ObservableSubscribeOn` 的 `subscribe` 方法，参数为自定义观察者
      • 2.4.7 创建 `SubscribeOnObserver` 对象
      • 2.4.8 创建 `SubscribeTask` 对象
      • 2.4.9 调用 `IoScheduler` 单例对象的 `scheduleDirect()` 方法
      • 2.4.10 调用 `IoScheduler` 单例对象的 `createWorker()` 方法
      • 2.4.11 调用 `EventLoopWorker` 对象的 `schedule` 方法
      • 2.4.12 调用 `ThreadWorker` 对象的 `scheduleActual` 方法
      • 2.4.13 调用 `ScheduledRunnable` 对象的 `run()` 方法
      • 2.4.14 调用 `DisposeTask` 对象的 `run()` 方法
      • 2.4.15 调用 `SubscribeTask` 对象的 `run()` 方法
      • 2.4.16 调用 `ObservableCreate` 对象的 `subscribe()` 方法
      • 2.4.17 发射器 `CreateEmitter` 发送 `onNext` 以及 `onComplete` 事件
      • 2.4.18 连续多次设置 `subscribeOn()`，哪一次生效？
    • 2.5 `observeOn()` 流程分析
      • 2.5.1 创建自定义 `Observer` 对象
      • 2.5.2 创建 `ObservableOnSubscribe` 对象
      • 2.5.3 创建 `ObservableCreate` 对象
      • 2.5.4 调用 `AndroidSchedulers.mainThread()`方法
      • 2.5.5 调用 `ObservableCreate` 对象的 `observeOn` 方法，参数 `HandlerScheduler` 对象
      • 2.5.6 创建 `ObservableObserveOn` 对象
      • 2.5.7 调用 `ObservableObserveOn` 对象的 `subscribe` 方法，参数为自定义观察者
      • 2.5.8 调用 `HandlerScheduler` 对象的 `createWorker` 方法
      • 2.5.9 创建 `ObserveOnObserver` 对象，参数自定义观察者，`HandlerWorker` 对象
      • 2.5.10 调用 `ObservableCreate` 对象的 `subscribe` 方法，参数为 `ObserveOnObserver` 对象
      • 2.5.11 创建发射器，参数为 `ObserveOnObserver` 对象
      • 2.5.12 调用 `ObserveOnObserver` 对象的 `onSubscribe` 方法
      • 2.5.13 调用发射器的`onNext`方法，值为`a`
      • 2.5.14 `HandlerWorker`对象的`schedule`方法，参数为`ObserveOnObserver`对象
      • 2.5.15 调用 `ScheduledRunnable` 对象的 `run` 方法
      • 2.5.16 调用 `ObserveOnObserver` 对象的 `run` 方法
      • 2.5.17 连续多次调用 `observeOn()` ，哪一次生效？
  • 3. 最后
    • 参考

1. 前言

从 2016 年开始接触 RxJava 也有几年的时间了，但是并没有去研究过源码。再过几年，会不会还是这样？

最近从公司内部调用到新的工作岗位，工作上的事情比较烦。写下文章总结一下 RxJava，算是让自己静下来的方式吧。

本文针对的是 RxJava2.x 版本，依赖版本：

implementation 'io.reactivex.rxjava2:rxjava:2.2.20'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

会从几个方面进行分享：

  • RxJava 里的观察者模式和普通的观察者模式有什么区别？
  • RxJava 里的观察者模式源码流程
  • RxJava 的 map 操作符的流程是什么样子的？
  • RxJava 是如何进行线程切换的？

2. 正文

2.1 RxJava 里的观察者模式和普通的观察者模式有什么区别？

先看普通的观察者模式的例子，场景是学生和码农都需要关注鸿洋的公众号，这样他们才能接收到鸿洋的推文：

object NormalObserverPatternDemo {
    const val TAG = "NormalObserverPattern"
    fun show() {
        // 1，创建观察者
        val student = Student()
        val engineer = Engineer()
        // 2，创建被观察者
        val hongyangOfficialAccount = HongyangOfficialAccount()
        // 3，订阅
        hongyangOfficialAccount.addObserver(student)
        hongyangOfficialAccount.addObserver(engineer)
        // 4，发送事件
        hongyangOfficialAccount.notifyObservers("2021/6/19 推文：HarmonyOS 开发者日又双来了")
    }
}

/** 抽象被观察者 */
interface Observable {
    fun addObserver(observer: Observer)
    fun removeObserver(observer: Observer)
    fun notifyObservers(arg: Any)
}

/** 抽象观察者 */
interface Observer {
    fun update(arg: Any)
}

/** 鸿洋公众号，作为具体被观察者 */
class HongyangOfficialAccount : Observable {
    private val observers = mutableListOf<Observer>()
    override fun addObserver(observer: Observer) {
        if (!observers.contains(observer)) {
            observers.add(observer)
        }
    }

    override fun removeObserver(observer: Observer) {
        if (observers.contains(observer)) {
            observers.remove(observer)
        }
    }

    override fun notifyObservers(arg: Any) {
        for (observer in observers) {
            observer.update(arg)
        }
    }
}

/** 学生，作为具体观察者 */
class Student : Observer {
    override fun update(arg: Any) {
        Log.d(TAG, "学生收到了推文：$arg，赶紧学习吧！")
    }
}
/** 码农，作为具体观察者 */
class Engineer : Observer {
    override fun update(arg: Any) {
        Log.d(TAG, "码农收到了推文：$arg，浏览一下，有个印象吧！")
    }
}

打印如下：

NormalObserverPattern: 学生收到了推文：2021/6/19 推文：HarmonyOS 开发者日又双来了，赶紧学习吧！
NormalObserverPattern: 码农收到了推文：2021/6/19 推文：HarmonyOS 开发者日又双来了，浏览一下，有个印象吧！

下面我们思考一下：

学生和码农不关注鸿洋的公众号时，鸿洋公众号还会不会发推文？

答：当然会了，因为他们不关注，洋神可以自己看啊。

接着，我们看 RxJava 的观察者模式的代码（这里我们只需要关注流程，先不去考虑源码实现，2.2 中会分析源码实现的）：

// 1, 创建观察者
val observer = object : Observer<String> {
    override fun onSubscribe(d: Disposable) {
        Log.d(TAG, "onSubscribe: ")
    }
    override fun onNext(t: String) {
        Log.d(TAG, "onNext: t=$t")
    }
    override fun onError(e: Throwable) {
        Log.e(TAG, "onError: ", e)
    }
    override fun onComplete() {
        Log.d(TAG, "onComplete: ")
    }
}
// 2, 创建被观察者
val observable = Observable.create(object : ObservableOnSubscribe<String> {
    override fun subscribe(emitter: ObservableEmitter<String>) {
    	// 4, 发送事件
        Log.d(TAG, "subscribe: onNext：发送值 a")
        emitter.onNext("a")
        Log.d(TAG, "subscribe: onNext：发送值 b")
        emitter.onNext("b")
        Log.d(TAG, "subscribe: onNext：发送值 c")
        emitter.onNext("c")
        Log.d(TAG, "subscribe: onNext：发送值 d")
        emitter.onNext("d")
        Log.d(TAG, "subscribe: onComplete")
        emitter.onComplete()
    }
})
// 3，订阅
observable.subscribe(observer)

打印如下：

D/RxJavaObserverPattern: onSubscribe: 
D/RxJavaObserverPattern: subscribe: onNext：发送值 a
D/RxJavaObserverPattern: onNext: t=a
D/RxJavaObserverPattern: subscribe: onNext：发送值 b
D/RxJavaObserverPattern: onNext: t=b
D/RxJavaObserverPattern: subscribe: onNext：发送值 c
D/RxJavaObserverPattern: onNext: t=c
D/RxJavaObserverPattern: subscribe: onNext：发送值 d
D/RxJavaObserverPattern: onNext: t=d
D/RxJavaObserverPattern: subscribe: onComplete
D/RxJavaObserverPattern: onComplete:

可以看到，RxJava 的观察者模式流程和普通的观察者模式是一样的：

1，创建观察者；
2，创建被观察者；
3，订阅；
4，发送事件。

思考一下：

注释掉这行代码：observable.subscribe(observer)，控制台的打印会是什么样子的？

答：没有任何打印。

小结一下：

类别 事件类型 订阅方式 不订阅是否会发送事件？ 谁发送事件？ 观察者与被观察者对应关系
普通的观察者模式 只有普通事件 addObserver() 或类似的方法 会 被观察者 多对一
RxJava的观察者模式 除了普通事件（onNext()），还有两个特殊事件：（onComplete() 和 onError()） subscribe() 否 发射器 一对一

注意，表格里说 RxJava 的观察者模式不订阅不会发送事件并不严谨。实际上，要分情况说明：

  • 热启动Observable任何时候都会发送消息，即使没有任何观察者监听它。
  • 冷启动Observable只有在至少有一个订阅者的时候才会发送消息。

如果本文无特殊说明，Observable 均指的是冷启动 Observable。

到这里，我们有几个疑问：

1，为什么 RxJava 观察者模式里不订阅（subscribe）就不会发送事件呢？

2，RxJava 里发射器发送事件是如何到达观察者（Observer）的回调方法里面的？

3，为什么发射器没有调用 onSubscribe 方法，自定义观察者却回调了 onSubscribe 方法呢？

接着往下看吧，我们一定要把这些问题搞明白了。

2.2 RxJava 观察者模式的订阅流程

针对 2.1 里面的 RxJava 观察者模式的代码，画出时序图如下：

Android筑基——RxJava框架学习笔记_第1张图片

看完时序图，不知道大家有没有得到问题的答案。

不过，不用担心，下面从源码上进行说明。现在就开始吧。

2.2.1 创建自定义 Observer 对象

Observer 是一个泛型接口，

public interface Observer<T> {
    void onSubscribe(@NonNull Disposable d);
    void onNext(@NonNull T t);
    void onError(@NonNull Throwable e);
    void onComplete();
}

通过创建一个实现自 Observer 的匿名类的对象，就得到自定义观察者对象了：

val observer = object : Observer<String> {
    override fun onSubscribe(d: Disposable) {
        Log.d(TAG, "onSubscribe: ")
    }
    override fun onNext(t: String) {
        Log.d(TAG, "onNext: t=$t")
    }
    override fun onError(e: Throwable) {
        Log.e(TAG, "onError: ", e)
    }
    override fun onComplete() {
        Log.d(TAG, "onComplete: ")
    }
}

这里传给类型参数T的实际参数是 String，这与发送的数据类型是一致的。

2.2.2 创建 ObservableOnSubscribe 对象

ObservableOnSubscribe 也是一个泛型接口，并且是一个函数式接口：

public interface ObservableOnSubscribe<T> {
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}

通过创建一个实现自 ObservableOnSubscribe 的匿名类的对象，作为传递给 Observable.create() 方法的参数：

object : ObservableOnSubscribe<String> {
    override fun subscribe(emitter: ObservableEmitter<String>) {
    }
}

2.2.3 创建 ObservableCreate 对象

查看 Observable 的静态方法 create() 方法：

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

这里我们不考虑 RxJavaPlugins.onAssembly() 方法会调用钩子函数，所以上面的方法可以写成这样子：

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    return new ObservableCreate<T>(source);
}

这里返回的是一个 ObservableCreate 对象，而 ObservableCreate 是 Observable 的子类：

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
}

可以看到，ObservableCreate 通过带参构造函数接收并持有了 ObservableOnSubscribe 对象。

val observableCreate = Observable.create(
        object : ObservableOnSubscribe<String> {
            override fun subscribe(emitter: ObservableEmitter<String>) {
            }
        }
)

2.2.4 调用Observable.subscribe() 订阅方法

observableCreate.subscribe(observer)

同样地，我们把 subscribe() 方法简化如下：

public final void subscribe(Observer<? super T> observer) {
   // 省略了校验函数和钩子函数
   subscribeActual(observer);     
}

在 Observable 类中，subscribeActual() 方法是一个抽象方法：

protected abstract void subscribeActual(Observer<? super T> observer);

那么，我们必须找到 subscribeActual() 方法的实现。

在上一步中，我们知道返回的Observable 对象就是一个 ObservableCreate 对象。因此，我们有理由认为 ObservableCreate 类里实现了 subscribeActual() 方法。

查看 ObservableCreate 类，果真有 subscribeActual() 方法的实现：

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);
        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
}

在 subscribeActual() 方法里面：

首先创建了一个 CreateEmitter 对象，这是发射器对象；

然后调用了自定义观察者 observer 对象的 onSubscribe() 方法，表示通知观察者订阅成功了；

最后调用 ObservableOnSubscribe 对象的 subscribe() 方法，接收发射器对象。

2.2.5 创建 CreateEmitter 对象

CreateEmitter<T> parent = new CreateEmitter<T>(observer);

这里把 CreateEmitter 进行简化处理：

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
    final Observer<? super T> observer;
    CreateEmitter(Observer<? super T> observer) {
        this.observer = observer;
    }
    @Override
    public void onNext(T t) {
        observer.onNext(t);
    }
    @Override
    public void onError(Throwable t) {
        if (!tryOnError(t)) {
            RxJavaPlugins.onError(t);
        }
    }
    @Override
    public boolean tryOnError(Throwable t) {
        observer.onError(t);
        return false;
    }
    @Override
    public void onComplete() {
        observer.onComplete();
    }
    // 省略一些与分析无关的代码
}

可以看到：

  • CreateEmitter 类通过构造函数接收了观察者对象并且持有了观察者对象；
  • CreateEmitter 类中的 onNext() 方法内部会调用观察者对象的 onNext() 方法，onComplete() 方法内部会调用观察者对象的 onComplete() 方法。

2.2.6 发送 onNext() 以及 onComplete() 事件

在 2.2.4 里，我们知道 ObservableOnSubscribe 对象的 subscribe() 方法，接收了发射器 CreateEmitter对象；

在 2.2.5 中，我们知道 CreateEmitter 类通过构造函数接收了观察者对象并且持有了观察者对象。CreateEmitter 类中的 onNext() 方法内部会调用观察者对象的 onNext() 方法，onComplete() 方法内部会调用观察者对象的 onComplete() 方法。

因此，发射器发送的 onNext 事件会到达观察者的 onNext 回调， onComplete 事件会到达观察者的 onComplete 回调。

object : ObservableOnSubscribe<String> {
    override fun subscribe(emitter: ObservableEmitter<String>) {
        Log.d(TAG, "subscribe: onNext：发送值 a")
        emitter.onNext("a")
        Log.d(TAG, "subscribe: onNext：发送值 b")
        emitter.onNext("b")
        Log.d(TAG, "subscribe: onNext：发送值 c")
        emitter.onNext("c")
        Log.d(TAG, "subscribe: onNext：发送值 d")
        emitter.onNext("d")
        Log.d(TAG, "subscribe: onComplete")
        emitter.onComplete()
    }
}

现在我们来回答 2.1 中提出的两个问题吧：

1，为什么 RxJava 观察者模式里不订阅（subscribe）就不会发送事件呢？

因为只有在订阅时，才会创建发射器；而没有发射器，何谈发送事件呢。

2，RxJava 里发射器发送事件是如何到达自定义观察者（Observer）的回调方法里面的？

发射器持有了自定义观察者对象，在调用发射器的 onNext 方法，内部会调用自定义观察者的 onNext 方法；在调用发射器的 onComplete 方法，内部会调用自定义观察者的 onComplete 方法。这时候，发射器就委托观察者来处理事件了。

3，为什么发射器没有调用 onSubscribe 方法，自定义观察者却回调了 onSubscribe 方法呢？

2.2.4 中，在调用 ObservableCreate 对象的 subscribeActual 方法中，调用了自定义观察者的 onSubscribe 方法，表示通知观察者订阅成功了。

到这里，有些同学可能会想，为什么 RxJava 实现观察者模式采用的代码比普通的观察者要复杂那么多？

其实，我们目前演示的只是订阅流程，RxJava 强大的操作符还没有出现。

到这里，文章已经有一定的长度了。但是，大家一定要继续往下看，因为江湖传言：不懂操作符，不知 RxJava。

2.3 RxJava 的 map 操作符的流程是什么样子的？

打开 Observable 类浏览一下，可以看到有很多操作符：

  • 创建操作符：just、interval、create、defer 等；
  • 变换操作符：map、flatMap、concatMap；
  • 合并操作符：zip、count、concatArray、mergeArrray 等；
  • 过滤操作符：filter、skip、elementAt、throttleFirst 等；
  • 条件操作符：all、takeWhile、contains、isEmpty 等；
  • do系列操作符：doOnNext、doOnSubscribe、doOnComplete 等；
  • 其他操作符：retry、repeat、delay、timeout 等。

这么多操作符，该怎么掌握呢？

先掌握重点的，然后一个一个学习。

这里我们从 map 操作符入手，先看一个在之前的例子上使用 map 操作符的例子，实现的需求是依次发送 “a”、 “b”、 “c”、 “d”，观察者接收到的是 97、98、99、100 ，这里面就是使用 map 变换操作符来实现的。

// 1, 创建观察者
val observer = object : Observer<Int> {
    override fun onSubscribe(d: Disposable) {
        Log.d(TAG, "onSubscribe: ")
    }
    override fun onNext(t: Int) {
        Log.d(TAG, "onNext: t=$t")
    }
    override fun onError(e: Throwable) {
        Log.e(TAG, "onError: ", e)
    }
    override fun onComplete() {
        Log.d(TAG, "onComplete: ")
    }
}
// 2, 创建被观察者
val observableCreate = Observable.create(
        object : ObservableOnSubscribe<String> {
            override fun subscribe(emitter: ObservableEmitter<String>) {
                // 5, 发送事件
                Log.d(TAG, "subscribe: onNext：发送值 a")
                emitter.onNext("a")
                Log.d(TAG, "subscribe: onNext：发送值 b")
                emitter.onNext("b")
                Log.d(TAG, "subscribe: onNext：发送值 c")
                emitter.onNext("c")
                Log.d(TAG, "subscribe: onNext：发送值 d")
                emitter.onNext("d")
                Log.d(TAG, "subscribe: onComplete")
                emitter.onComplete()
            }
        }
)
// 3，使用 map 操作符对发送的数据进行变换
val observableMap = observableCreate.map(object : Function<String, Int> {
    override fun apply(t: String): Int {
        // 示取出索引为0的元素，数据类型是 Char，然后转换为 Int 类型。
        return t[0].toInt()
    }
})
// 4，订阅
observableMap.subscribe(observer)

代码改动的地方有：

1，观察者对象接收的数据类型由 String 改为 Int；

2，添加使用 map 操作符：

// 3，使用 map 操作符对发送的数据进行变换
val observableMap = observableCreate.map(object : Function<String, Int> {
    override fun apply(t: String): Int {
        // 取出索引为0的元素，数据类型是 Char，然后转换为 Int 类型。
        return t[0].toInt()
    }
})

3，使用 observableMap 而非 observableCreate 来订阅：

observableMap.subscribe(observer)

运行一下，打印日志如下：

D/RxJavaMapOperator: onSubscribe: 
D/RxJavaMapOperator: subscribe: onNext：发送值 a
D/RxJavaMapOperator: onNext: t=97
D/RxJavaMapOperator: subscribe: onNext：发送值 b
D/RxJavaMapOperator: onNext: t=98
D/RxJavaMapOperator: subscribe: onNext：发送值 c
D/RxJavaMapOperator: onNext: t=99
D/RxJavaMapOperator: subscribe: onNext：发送值 d
D/RxJavaMapOperator: onNext: t=100
D/RxJavaMapOperator: subscribe: onComplete
D/RxJavaMapOperator: onComplete:

查看日志打印，可以看到我们通过使用 map 操作符满足了需求。

代码已经了解了，现在我们看一下绘制好的 map 操作符时序图（点击图片可以查看大图）：

Android筑基——RxJava框架学习笔记_第2张图片

这个图里边包含的内容确实有点多，看着可能会头晕。

不过，不要忘记了，我们只是在基本的订阅流程里，加了 map 操作符的使用而已。

在分析源码之前，还是先提几个问题：

  • map 操作符的变换方法调用发生在什么地方？
  • 代码里面哪些部分用到了装饰器模式？

2.3.1 创建自定义Observer 对象

参见 2.2.1 创建自定义 Observer 对象

2.3.2 创建 ObservableOnSubscribe 对象

参见 2.2.2 创建 ObservableOnSubscribe 对象

2.3.3 创建 ObservableCreate 对象

参见 2.2.3 创建 ObservableCreate 对象

2.3.4 创建封装了变换操作的Function 对象

先看一下 Function 接口，它是一个函数式接口，封装了 apply 方法，用于进行变换操作，即把输入值进行一些操作（值变换，类型变换）后返回：

public interface Function<T, R> {
    R apply(@NonNull T t) throws Exception;
}

这里所做的变换是把 String 类型的数据，如 "a"，变换为 Int 类型的数据，如 97：

object : Function<String, Int> {
    override fun apply(t: String): Int {
        // 取出索引为0的元素，数据类型是 Char，然后转换为 Int 类型。
        return t[0].toInt()
    }
}

2.3.5 创建 ObservableMap 对象

查看 Observable 类中的 map 方法：

public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
    ObjectHelper.requireNonNull(mapper, "mapper is null");
    return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}

删繁就简为：

public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
    return new ObservableMap<T, R>(this, mapper);
}

这里返回的是 ObservableMap 对象，而ObservableMap 是 Observable 的子类：

abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
    protected final ObservableSource<T> source;
    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }
    @Override
    public final ObservableSource<T> source() {
        return source;
    }
}
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }
    // 省略了与本次分析无关的代码
}

可以看到，通过创建 ObservableMap 对象，让 ObservableMap 对象持有了 ObservableCreate 对象以及封装了变换操作的 Function 对象。

这里我们停下来，绘制一份类图如下：

Android筑基——RxJava框架学习笔记_第3张图片

从类图可以知道，这就是典型的装饰器模式了。

这里使用装饰器模式的好处是什么呢？

在不改变现有的 ObservableCreate 对象结构的基础上，通过具体装饰角色 ObservableMap 动态地给 ObservableCreate 对象（核心功能）添加了变换数据类型的功能；同时也实现了链式调用。

到这里配置的步骤已经完成了，下边开始进行订阅了。

2.3.6 调用 ObservableMap 的 subscribe 方法

内部实际调用的是 ObservableMap 的 subscribeActual 方法，传递的参数是观察者对象：

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }
    @Override
    public void subscribeActual(Observer<? super U> t) {
    	// source 就是 ObservableCreate 对象
        source.subscribe(new MapObserver<T, U>(t, function));
    }
}

2.3.7 创建 MapObserver 对象

static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
    final Function<? super T, ? extends U> mapper;
    MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
        super(actual);
        this.mapper = mapper;
    }
}

通过 MapObserver 的构造函数，MapObserver 对象持有了观察者对象和 Function 对象。

这里我们有必要再停一下，绘制一份类图如下：

Android筑基——RxJava框架学习笔记_第4张图片

这里同样使用了装饰器模式。

那么，这里使用装饰器模式的好处又是什么呢？

在不改变现有的自定义 Observer 对象结果的情况下，通过具体装饰角色 MapObserver 对象动态地自定义 Observer 对象（核心功能）添加一些职责（进行数据变换）。

2.3.8 调用 ObservableCreate 对象的 subscribe 方法

在 2.3.5 中，我们知道 ObservableMap 对象持有了 ObservableCreate 对象以及封装了变换操作的 Function 对象。

因此，下面代码里的 source 就是 ObservableCreate 对象：

source.subscribe(new MapObserver<T, U>(t, function))

内部实际调用的是 ObservableCreate 类的 subscribeActual 方法：

protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    observer.onSubscribe(parent);
    try {
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

传递给 subscribeActual 方法的实参是 MapObserver 对象。

在 subscribeActual 方法里：

首先创建了一个 CreateEmitter 对象，参数是 MapObserver 对象，这就创建了发射器对象；

然后调用了MapObserver 对象的 onSubscribe() 方法，表示通知观察者订阅成功了；

最后调用 ObservableOnSubscribe 对象的 subscribe() 方法，接收发射器对象。

2.3.9 创建 CreateEmitter 对象

CreateEmitter<T> parent = new CreateEmitter<T>(observer);

这里把 CreateEmitter 进行简化处理：

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
    final Observer<? super T> observer;
    CreateEmitter(Observer<? super T> observer) {
        this.observer = observer;
    }
    @Override
    public void onNext(T t) {
        observer.onNext(t);
    }
    @Override
    public void onError(Throwable t) {
        if (!tryOnError(t)) {
            RxJavaPlugins.onError(t);
        }
    }
    @Override
    public boolean tryOnError(Throwable t) {
        observer.onError(t);
        return false;
    }
    @Override
    public void onComplete() {
        observer.onComplete();
    }
    // 省略一些与分析无关的代码
}

可以看到：

  • CreateEmitter 类通过构造函数接收了MapObserver对象并且持有了MapObserver对象；
  • CreateEmitter 类中的 onNext() 方法内部会调用MapObserver对象的 onNext() 方法，onComplete() 方法内部会调用MapObserver对象的 onComplete() 方法。

2.3.10 调用 MapObserver 对象的 onSubscribe 方法

observer.onSubscribe(parent);

其中，observer 是 MapObserver 对象，parent 是 CreateEmitter 对象。

调用在 MapObserver 的父类 BasicFuseableObserver 的 onSubscribe 方法：

public final void onSubscribe(Disposable d) {
	// 删除与分析无关的代码
    downstream.onSubscribe(this);
}

在 2.3.5 中我们知道，downstream 是观察者对象。所以，这里会调用观察者对象的 onSubscribe 方法。

2.3.11 CreateEmitter 对象调用 onNext 以及 onComplete 方法

在 2.3.9 中，我们知道：

  • CreateEmitter 类通过构造函数接收了MapObserver对象并且持有了MapObserver对象；
  • CreateEmitter 类中的 onNext() 方法内部会调用MapObserver对象的 onNext() 方法，onComplete() 方法内部会调用MapObserver对象的 onComplete() 方法。

2.3.12 MapObserver 对象调用 onNext 以及 onComplete 方法

public abstract class BasicFuseableObserver<T, R> implements Observer<T>, QueueDisposable<R> {
    protected final Observer<? super R> downstream;
    public BasicFuseableObserver(Observer<? super R> downstream) {
        this.downstream = downstream;
    }
    @Override
    public final void onSubscribe(Disposable d) {
        downstream.onSubscribe(this);
    }
    @Override
    public void onComplete() {
        downstream.onComplete();
    }
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
    final Function<? super T, ? extends U> mapper;
    MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
        super(actual);
        this.mapper = mapper;
    }
    @Override
    public void onNext(T t) {
        U v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
        downstream.onNext(v);
    }
}

MapObserver 类中的 onNext() 方法内部会先使用Function对象进行变换操作，再调用自定义观察者对象的 onNext() 方法，onComplete() 方法内部会调用自定义观察者的 onComplete() 方法。

到这里，map 操作符的流程已经分析完毕了。

我们一起来回答本节开头提出的两个问题吧：

map 操作符的变换方法调用发生在什么地方？

答：在 2.3.12 里面， MapObserver 对象的 onNext 方法中发生调用的。

代码里面哪些部分用到了装饰器模式？

答：代码里面为了扩展 ObservableCreate 对象的功能时，用到了装饰器模式；为了扩展自定义 Observer 对象的功能，再次用到了装饰器模式。

2.4 subscribeOn() 流程分析

扔物线大佬的文章中这样写：

RxJava 的本质可以压缩为异步这一个词。说到根上，它就是一个实现异步操作的库，而别的定语都是基于这之上的。

首先，我们先引入一个小例子，演示 subscribeOn() 方法的使用：

对演示 RxJava 流程的代码进行修改，仅在发送事件之前增加休眠时间以及增加线程打印，代码如下：

// 1, 创建观察者
val observer = object : Observer<String> {
    override fun onSubscribe(d: Disposable) {
        Log.d(TAG, "onSubscribe: currThread=${Thread.currentThread().name}")
    }
    override fun onNext(t: String) {
        Log.d(TAG, "onNext: t=$t, currThread=${Thread.currentThread().name}")
    }
    override fun onError(e: Throwable) {
        Log.e(TAG, "onError: ", e)
    }
    override fun onComplete() {
        Log.d(TAG, "onComplete: currThread=${Thread.currentThread().name}")
    }
}
// 2, 创建被观察者
val observableCreate = Observable.create(
    object : ObservableOnSubscribe<String> {
        override fun subscribe(emitter: ObservableEmitter<String>) {
            // 4, 发送事件
            TimeUnit.SECONDS.sleep(3L)
            Log.d(TAG, "subscribe: onNext：发送值 a, currThread=${Thread.currentThread().name}")
            emitter.onNext("a")
            TimeUnit.SECONDS.sleep(3L)
            Log.d(TAG, "subscribe: onComplete, currThread=${Thread.currentThread().name}")
            emitter.onComplete()
        }
    }
)
// 3，订阅
observableCreate.subscribe(observer)

运行程序，打印日志如下：

D/RxJavaTimeConsuming: onSubscribe: currThread=main
D/RxJavaTimeConsuming: subscribe: onNext：发送值 a, currThread=main
D/RxJavaTimeConsuming: onNext: t=a, currThread=main
D/RxJavaTimeConsuming: subscribe: onComplete, currThread=main
D/RxJavaTimeConsuming: onComplete: currThread=main

大家看看日志，都是主线程打印的。没有问题，因为我们根本就没有新启线程，所以只能是主线程。

眼尖的你很快发现：在发送事件之前休眠了 3s，这好像不合理吧？

这都被你看出来，哈哈。我们希望发送事件的部分可以运行在子线程里面。这就要用到 subscribeOn() 方法了。

修改代码如下：

// 3，指定在 io 线程里发送事件
val observableSubscribeOn = observableCreate.subscribeOn(Schedulers.io())
// 4，订阅
observableSubscribeOn.subscribe(observer)

再次运行程序，打印日志如下：

D/RxJavaSubscribeOn: onSubscribe: currThread=main
D/RxJavaSubscribeOn: subscribe: onNext：发送值 a, currThread=RxCachedThreadScheduler-1
D/RxJavaSubscribeOn: onNext: t=a, currThread=RxCachedThreadScheduler-1
D/RxJavaSubscribeOn: subscribe: onComplete, currThread=RxCachedThreadScheduler-1
D/RxJavaSubscribeOn: onComplete: currThread=RxCachedThreadScheduler-1

我们再看一下日志，

  • 自定义观察者的 onSubscribe 方法在主线程回调；
  • 发送事件的方法：onNext 和 onComplete，是在子线程调用的；
  • 自定义观察者的 onNext 和 onComplete，是在子线程回调的（和发送事件的子线程是一样的）。

好了，这里同样产生了几个疑问：

  1. 为什么自定义观察者的 onSubscribe 方法在主线程回调，而不是在子线程？
  2. 为什么发送事件的方法：onNext 和 onComplete，是在子线程调用的？子线程是在哪里创建的？
  3. 为什么自定义观察者的 onNext 和 onComplete，是在子线程回调的？为什么子线程和发送事件的子线程是一样的？

这里把上述代码的时序图（一定要点击放大查看）绘制如下：

Android筑基——RxJava框架学习笔记_第5张图片
现在我们开始看源码了，大家准备好了吗？

2.4.1 创建自定义Observer 对象

参见 2.2.1 创建自定义 Observer 对象

2.4.2 创建 ObservableOnSubscribe 对象

参见 2.2.2 创建 ObservableOnSubscribe 对象

2.4.3 创建 ObservableCreate 对象

参见 2.2.3 创建 ObservableCreate 对象

2.4.4 调用 Schedulers.io() 方法

这行代码返回的是 Scheduler 对象：

Schedulers.io()

查看 Schedulers 类中的 io() 方法：

// Schedulers 类中：
static final Scheduler IO;
static {
    IO = RxJavaPlugins.initIoScheduler(new IOTask());
}
static final class IoHolder {
    static final Scheduler DEFAULT = new IoScheduler();
}
public static Scheduler io() {
    return RxJavaPlugins.onIoScheduler(IO);
}
static final class IOTask implements Callable<Scheduler> {
    @Override
    public Scheduler call() throws Exception {
        return IoHolder.DEFAULT;
    }
}
// RxJavaPlugins 类中：
public static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler) {
    ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
    Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitIoHandler;
    if (f == null) {
        return callRequireNonNull(defaultScheduler);
    }
    return applyRequireNonNull(f, defaultScheduler);
}
static Scheduler callRequireNonNull(@NonNull Callable<Scheduler> s) {
    try {
        return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be null");
    } catch (Throwable ex) {
        throw ExceptionHelper.wrapOrThrow(ex);
    }
}

化繁为简为：

// Schedulers 类中：
static final Scheduler IO;
static {
    IO = RxJavaPlugins.initIoScheduler(new IOTask());
}
static final class IoHolder {
    static final Scheduler DEFAULT = new IoScheduler();
}
public static Scheduler io() {
    return IO;
}
static final class IOTask implements Callable<Scheduler> {
    @Override
    public Scheduler call() throws Exception {
        return IoHolder.DEFAULT;
    }
}
// RxJavaPlugins 类中：
public static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler) {
    return defaultScheduler.call();
}

总结一下：

Schedulers.io() 就是创建了一个单例的 IoScheduler 对象。

2.4.5 调用 ObservableCreate 对象的 subscribeOn方法

传递的实际参数为IoScheduler单例对象

public final Observable<T> subscribeOn(Scheduler scheduler) {
	// 这是简化后的代码
    return new ObservableSubscribeOn<T>(this, scheduler);
}

在方法里面，创建了一个 ObservableSubscribeOn 对象：

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;

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

通过 ObservableSubscribeOn 的构造方法，把 ObservableCreate 对象赋值给 source 变量，把 IoScheduler 单例对象赋值给 scheduler 变量。

2.4.6 调用 ObservableSubscribeOn 的 subscribe 方法，参数为自定义观察者

实际调用的是 ObservableSubscribeOn 的 subscribeActual 方法，传递的实参是自定义观察者。

public void subscribeActual(final Observer<? super T> observer) {
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
    observer.onSubscribe(parent);
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}

在方法内部：

  1. 创建 SubscribeOnObserver 对象，参数是自定义观察者；
  2. 调用自定义观察者的 onSubscribe 方法，自定义观察者的 onSubscribe 方法会在当前线程回调；
  3. 创建 SubscribeTask 对象，参数是 SubscribeOnObserver 对象；
  4. 调用 IoScheduler 单例对象的 scheduleDirect 方法，参数是 SubscribeTask 对象。

2.4.7 创建 SubscribeOnObserver 对象

static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
    private static final long serialVersionUID = 8094547886072529208L;
    final Observer<? super T> downstream;
    final AtomicReference<Disposable> upstream;
    SubscribeOnObserver(Observer<? super T> downstream) {
        this.downstream = downstream;
        this.upstream = new AtomicReference<Disposable>();
    }
}

通过构造方法，传递自定义观察者对象，赋值给 downstream 字段。

2.4.8 创建 SubscribeTask 对象

final class SubscribeTask implements Runnable {
    private final SubscribeOnObserver<T> parent;
    SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
    }
    @Override
    public void run() {
        source.subscribe(parent);
    }
}

SubscribeTask 实现了 Runnable 接口，因此它是一个自定义任务类。通过构造方法，传递 SubscribeOnObserver 对象，赋值给 parent 字段。

2.4.9 调用 IoScheduler 单例对象的 scheduleDirect() 方法

传递给 scheduleDirect 方法的实参是 SubscribeTask 对象。

public Disposable scheduleDirect(@NonNull Runnable run) {
    return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
}
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    // 2.4.10
    final Worker w = createWorker();
    final Runnable decoratedRun = run; // 此行去除了 hook 操作
    DisposeTask task = new DisposeTask(decoratedRun, w);
    // 2.4.11
    w.schedule(task, delay, unit);
    return task;
}

这里 DisposeTask 与 SubscribeTask 的关系是一种包装，绘制类图如下：

Android筑基——RxJava框架学习笔记_第6张图片

2.4.10 调用 IoScheduler 单例对象的 createWorker() 方法

final AtomicReference<CachedWorkerPool> pool;
public Worker createWorker() {
    return new EventLoopWorker(pool.get());
}
static final class EventLoopWorker extends Scheduler.Worker {
    private final CompositeDisposable tasks;
    private final CachedWorkerPool pool;
    private final ThreadWorker threadWorker;
    final AtomicBoolean once = new AtomicBoolean();
    EventLoopWorker(CachedWorkerPool pool) {
        this.pool = pool;
        this.tasks = new CompositeDisposable();
        this.threadWorker = pool.get();
    }
}

createWorker 方法内部创建 EventLoopWorker 对象，并返回 EventLoopWorker 对象。

2.4.11 调用 EventLoopWorker 对象的 schedule 方法

public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
   	// 省略无关分析的代码
    return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}

传递给形参 action 的实参是 DisposeTask 对象。

threadWorker 是 ThreadWorker 对象，是在创建 EventLoopWorker 时被初始化的。

2.4.12 调用 ThreadWorker 对象的 scheduleActual 方法

在 NewThreadWorker 类中查看：

public ScheduledRunnable scheduleActual(final Runnable run, long delayTime,
 @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
    Runnable decoratedRun = run; // 去除了 hook 操作
    ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
    if (parent != null) {
        if (!parent.add(sr)) {
            return sr;
        }
    }
    Future<?> f = executor.submit((Callable<Object>)sr);
    sr.setFuture(f);
    return sr;
}

在方法内部，ScheduledRunnable 包装了 DisposeTask，绘制类图如下：
Android筑基——RxJava框架学习笔记_第7张图片
Future f = executor.submit((Callable)sr); 把 ScheduledRunnable 对象交给线程池执行，就会执行 ScheduledRunnable 对象的 run() 方法。

注意！注意！注意！ 这里以后的代码都是运行在子线程里面了。

2.4.13 调用 ScheduledRunnable 对象的 run() 方法

public final class ScheduledRunnable extends AtomicReferenceArray<Object>
implements Runnable, Callable<Object>, Disposable {

    final Runnable actual;
    public ScheduledRunnable(Runnable actual, DisposableContainer parent) {
        super(3);
        this.actual = actual;
        this.lazySet(0, parent);
    }

    @Override
    public Object call() {
        // Being Callable saves an allocation in ThreadPoolExecutor
        run();
        return null;
    }

    @Override
    public void run() {
    	// actual 是 DisposeTask 对象
    	actual.run();
    }
}

在 run() 方法里面，调用的是 DisposeTask 对象的 run() 方法。

2.4.14 调用 DisposeTask 对象的 run() 方法

static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {
    final Runnable decoratedRun;
    final Worker w;
    DisposeTask(@NonNull Runnable decoratedRun, @NonNull Worker w) {
        this.decoratedRun = decoratedRun;
        this.w = w;
    }
    @Override
    public void run() {
    	// decoratedRun 就是 SubscribeTask 对象
        decoratedRun.run();
    }
    // 省略与分析无关的代码
}

2.4.15 调用 SubscribeTask 对象的 run() 方法

final class SubscribeTask implements Runnable {
    private final SubscribeOnObserver<T> parent;
    SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
    }
    @Override
    public void run() {
    	// source 是 ObservableCreate 对象
        source.subscribe(parent);
    }
}

在 run() 方法内部，调用 ObservableCreate 对象的 subscribe() 方法，参数为 SubscribeOnObserver 对象。

2.4.16 调用 ObservableCreate 对象的 subscribe() 方法

实际调用的是 ObservableCreate 对象的 subscribeActual 方法，参数是 SubscribeOnObserver 对象。

protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    observer.onSubscribe(parent);
    source.subscribe(parent);
}

在 subscribeActual() 方法里面：

首先创建了一个 CreateEmitter 对象，即发射器对象，传递参数是 SubscribeOnObserver 对象；

然后调用了SubscribeOnObserver 对象的 onSubscribe() 方法，但是并不会再回调给自定义观察者了；

最后调用 ObservableOnSubscribe 对象的 subscribe() 方法，接收发射器对象。

至此订阅过程就结束了，下边就开始发送事件了。

2.4.17 发射器 CreateEmitter 发送 onNext 以及 onComplete 事件

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
    final Observer<? super T> observer;
    CreateEmitter(Observer<? super T> observer) {
        this.observer = observer;
    }
    @Override
    public void onNext(T t) {
    	 // observer 是  SubscribeOnObserver 对象
         observer.onNext(t);
    }
    
    @Override
    public void onComplete() {
         // observer 是  SubscribeOnObserver 对象
         observer.onComplete(); 
    }
}

SubscribeOnObserver 类：

static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
    private static final long serialVersionUID = 8094547886072529208L;
    final Observer<? super T> downstream;
    final AtomicReference<Disposable> upstream;
    SubscribeOnObserver(Observer<? super T> downstream) {
        this.downstream = downstream;
        this.upstream = new AtomicReference<Disposable>();
    }
    @Override
    public void onSubscribe(Disposable d) {
        DisposableHelper.setOnce(this.upstream, d);
    }
    @Override
    public void onNext(T t) {
    	// downstream 是 自定义观察者对象
        downstream.onNext(t);
    }
    @Override
    public void onError(Throwable t) {
        downstream.onError(t);
    }
    @Override
    public void onComplete() {
    	// downstream 是 自定义观察者对象
        downstream.onComplete();
    }
}

发射器调用 onNext 方法 -> 调用 SubscribeOnObserver 对象的 onNext 方法 -> 调用自定义观察者的 onNext 方法。

发射器调用 onComplete 方法 -> 调用 SubscribeOnObserver 对象的 onComplete 方法 -> 调用自定义观察者的 onComplete 方法。

在 2.4.12 已经切为子线程了，所以自定义观察者的 onNext 方法和 onComplete 方法都是在子线程调用的。

回答本节开头的几个疑问：

  1. 为什么自定义观察者的 onSubscribe 方法在主线程回调，而不是在子线程？

    因为调用自定义观察者的 onSubscribe 方法时，还没有进行线程切换，所以它是在当前线程回调的，当前线程是主线程。

  2. 为什么发送事件的方法：onNext 和 onComplete，是在子线程调用的？子线程是在哪里创建的？

    在 2.4.12 已经切为子线程了，所以自定义观察者的 onNext 方法和 onComplete 方法都是在子线程调用的。
    子线程是在 createWorker() 中，通过创建 ThreadWorker 对象初始化了线程池。

  3. 为什么自定义观察者的 onNext 和 onComplete，是在子线程回调的？为什么子线程和发送事件的子线程是一样的？

    在 2.4.12 已经切为子线程了，之后没有进行过线程切换，所以自定义观察者的 onNext 和 onComplete，是在和发送事件的子线程是一样的子线程回调的。

2.4.18 连续多次设置 subscribeOn()，哪一次生效？

调整代码如下：

val observableSubscribeOn1 = observableCreate.subscribeOn(Schedulers.io()) // RxCachedThreadScheduler
val observableSubscribeOn2 = observableSubscribeOn1.subscribeOn(Schedulers.computation()) // RxComputationThreadPool
val observableSubscribeOn3 = observableSubscribeOn2.subscribeOn(Schedulers.newThread()) // RxNewThreadScheduler
// 4，订阅
observableSubscribeOn3.subscribe(observer)

运行结果如下：

D/RxJavaSubscribeOn: onSubscribe: currThread=main
D/RxJavaSubscribeOn: subscribe: onNext：发送值 a, currThread=RxCachedThreadScheduler-1
D/RxJavaSubscribeOn: onNext: t=a, currThread=RxCachedThreadScheduler-1
D/RxJavaSubscribeOn: subscribe: onComplete, currThread=RxCachedThreadScheduler-1
D/RxJavaSubscribeOn: onComplete: currThread=RxCachedThreadScheduler-1

可以看到，只有第一次设置的 subscribeOn() 生效了。

那么，为什么只有第一次设置的 subscribeOn() 生效了呢？

答案在下面的时序图里面了：

Android筑基——RxJava框架学习笔记_第8张图片

2.5 observeOn() 流程分析

本节开头，我们仍是先设定一个场景，这样分析更加具体。

对于 2.4 中的例子，我们修改如下：

// 2, 创建被观察者
val observableCreate = Observable.create(
    object : ObservableOnSubscribe<String> {
        override fun subscribe(emitter: ObservableEmitter<String>) {
            // 5, 子线程发送事件
            thread(name = "WorkThread") {
                TimeUnit.SECONDS.sleep(3L)
                Log.d(TAG, "subscribe: onNext：发送值 a, currThread=${Thread.currentThread().name}")
                emitter.onNext("a")
                TimeUnit.SECONDS.sleep(3L)
                Log.d(TAG, "subscribe: onComplete, currThread=${Thread.currentThread().name}")
                emitter.onComplete()
            }
        }
    }
)
// 3，指定在 main 线程里观察事件
val observableObserveOn= observableCreate.observeOn(AndroidSchedulers.mainThread())
// 4，订阅
observableObserveOn.subscribe(observer)

说明一下这里的改动：

  1. 在线程名字为 WorkerThread 的子线程里发送事件。这里其实可以用 2.4 中的 subscribeOn() 方法来实现，但是为了使大家专注于分析 observeOn()，这里直接创建了一个子线程。
  2. observableCreate.observeOn(AndroidSchedulers.mainThread())，表示让自定义观察者在主线程观察事件。

好了，运行一下程序，看一下日志吧：

D/RxJavaObserveOnDemo: onSubscribe: currThread=main
D/RxJavaObserveOnDemo: subscribe: onNext：发送值 a, currThread=WorkThread
D/RxJavaObserveOnDemo: onNext: t=a, currThread=main
D/RxJavaObserveOnDemo: subscribe: onComplete, currThread=WorkThread
D/RxJavaObserveOnDemo: onComplete: currThread=main

可以看到，日志打印与我们的改动目的完全相符。

在继续分析之前，提出一个疑问：

从子线程切到主线程是如何完成的？

绘制时序图如下：

Android筑基——RxJava框架学习笔记_第9张图片

2.5.1 创建自定义 Observer 对象

见 2.2.1 创建自定义 Observer 对象

2.5.2 创建 ObservableOnSubscribe 对象

见 2.2.2 创建 ObservableOnSubscribe 对象

2.5.3 创建 ObservableCreate 对象

见 2.2.3 创建 ObservableCreate 对象

2.5.4 调用 AndroidSchedulers.mainThread()方法

看下面的源码：

// 在 AndroidSchedulers 类中：
public static Scheduler mainThread() {
    return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
}
private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
        new Callable<Scheduler>() {
            @Override public Scheduler call() throws Exception {
                return MainHolder.DEFAULT;
            }
        });
private static final class MainHolder {
    static final Scheduler DEFAULT
        = new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
}
// 在 RxAndroidPlugins 类中：
public static Scheduler onMainThreadScheduler(Scheduler scheduler) {
    if (scheduler == null) {
        throw new NullPointerException("scheduler == null");
    }
    Function<Scheduler, Scheduler> f = onMainThreadHandler;
    if (f == null) {
        return scheduler;
    }
    return apply(f, scheduler);
}
public static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler) {
    if (scheduler == null) {
        throw new NullPointerException("scheduler == null");
    }
    Function<Callable<Scheduler>, Scheduler> f = onInitMainThreadHandler;
    if (f == null) {
        return callRequireNonNull(scheduler);
    }
    return applyRequireNonNull(f, scheduler);
}
static Scheduler callRequireNonNull(Callable<Scheduler> s) {
    try {
        Scheduler scheduler = s.call();
        if (scheduler == null) {
            throw new NullPointerException("Scheduler Callable returned null");
        }
        return scheduler;
    } catch (Throwable ex) {
        throw Exceptions.propagate(ex);
    }
}

去掉 hook 操作，化繁为简为：

// 在 AndroidSchedulers 类中：
public static Scheduler mainThread() {
    return MAIN_THREAD;
}
private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
        new Callable<Scheduler>() {
            @Override public Scheduler call() throws Exception {
                return MainHolder.DEFAULT;
            }
        });
private static final class MainHolder {
    static final Scheduler DEFAULT
        = new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
}
// 在 RxAndroidPlugins 类中：
public static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler) {
    return scheduler.call();

总结一下：

AndroidSchedulers.mainThread() 返回的是一个单例的 HandlerScheduler对象，这个对象持有一个可以切换到主线程的 Handler 对象。

2.5.5 调用 ObservableCreate 对象的 observeOn 方法，参数 HandlerScheduler 对象

在 Observable 类中：

public final Observable<T> observeOn(Scheduler scheduler) {
    return observeOn(scheduler, false, bufferSize());
}
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
	// 这里去掉了 hook 操作
    return new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize);
}

可以看到，在 observeOn方法内部，创建了一个 ObservableObserveOn 对象；并且，通过 ObservableObserveOn 的构造方法，使得 ObservableObserveOn 对象持有了 ObservableCreate 对象HandlerScheduler 对象；最后返回 ObservableObserveOn 对象。

2.5.6 创建 ObservableObserveOn 对象

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;
    final boolean delayError;
    final int bufferSize;
    public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
    	// 把 ObservableCreate 对象设置给 source 字段
        super(source);
        // 把 HandlerScheduler 对象设置给 scheduler 字段
        this.scheduler = scheduler;
        this.delayError = delayError;
        this.bufferSize = bufferSize;
    }
}

2.5.7 调用 ObservableObserveOn 对象的 subscribe 方法，参数为自定义观察者

实际调用的是 ObservableObserveOn 类中的 subscribeActual 方法，参数为自定义观察者：

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
    	// scheduler 是 HandlerScheduler 对象
        Scheduler.Worker w = scheduler.createWorker();
        // source 是 ObservableCreate 对象
        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}

2.5.8 调用 HandlerScheduler 对象的 createWorker 方法

在 HandlerScheduler 中：

public Worker createWorker() {
	// handler 就是一个可以切换到主线程的 `Handler` 对象
    return new HandlerWorker(handler, async);
}

HandlerWorker 是继承于 Worker 的一个类。

private static final class HandlerWorker extends Worker {
    private final Handler handler;
    private final boolean async;
    HandlerWorker(Handler handler, boolean async) {
        this.handler = handler;
        this.async = async;
    }
}

2.5.9 创建 ObserveOnObserver 对象，参数自定义观察者，HandlerWorker 对象

static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
    final Observer<? super T> downstream;
    final Scheduler.Worker worker;
    ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
        this.downstream = actual;
        this.worker = worker;
    }

2.5.10 调用 ObservableCreate 对象的 subscribe 方法，参数为 ObserveOnObserver 对象

分析这行代码：

// source 是 ObservableCreate 对象
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));

实际调用的是 ObservableCreate 的 subscribeActual 方法。

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);
        source.subscribe(parent);
    }
}

在 subscribeActual() 方法里面：

首先创建了一个 CreateEmitter 对象，即发射器对象，并把 ObserveOnObserver 对象通过构造方法传递给发射器对象；

然后调用了ObserveOnObserver 对象的 onSubscribe() 方法，表示通知观察者订阅成功了；

最后调用 ObservableOnSubscribe 对象的 subscribe() 方法，接收发射器对象。

2.5.11 创建发射器，参数为 ObserveOnObserver 对象

这里我们直接把 CreateEmitter 化繁为简，关注主线流程：

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
    final Observer<? super T> observer;
    CreateEmitter(Observer<? super T> observer) {
    	// 把 ObserveOnObserver 对象设置给 observer 字段
        this.observer = observer;
    }
    @Override
    public void onNext(T t) {
         observer.onNext(t);
    }
    @Override
    public void onError(Throwable t) {
        observer.onError(t);
    }
 
    @Override
    public void onComplete() {
         observer.onComplete();
    }
 
}

2.5.12 调用 ObserveOnObserver 对象的 onSubscribe 方法

static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
    final Observer<? super T> downstream;
    final Scheduler.Worker worker;
    SimpleQueue<T> queue;    
    ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
        this.downstream = actual;
        this.worker = worker;
    }
    @Override
    public void onSubscribe(Disposable d) {
    		// 初始化 SimpleQueue 对象，用于存放 onNext 方法发送的值
            queue = new SpscLinkedArrayQueue<T>(bufferSize);
            // downstream 是自定义观察者对象
            downstream.onSubscribe(this);
        }
    }
}

可以看到，在方法内部调用了自定义观察者的 onSubscribe 方法，这样自定义观察者就收到了订阅成功的回调了。

2.5.13 调用发射器的onNext方法，值为a

在发射器的 onNext 方法里会调用 ObserveOnObserver 对象的 onNext 方法。

看一下 ObserveOnObserver 的 onNext 方法：

static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
    final Observer<? super T> downstream;
    final Scheduler.Worker worker;
    SimpleQueue<T> queue;
    Disposable upstream;
    volatile boolean done;
    ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
    	// 自定义观察者
        this.downstream = actual;
        // HandlerWorker 对象
        this.worker = worker;
    }
    @Override
    public void onSubscribe(Disposable d) {
        queue = new SpscLinkedArrayQueue<T>(bufferSize);
        downstream.onSubscribe(this);
    }
    @Override
    public void onNext(T t) {
    	queue.offer(t);
        schedule();
    }
    @Override
    public void onComplete() {
        if (done) {
            return;
        }
        done = true;
        schedule();
    }
    void schedule() {
        worker.schedule(this);
    }
    void drainNormal() {
        int missed = 1;
        final SimpleQueue<T> q = queue;
        final Observer<? super T> a = downstream;
        for (;;) {
            if (checkTerminated(done, q.isEmpty(), a)) {
                return;
            }
            for (;;) {
                boolean d = done;
                // 从队列里取出元素
                T v = q.poll();
                boolean empty = v == null;
                if (checkTerminated(d, empty, a)) {
                    return;
                }
                if (empty) {
                    break;
                }
                // 发送 onNext 事件
                a.onNext(v);
            }
            missed = addAndGet(-missed);
            if (missed == 0) {
                break;
            }
        }
    }
    @Override
    public void run() {
        drainNormal();
    }
    boolean checkTerminated(boolean d, boolean empty, Observer<? super T> a) {
        if (empty) {
              disposed = true;
              a.onComplete();
              worker.dispose();
              return true;
         }
         return false;
    }
}

可以看到在 onNext 方法内部：

先调用 queue.offer(t); 把要发送的值放在队列里面；

然后调用 schedule 方法，内部调用了 HandlerWorker 对象的 schedule 方法，传递的参数是 ObserveOnObserver 对象（它实现了 Runnable 接口，所以可以直接传递）。

2.5.14 HandlerWorker对象的schedule方法，参数为ObserveOnObserver对象

在 HandlerWorker的 schedule 方法里：

public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
    ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
    Message message = Message.obtain(handler, scheduled);
    handler.sendMessageDelayed(message, unit.toMillis(delay));
    return scheduled;
}
  • 首先，创建了一个 ScheduledRunnable 对象，持有 Handler 对象以及 ObserveOnObserver 对象；
  • 然后，把 ScheduledRunnable 包装在一个 Message 里面；
  • 最后，使用 Handler 对象发送消息，使 ScheduledRunnable 对象在主线程执行。

2.5.15 调用 ScheduledRunnable 对象的 run 方法

private static final class ScheduledRunnable implements Runnable, Disposable {
    private final Handler handler;
    private final Runnable delegate;
    ScheduledRunnable(Handler handler, Runnable delegate) {
        this.handler = handler;
        // delegate 就是 ObserveOnObserver 对象
        this.delegate = delegate;
    }
    @Override
    public void run() {
        try {
            // 调用 ObserveOnObserver 对象的 run 方法
            delegate.run();
        } catch (Throwable t) {
            RxJavaPlugins.onError(t);
        }
    }
}

2.5.16 调用 ObserveOnObserver 对象的 run 方法

static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
    final Observer<? super T> downstream;
    final Scheduler.Worker worker;
    SimpleQueue<T> queue;
    Disposable upstream;
    volatile boolean done;
    ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
    	// 自定义观察者
        this.downstream = actual;
        // HandlerWorker 对象
        this.worker = worker;
    }
    @Override
    public void onSubscribe(Disposable d) {
        queue = new SpscLinkedArrayQueue<T>(bufferSize);
        downstream.onSubscribe(this);
    }
    @Override
    public void onNext(T t) {
    	queue.offer(t);
        schedule();
    }
    @Override
    public void onComplete() {
        if (done) {
            return;
        }
        done = true;
        schedule();
    }
    void schedule() {
        worker.schedule(this);
    }
    void drainNormal() {
        int missed = 1;
        final SimpleQueue<T> q = queue;
        final Observer<? super T> a = downstream;
        for (;;) {
            if (checkTerminated(done, q.isEmpty(), a)) {
                return;
            }
            for (;;) {
                boolean d = done;
                // 从队列里取出元素
                T v = q.poll();
                boolean empty = v == null;
                if (checkTerminated(d, empty, a)) {
                    return;
                }
                if (empty) {
                    break;
                }
                // 发送 onNext 事件
                a.onNext(v);
            }
            missed = addAndGet(-missed);
            if (missed == 0) {
                break;
            }
        }
    }
    @Override
    public void run() {
        drainNormal();
    }
    boolean checkTerminated(boolean d, boolean empty, Observer<? super T> a) {
        if (empty) {
              disposed = true;
              a.onComplete();
              worker.dispose();
              return true;
         }
         return false;
    }
}

在 run 方法内部调用 drainNormal 方法；

从队列中取出发送的值，调用自定义观察者的 onNext 方法。

2.5.17 连续多次调用 observeOn() ，哪一次生效？

对于本节开头的例子，修改如下：

val observableObserveOn1 = observableCreate.observeOn(AndroidSchedulers.mainThread()) // main
val observableObserveOn2 = observableObserveOn1.observeOn(Schedulers.io()) // RxCachedThreadScheduler
val observableObserveOn3 = observableObserveOn2.observeOn(Schedulers.newThread()) // RxNewThreadScheduler
// 4，订阅
observableObserveOn3.subscribe(observer)

运行结果如下：

D/MultipleObserveOn: onSubscribe: currThread=main
D/MultipleObserveOn: subscribe: onNext：发送值 a, currThread=WorkThread
D/MultipleObserveOn: onNext: t=a, currThread=RxNewThreadScheduler-1
D/MultipleObserveOn: subscribe: onComplete, currThread=WorkThread
D/MultipleObserveOn: onComplete: currThread=RxNewThreadScheduler-1

可以看到，只有最后一次 observeOn() 生效了。

这是为什么呢？

查看下面的时序图：

Android筑基——RxJava框架学习笔记_第10张图片

3. 最后

本文主要采用时序图的方式展示了 RxJava 的订阅流程，map变化操作符流程，线程切换流程；并用类图展示了 RxJava 里使用到的包装器模式。

虽然本文已经够长了，但是还有一些内容没有包括进去：

  • RxJava 中的 hook 是做什么用的？
  • RxJava 在工作中的最佳实践
  • 工作中使用 RxJava 遇到的问题及解决办法。
  • 自定义操作符

希望回头有时间可以补完。

代码、时序图以及类图源文件在这里。

参考

  • 给 Android 开发者的 RxJava 详解
  • Android主流三方库源码分析（五、深入理解RxJava源码）
  • 详解 RxJava 的消息订阅和线程切换原理
  • RxJava2.0——从放弃到入门
  • RxJava入门之路（一）
  • 这可能是最好的RxJava 2.x 教程（完结版）
  • 反应式编程 RxJava 设计原理解析
  • RxJava——扩展的观察者模式
  • RxJava2源码分析-类的命名规则
  • RxJava入门之介绍与基本运用
  • RxJava入门
  • 变种装饰器模式在rxjava中的应用
  • Android：RxJava 3.0尝鲜，你做好准备了吗？
  • 彻底搞清楚 RxJava 是什么东西
  • 你会在实际工作中使用 rxjava 吗？
  • RxJava 这8问，你顶得住吗？
  • RxJava系列教程
  • RxJava
  • ReactiveX

你可能感兴趣的:(#,著名开源库学习,RxJava,观察者模式,装饰器模式,map,时序图)

  • 可视化相机pose colmap形式的相机内参外参 AI算法网奇 python基础python
    目录内参外参转换可视化相机posecolmap形式的相机内参外参内参外参转换defvisualize_cameras(cameras,images):fig=plt.figure()ax=fig.add_subplot(111,projection='3d')forimage_id,image_datainimages.items():qvec=image_data['qvec']tvec=ima
  • SpringMVC（五）：SpringMVC的获取请求参数 Lansonli Spring系列核心知识servletjavahttpSpringMVC
    文章目录SpringMVC的获取请求参数一、POJO接收参数1、form表单2、controller处理单元3、POJO实体类4、POJO实体类二、日期类型转换方式1:注解方式（推荐该方式）方式2:配置转换器三、List集合接收参数1、实体类2、controller3、form表单四、Map集合接收参数1、实体类2、form表单3、controller五、编码问题1、GET乱码问题2、POST乱码
  • SpringMVC 注解实现参数映射 姜源Jerry Springspringjavaservlet
    SpringMVC注解实现参数映射1.请求参数映射1.1RequestMapping1.2请求参数的映射1.2.1基本类型/字符串属性封装1.2.2实体类属性封装1.2.3集合属性封装1.2.4Date类型封装1.3常用注解1.4其他注解2.响应数据和结果视图2.1返回值分类3.配置不拦截静态资源参考资料：https://spring-mvc.linesh.tw/1.请求参数映射@RequestM
  • ArcGIS——数据库与服务备份（一、oracle中的geodatabase备份使用impdp与expdp） gis_morningsun GISArcGISJavaScript数据备份geodatabaseimpdpexpdparcgisoracle
    一、引言谷歌百度文章已翻烂，自己想找的东西也找不到，硬是靠着自己偷懒的毅力来搞定了这个问题。一般文章建议空间数据库从arcmap中备份恢复，普通数据使用传统的oracle备份恢复，我认为都是存储在数据库中，应该有办法从oracle层面可以一起备份的，这就是这篇文章的起源。从此走向了一条不归路。二、oracle中geodatabase备份过程1、创建企业级geodatabase安装oracle客户端
  • MyBatis学习：多表映射 Landy_Jay mybatis学习数据库
    目录一、多表映射概念1.1多表查询结果映射思路1.2实体类设计方案1.2.1对一关系设计1.2.2对多关系设计多表映射案例准备二、对一映射三、对多映射四、多表映射总结4.1多表映射优化4.2总结：一、多表映射概念1.1多表查询结果映射思路数据库的表结构具有复杂性，不是所有数据库都达到第三范式或BCNF范式，故数据库查询结果与java对象的属性映射也变得复杂。MyBatis使用ResultMap实现
  • Java 如何使用 Linux 内存 -《面向技术宅的 JVM 内幕》 jvmjvm-hotspot
    为了更高的性能、更高的内存利用率、更可靠的异常溢出保护机制，Java重度重用了Linux的内存区MMap机制。k8s容器环境下，内存使用预估也依赖于对它的理解。本文主讲Java的内存分区机制。本文摘自我在编写的开源互动图书《面向技术宅的JVM内幕》中的MMap-OSMemoryRegion一节。如图片不清，请转回原文。内存分区关于JVM内存分区，可见我之前写的文章：Linux进程内存分区概念。如还
  • 关于将HashMap替换原有Map的key保持value不变报错java.util.ConcurrentModificationException的处理方案 梦岚如雪 轮子库之HashMapjava工具类java开发语言后端HashMap
    前言由于苦逼的在公司支持上线，在等待es集群分片完成过程，实在闲的无聊，将之前本地Notion记得一些笔记扔上来一些打发下时间吧(￣.￣)需求有个类似下面的数据为Map>>，其中key为资源id，value为List>,{"4757637007194717896":[{"oracleTableSpaceSize":"30000","oracleTableName":"System4","oracl
  • SQLAlchemy 介绍与实践 cliffordl pythonpython数据库
    postgresql实践pydantic实践1.SQLAlchemy介绍SQLAlchemy是一个ORM框架。SQLAlchemy是一个用于Python的SQL工具和对象关系映射（ORM）库。它允许你通过Python代码来与关系型数据库交互，而不必直接编写SQL语句。简单介绍一下对象关系映射吧，对象关系映射（英语：ObjectRelationalMapping，简称ORM，或O/RM，或O/Rma
  • 2025最新版Java面试八股文大全 m0_74823452 java面试开发语言
    一、Java并发面试题1、ThreadLocal1.1谈谈你对ThreadLocal的理解？ThreadLocal的作用主要是做数据隔离，填充的数据只属于当前线程，变量的数据对别的线程而言是相对隔离的。它不是针对程序的全局变量，只是针对当前线程的全局变量。1.2ThreadLocal底层实现原理？Threadlocal内部有一个非常关键的内部类ThreadlocalMap，里面定义了一个由key-
  • java map深拷贝_java Map深度复制问题 weixin_39860732 javamap深拷贝
    展开全部这里的pos是基础类型，不是引用类型，不需要拿出来单独复制，浅clone就可e5a48de588b63231313335323631343130323136353331333332613737以了，但是attr这个map需要进行深度复制，因为这个是引用类型，复制后的对象修改该属性依然会影响源对象clone方法可以简单写为@OverrideprotectedObjectclone()thro
  • java map深拷贝_关于HashMap的浅拷贝深拷贝 K8S技术社区 javamap深拷贝
    Map中存储的都是String，不是基本数据类型的，这个有很大影响；putAll()和clone()对基本数据类型的数据是没有问题的，但是引用类型还是不行。HashMap的浅拷贝clone()方法一、创建一个HashMap对象source，进行赋值，然后再克隆一个对象targetMap出来。通过改变targetMap的值，观察source与targetMap的变化。HashMapsource=ne
  • MapUtils常用方法 qq_41482600 java基础开发语言
    1、摘要MapUtils是一个用于处理Map对象的实用工具类，它提供了许多方便的方法来执行常见的操作，如获取值、设置默认值、合并Map等。本文将介绍MapUtils的常见用法，以帮助你更轻松地处理Map数据。2、前言在Java编程中，Map是一种常用的数据结构，用于存储键值对。然而，处理Map数据时，经常需要进行一些繁琐的操作，例如检查键是否存在，获取键对应的值，或者在键不存在时设置默认值。为了简
  • 关于Java中的Map的浅拷贝和深拷贝问题 不生气的打工人 使用笔记
    关于Java中的Map的浅拷贝和深拷贝问题发生背景生产打印的log会有图片的Base64码这并不是我们实际日志中需要关心的东西想定的解决案是在切面打印日志类中删除掉打印log的字段使用过程根据方法的参数做区分定位到对应的参数是删除掉参数中的图片字段代码if(args.length==1&&args[0]instanceofMap){MapargMap=(Map)args[0];argMap.rem
  • Java Map 深拷贝方法 qq_41482600 java基础java开发语言
    1、JSON.parseObject(JSON.toJSONString(map))importcom.alibaba.fastjson.JSON;importorg.apache.commons.lang3.SerializationUtils;importjava.util.HashMap;importjava.util.Map;publicclassJSONDemo{publicstatic
  • 设计模式(16)：观察者模式 java的艺术 GOF23设计模式设计模式观察者模式广播模式发布订阅模式java
    核心观察者模式主要用于1：N的通知。当一个对象(目标对象Subject或者Abservable)的状态变化时，他需要及时告知一系列对象(观察者对象，Observer),令他们做出响应。通知观察者的方式：推:每次都会把通知以广播方式发送给所有观察者，所有观察者只能被动接收。拉：观察者只要知道有情况变化即可。至于什么时候获取内容，获取什么内容，都可以自主决定。观察者模式角色抽象主题对象(Subject
  • 设计模式的艺术-观察者模式 晚秋贰拾伍 设计模式的艺术设计模式观察者模式运维开发运维
    行为型模式的名称、定义、学习难度和使用频率如下表所示：1.如何理解观察者模式一个对象的状态或行为的变化将导致其他对象的状态或行为也发生改变，它们之间将产生联动，正所谓“触一而牵百发”。为了更好地描述对象之间存在的这种一对多（包括一对一）的联动，观察者模式应运而生。观察者模式是使用频率最高的设计模式之一，用于建立对象与对象之间的依赖关系。一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。
  • YAML 简介及语法 yueguangni 自动化
    文章目录一、YAML简介二、YMAL语法0.注释1.标量(Scalar)1.1流标量FlowScalars1.2块标量BlockScalars2.映射(Mapping)3.序列(Sequence)4.锚点(Anchor)与别名(Alias)5.继承一、YAML简介YAML（YAMLAin'tMarkupLanguage的缩写）是一种人类可读的完整的数据序列化语言。YAML官网首页就很YAML，这很
  • C++计算精解【20】 sakura_sea 游戏引擎与高性能计算c++开发语言
    动手做汇编解释器【3】跳转语句增加了条件跳转指令，无条件跳转指令增加了cmp，没有这个指令，无法进行跳转intcmp_flag=0;作为cmp比较结果的标志位opcode_map是指令hash，所有支持的指令都在这个hash的key中，不在hash的key中的指令运行抛出异常。labels标签hash，记录标签标注指令的ip（索引）。instructions存放指令集。registers为寄存器。
  • 蓝桥杯备赛指南分享 小布先生~噫嘘唏 蓝桥杯职场和发展算法
    什么是蓝桥杯蓝桥杯是中国著名的计算机程序设计大赛，由教育部主管、全国高等学校计算机教育研究会、CCF（中国计算机学会）主办，自2002年起每年举办一次。蓝桥杯这个名字来源于江苏扬州的个园，因该园中有座名为“蓝桥”的小桥而得名。该比赛旨在提高大学生计算机程序设计能力，增强创新思维和团队协作精神，也是许多计算机相关专业学子非常看重的比赛之一。蓝桥杯举行的意义首先，蓝桥杯作为国内顶尖的计算机程序设计大赛
  • CNN的各种知识点（五）：平均精度均值（mean Average Precision, mAP） 墨绿色的摆渡人 CNN的各种知识点零碎知识点cnn均值算法目标跟踪
    平均精度均值（meanAveragePrecision,mAP）1.平均精度均值（meanAveragePrecision,mAP）概念：计算步骤：具体例子：重要说明：典型值范围：总结：好的，我将分两部分详细解答您的问题：1.平均精度均值（meanAveragePrecision,mAP）概念：mAP是目标检测中最常用的评估指标，综合反映模型在不同召回率下的平均精度表现。其核心是计算每个类别的平均
  • 【Go语言圣经】第四节：复合数据类型 YGGP Golanggolang
    第四章：复合数据类型本节主要讨论四种类型——数组、slice、map和结构体。数组和结构体都是有固定内存大小的数据结构。相比之下，slice和map则是动态的数据结构，它们可以根据需要动态增长。4.1数组数组是一个定长的由特定类型元素构成的序列。由于数组定长，因此Golang当中很少直接使用数组，而是使用slice。一个使用数组的例子如下：packagemainimport"fmt"funcmai
  • leetcode5186.区间内查询数字的频率（周赛，中等） 重you小垃 周赛题letcode5186区间内查询数字的频率
    看到调用query不超过10^5次，则query()必须控制在O(logn)以内自己的思路：定义一个unordered_maphash;//值->set的下标映射autole=hash[value].lower_bound(left);for(;*lehash;//值->vector下标映射classRangeFreqQuery{public:unordered_map>hash;RangeFre
  • 力扣2080.区间内查询数字的频率 阳光男孩01 leetcode算法职场和发展
    力扣2080.区间内查询数字的频率题目题目解析及思路题目要求求出[l,r]上val的出现次数用哈希表把所有元素的所有下标存起来，在val的数组中分别对l,r二分找到在[l,r]内的下标数量在下标上做二分把所有下标存入哈希表在left,right的范围内做二分求个数代码classRangeFreqQuery{unordered_map>pos;public:RangeFreqQuery(vector
  • CSES-1640 Sum of Two Values edward1346 算法c++
    题目传送门https://vjudge.net/problem/CSES-1640#author=GPT_zh解题思路可以开一个数组标记每个数的位置。遍历，查看是否存在，若存在直接输出。否则就是无解。由于过大，可以使用map标记。代码#includeusingnamespacestd;intn,a[200001],m;mapflag;intmain(){ios::sync_with_stdio(0
  • OSCP - Proving Grounds - Marketing 柴郡猫^O^ OSCP网络安全安全性测试
    主要知识点错误配置导致默认密码未被更改当你有一个密码的时候，尝试用它匹配尽可能多的用户，也许能遇到匹配的具体步骤执行nmap扫描，除了22/80端口开放以外，marketing.pg也很有趣，毕竟在provinggrounds里,这种pattern的字样都是需要加到/etc/hosts里的StartingNmap7.94SVN(https://nmap.org)at2024-09-2223:30U
  • 深入理解Mybatis分库分表执行原理 牛马程序员_江 mybatisunix
    深入理解Mybatis分库分表执行原理探究分库分表场景下Mybatis是如何将mapper.xml中sql的逻辑表，转换成实际执行时的物理表。前言工作多年，分库分表的场景也见到不少了，但是我仍然对其原理一知半解。趁着放假前时间比较富裕，我想要解答三个问题：为什么mybatis的mapper.xml文件里的sql不需要拼接表名中的分表？mybatis是如何识别分表位的？最近工作中遇到的问题：为什么我
  • mybatis核心配置文件 清风冉起 mybatisjavamysql
    1.核心配置文件（SqlMapConfig.xml）详解yBatis另一个核心要素就是核心配置文件。一个完整的核心配置文件的标签包括：注意:文件中的元素节点是有一定顺序的，节点位置必须按以上位置排序，否则会编译错误MyBatis核心组件包括四部分：SqlSessionFactoryBuilder（构造器）SqlSessionFactory（工厂接口）SqlSession（会话）SQLMapper（
  • Hadoop---(6)Sqoop（数据传输） Mr Cao sqoop大数据
    6.SqoopSqoop是一个用于hadoop数据和结构化数据之间转换的工具。全称SQL-TO-HADOOP.它可以把hadoop数据，包括hive和hbase存储的数据转化为结构化数据也就是数据库的数据，也可以把关系型数据库数据转化为hadoop数据这些转换操作全是通过Hadoop的MapTask来完成的，并不会涉及到Reduce操作。这是因为我们只是进行数据的拷贝，并不会对数据进行处理或者计算
  • Sqoop 支持 ORC 文件格式 吃鱼的羊 sqoop
    ORC介绍ORC文件格式是Hive0.11.0版本引入的一种文件格式。ORC的引入是为了解决其他Hive文件格式的局限性。使用ORC文件格式提升Hive读取、写入及处理数据的性能。与RCFile对比，ORC文件格式有很多优点：每个Task只输出一个文件，降低NameNode的负载。Hive数据类型支持，包括：datetime、decimal以及复杂数据类型（struct、list、map、unio
  • React中的key属性有什么作用，如何使用？ JJCTO袁龙 reactreact.jsjavascript前端
    React中的key属性：作用与使用指南在React中，key属性是一个非常重要的概念，尤其在构建动态列表时，它的作用不容小觑。理解key的使用对提高应用性能、优化渲染以及避免潜在的渲染问题都有很大的帮助。本文将详细探讨React中的key属性，为什么它是必需的以及如何正确使用它。1.key的作用在React中，当我们使用map或类似的方法生成列表时，key属性帮助React识别哪些元素已更改、添
  • Enum 枚举 120153216 enum枚举
    原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration 于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样： public static final int APPLE_FUJI = 0
  • Java8简明教程 bijian1013 javajdk1.8
            Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。  一.允许在接口中有默认方法实现         Java 8 允许我们使用default关键字，为接口声明添
  • Oracle表维护 快速备份删除数据 cuisuqiang oracle索引快速备份删除
    我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。 当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。 为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。 为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
  • java多态内存分析 麦田的设计者 java内存分析多态原理接口和抽象类
          “  时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。       但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
  • Xshell实现Windows上传文件到Linux主机 被触发 windows
    经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛； 我是怎么操作的： 1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
  • 类的加载ClassLoader 肆无忌惮_ ClassLoader
    类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。   其中重要的方法为findClass(String name)。   如何写一个自己的类加载器呢？ 首先写一个便于测试的类Student
  • html5写的玫瑰花 知了ing html5
    <html> <head> <title>I Love You!</title> <meta charset="utf-8" /> </head> <body> <canvas id="c"></canvas>
  • google的ConcurrentLinkedHashmap源代码解析 矮蛋蛋 LRU
    原文地址： http://janeky.iteye.com/blog/1534352 简述 ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对 ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见 http://code.google.com/p/concurrentlinke
  • webservice获取访问服务的ip地址 alleni123 webservice
    1. 首先注入javax.xml.ws.WebServiceContext, @Resource private WebServiceContext context; 2. 在方法中获取交换请求的对象。 javax.xml.ws.handler.MessageContext mc=context.getMessageContext(); com.sun.net.http
  • 菜鸟的java基础提升之道——————>是否值得拥有 百合不是茶
    1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员      java组成：
  • 通过修改Linux服务自动启动指定应用程序 bijian1013 linux
    Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下: chkconfig 功能说明：检查，设置系统的各种服务。 语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level  <</SPAN>
  • spring拦截器的一个简单实例 bijian1013 javaspring拦截器Interceptor
    Purview接口 package aop; public interface Purview { void checkLogin(); } Purview接口的实现类PurviesImpl.java package aop; public class PurviewImpl implements Purview { public void check
  • [Velocity二]自定义Velocity指令 bit1129 velocity
    什么是Velocity指令 在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令   自定义指令(Directive)的一般步骤 &nbs
  • 【Hive十】Programming Hive学习笔记 bit1129 programming
    第二章 Getting Started 1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
  • nginx有选择性进行限制 ronin47 nginx 动静　限制
    http { limit_conn_zone $binary_remote_addr zone=addr:10m; limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;... server {... location ~.*\.(gif|png|css|js|icon)$ {
  • java-4.-在二元树中找出和为某一值的所有路径 . bylijinnan java
    /* * 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it. * 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise
  • Netty学习笔记 bylijinnan javanetty
    本文是阅读以下两篇文章时： http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html 我的一些笔记 ===
  • js获取项目路径 cngolon js
    //js获取项目根路径，如： http://localhost:8083/uimcardprj function getRootPath(){     //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp     var curWwwPath=window.document.locati
  • oracle 的性能优化 cuishikuan oracleSQL Server
       在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。     1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
  • Shell变量和数组使用详解 daizj linuxshell变量数组
    Shell 变量 定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如： your_name="w3cschool.cc" 注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则： 首个字符必须为字母（a-z，A-Z）。 中间不能有空格，可以使用下划线（_）。 不能使用标点符号。 不能使用ba
  • 编程中的一些概念，KISS、DRY、MVC、OOP、REST dcj3sjt126com REST
    KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。 （2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。 （3）OOP 即Object-Orie
  • [Android]设置Activity为全屏显示的两种方法 dcj3sjt126com Activity
    1. 方法1：AndroidManifest.xml 里，Activity的 android:theme  指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例:   <application      
  • solrcloud 部署方式比较 eksliang solrCloud
    solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？ 第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。  第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理   谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
  • Java synchronized关键字详解 gqdy365 synchronized
    转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html 多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。 同步机制可以使用synchronized关键字实现。 当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。 当s
  • js实现登录时记住用户名 hw1287789687 记住我记住密码cookie记住用户名记住账号
    在页面中如何获取cookie值呢? 如果是JSP的话,可以通过servlet的对象request 获取cookie,可以 参考:http://hw1287789687.iteye.com/blog/2050040 如果要求登录页面是html呢?html页面中如何获取cookie呢? 直接上代码了 页面:loginInput.html 代码: <!DOCTYPE html PUB
  • 开发者必备的 Chrome 扩展 justjavac chrome
    Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
  • 算法机试题 李亚飞 java算法机试题
           在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。        这道题大致意思是：输入一个数，比如4,。这时会输出：           &n
  • 正确配置Linux系统ulimit值 字符串 ulimit
    在Linux下面部 署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用 其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
  • hibernate调用返回游标的存储过程 Supanccy2013 javaDAOoracleHibernatejdbc
    注：原创作品，转载请注明出处。     上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。     此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。 1，创建oracle中的包，并在该包中创建的游标类型。 ---创建oracle的程
  • Spring 4.2新特性-更简单的Application Event wiselyman application
    1.1 Application Event Spring 4.1的写法请参考10点睛Spring4.1-Application Event 请对比10点睛Spring4.1-Application Event 使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低; 1.2 示例 包依赖 <p