Rxjava(变换类)-concatMap

最新推荐文章于 2022-04-23 20:40:10 发布
最新推荐文章于 2022-04-23 20:40:10 发布
阅读量1.6k 收藏
点赞数
分类专栏： RxJava RxJava系列文章
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/new_abc/article/details/52944321
版权

demo

        Observable.from(aa).concatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer number) {
                return Observable.just(number * number).subscribeOn(Schedulers.from(JobExecutor.getInstance()));
            }

        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.print(integer + ", ");
            }
        });

看下contctMap 

    public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<? extends R>> func) {
        if (this instanceof ScalarSynchronousObservable) {
            ScalarSynchronousObservable<T> scalar = (ScalarSynchronousObservable<T>) this;
            return scalar.scalarFlatMap(func);
        }
        return create(new OnSubscribeConcatMap<T, R>(this, func, 2, OnSubscribeConcatMap.IMMEDIATE));
    }

这里 如果 是 ScalarSynchronousObservable 就跟flatMap一样，我们看下不是ScalarSynchronousObservable类型

这里会创建一个OnSubscribeConcatMap，这里会把Func1保存到mapper，另外两个参数是 2, OnSubscribeConcatMap.IMMEDIATE

然后后面subscribe的时候会调用OnSubscribeConcatMap的call函数，我们看一下它的实现

public void call(Subscriber<? super R> child) {
        Subscriber<? super R> s;

        if (delayErrorMode == IMMEDIATE) {
            s = new SerializedSubscriber<R>(child);
        } else {
            s = child;
        }

        final ConcatMapSubscriber<T, R> parent = new ConcatMapSubscriber<T, R>(s, mapper, prefetch, delayErrorMode);

        child.add(parent);
        child.add(parent.inner);
        child.setProducer(new Producer() {
            @Override
            public void request(long n) {
                parent.requestMore(n);
            }
        });

        if (!child.isUnsubscribed()) {
            source.unsafeSubscribe(parent);
        }
    }
这里delayErrorMode == IMMEDIATE，走if分支，创建一个SerializedSubscriber

然后以前面创建的SerializedSubscriber另加mapper, prefetch, delayErrorMode创建ConcatMapSubscriber

        public ConcatMapSubscriber(Subscriber<? super R> actual,
                Func1<? super T, ? extends Observable<? extends R>> mapper, int prefetch, int delayErrorMode) {
            this.actual = actual;
            this.mapper = mapper;
            this.delayErrorMode = delayErrorMode;
            this.arbiter = new ProducerArbiter();
            this.wip = new AtomicInteger();
            this.error = new AtomicReference<Throwable>();
            Queue<Object> q;
            if (UnsafeAccess.isUnsafeAvailable()) {
                q = new SpscArrayQueue<Object>(prefetch);
            } else {
                q = new SpscAtomicArrayQueue<Object>(prefetch);
            }
            this.queue = q;
            this.inner = new SerialSubscription();
            this.request(prefetch);
        }
这里会创建一个ProducerArbiter，调用request，这里prefetch是2 

protected final void request(long n) {
        if (n < 0) {
            throw new IllegalArgumentException("number requested cannot be negative: " + n);
        }

        // if producer is set then we will request from it
        // otherwise we increase the requested count by n
        Producer producerToRequestFrom;
        synchronized (this) {
            if (producer != null) {
                producerToRequestFrom = producer;
            } else {
                addToRequested(n);
                return;
            }
        }
        // after releasing lock (we should not make requests holding a lock)
        producerToRequestFrom.request(n);
    }

producer为null,调用addToRequested

    private void addToRequested(long n) {
        if (requested == NOT_SET) {
            requested = n;
        } else {
            final long total = requested + n;
            // check if overflow occurred
            if (total < 0) {
                requested = Long.MAX_VALUE;
            } else {
                requested = total;
            }
        }
    }

这里把requested设置为了2

回到前面的call函数

然后调用child 的setProducer，最终会调用到这里Producer的request方法

从而调用

 parent.requestMore(n);
这里的parent就是我们刚刚创建的ConcatMapSubscriber，我们看下它的requestMore方法 

        void requestMore(long n) {
            if (n > 0) {
                arbiter.request(n);
            } else
            if (n < 0) {
                throw new IllegalArgumentException("n >= 0 required but it was " + n);
            }
        }
arbiter就是前面创建的ProducerArbiter 

 public void request(long n) {
        if (n < 0) {
            throw new IllegalArgumentException("n >= 0 required");
        }
        if (n == 0) {
            return;
        }
        synchronized (this) {
            if (emitting) {
                missedRequested += n;
                return;
            }
            emitting = true;
        }
        boolean skipFinal = false;
        try {
            long r = requested;
            long u = r + n;
            if (u < 0) {
                u = Long.MAX_VALUE;
            }
            requested = u;

            Producer p = currentProducer;
            if (p != null) {
                p.request(n);
            }

            emitLoop();
            skipFinal = true;
        } finally {
            if (!skipFinal) {
                synchronized (this) {
                    emitting = false;
                }
            }
        }
    }

这里n为Long.MAX_VALUE

emitting设置为true，currentProducer为null,调用emitLoop

public void emitLoop() {
        for (;;) {
            long localRequested;
            long localProduced;
            Producer localProducer;
            synchronized (this) {
                localRequested = missedRequested;
                localProduced = missedProduced;
                localProducer = missedProducer;
                if (localRequested == 0L
                        && localProduced == 0L
                        && localProducer == null) {
                    emitting = false;
                    return;
                }
                missedRequested = 0L;
                missedProduced = 0L;
                missedProducer = null;
            }

            long r = requested;

            if (r != Long.MAX_VALUE) {
                long u = r + localRequested;
                if (u < 0 || u == Long.MAX_VALUE) {
                    r = Long.MAX_VALUE;
                    requested = r;
                } else {
                    long v = u - localProduced;
                    if (v < 0) {
                        throw new IllegalStateException("more produced than requested");
                    }
                    r = v;
                    requested = v;
                }
            }
            if (localProducer != null) {
                if (localProducer == NULL_PRODUCER) {
                    currentProducer = null;
                } else {
                    currentProducer = localProducer;
                    localProducer.request(r);
                }
            } else {
                Producer p = currentProducer;
                if (p != null && localRequested != 0L) {
                    p.request(localRequested);
                }
            }
        }
    }
满足 
if (localRequested == 0L
                        && localProduced == 0L
                        && localProducer == null)
把emitting设置为false返回

再次回到call函数，调用

 source.unsafeSubscribe(parent);
调用source的call函数，这里的source是OnSubscribeFromIterable 

public void call(final Subscriber<? super T> o) {
        Iterator<? extends T> it;
        boolean b;

        try {
            it = is.iterator();

            b = it.hasNext();
        } catch (Throwable ex) {
            Exceptions.throwOrReport(ex, o);
            return;
        }

        if (!o.isUnsubscribed()) {
            if (!b) {
                o.onCompleted();
            } else {
                o.setProducer(new IterableProducer<T>(o, it));
            }
        }
    }
先获取值，然后调用setProducer，这里new了一个IterableProducer，最终会调用它的request方法，这里的o是ConcatMapSubscriber 

       @Override
        public void request(long n) {
            if (get() == Long.MAX_VALUE) {
                // already started with fast-path
                return;
            }
            if (n == Long.MAX_VALUE && compareAndSet(0, Long.MAX_VALUE)) {
                fastPath();
            } else
            if (n > 0 && BackpressureUtils.getAndAddRequest(this, n) == 0L) {
                slowPath(n);
            }

        }
这里n为2，前面初始化ConcatMapSubscriber的时候设置的

所以这里走的是slowPath

void slowPath(long n) {
            // backpressure is requested
            final Subscriber<? super T> o = this.o;
            final Iterator<? extends T> it = this.it;

            long r = n;
            long e = 0;

            for (;;) {
                while (e != r) {
                    if (o.isUnsubscribed()) {
                        return;
                    }

                    T value;

                    try {
                        value = it.next();
                    } catch (Throwable ex) {
                        Exceptions.throwOrReport(ex, o);
                        return;
                    }

                    o.onNext(value);

                    if (o.isUnsubscribed()) {
                        return;
                    }

                    boolean b;

                    try {
                        b = it.hasNext();
                    } catch (Throwable ex) {
                        Exceptions.throwOrReport(ex, o);
                        return;
                    }

                    if (!b) {
                        if (!o.isUnsubscribed()) {
                            o.onCompleted();
                        }
                        return;
                    }

                    e++;
                }

                r = get();
                if (e == r) {
                    r = BackpressureUtils.produced(this, e);
                    if (r == 0L) {
                        break;
                    }
                    e = 0L;
                }
            }

        }
之类调用o的onNext，o是ConcatMapSubscriber 

        @Override
        public void onNext(T t) {
            if (!queue.offer(NotificationLite.next(t))) {
                unsubscribe();
                onError(new MissingBackpressureException());
            } else {
                drain();
            }
        }
queue.offer会把当前值入队列调用drain 

void drain() {
            if (wip.getAndIncrement() != 0) {
                return;
            }

            final int delayErrorMode = this.delayErrorMode;

            for (;;) {
                if (actual.isUnsubscribed()) {
                    return;
                }

                if (!active) {
                    if (delayErrorMode == BOUNDARY) {
                        if (error.get() != null) {
                            Throwable ex = ExceptionsUtils.terminate(error);
                            if (!ExceptionsUtils.isTerminated(ex)) {
                                actual.onError(ex);
                            }
                            return;
                        }
                    }

                    boolean mainDone = done;
                    Object v = queue.poll();
                    boolean empty = v == null;

                    if (mainDone && empty) {
                        Throwable ex = ExceptionsUtils.terminate(error);
                        if (ex == null) {
                            actual.onCompleted();
                        } else
                        if (!ExceptionsUtils.isTerminated(ex)) {
                            actual.onError(ex);
                        }
                        return;
                    }

                    if (!empty) {

                        Observable<? extends R> source;

                        try {
                            source = mapper.call(NotificationLite.<T>getValue(v));
                        } catch (Throwable mapperError) {
                            Exceptions.throwIfFatal(mapperError);
                            drainError(mapperError);
                            return;
                        }

                        if (source == null) {
                            drainError(new NullPointerException("The source returned by the mapper was null"));
                            return;
                        }

                        if (source != Observable.empty()) {

                            if (source instanceof ScalarSynchronousObservable) {
                                ScalarSynchronousObservable<? extends R> scalarSource = (ScalarSynchronousObservable<? extends R>) source;

                                active = true;

                                arbiter.setProducer(new ConcatMapInnerScalarProducer<T, R>(scalarSource.get(), this));
                            } else {
                                ConcatMapInnerSubscriber<T, R> innerSubscriber = new ConcatMapInnerSubscriber<T, R>(this);
                                inner.set(innerSubscriber);

                                if (!innerSubscriber.isUnsubscribed()) {
                                    active = true;

                                    source.unsafeSubscribe(innerSubscriber);
                                } else {
                                    return;
                                }
                            }
                            request(1);
                        } else {
                            request(1);
                            continue;
                        }
                    }
                }
                if (wip.decrementAndGet() == 0) {
                    break;
                }
            }
        }
active开始为false,进入后会把它设置为true，这里如果 active为true，则表示前一个操作未完成，直接返回（前一个操作什么时候完成后面会讲）
出队列，主要的是调用mapper的call函数 

public Observable<Integer> call(Integer number) {
                return Observable.just(number * number).subscribeOn(Schedulers.from(JobExecutor.getInstance()));
            }
最终会创建一个ScalarAsyncOnSubscribe它的onSubscribe是OperatorSubscribeOn  

回到drain函数，source不是ScalarSynchronousObservable，走else分支

 ConcatMapInnerSubscriber<T, R> innerSubscriber = new ConcatMapInnerSubscriber<T, R>(this);
                                inner.set(innerSubscriber);

                                if (!innerSubscriber.isUnsubscribed()) {
                                    active = true;

                                    source.unsafeSubscribe(innerSubscriber);
                                } else {
                                    return;
                                }
                            }
                            request(1);

创建一个ConcatMapInnerSubscriber并设置给inner，inner是我们初始化时创建的SerialSubscription

并走if分支，active设置为true，调用unsafeSubscribe,最终调用ScalarAsyncOnSubscribe的call函数

 public void call(Subscriber<? super T> s) {
            s.setProducer(new ScalarAsyncProducer<T>(s, value, onSchedule));
        }

这里创建了一个ScalarAsyncProducer，调用setProducer 

        @Override
        public void setProducer(Producer p) {
            parent.arbiter.setProducer(p);
        }

这里的arbiter是ProducerArbiter， 

public void setProducer(Producer newProducer) {
        synchronized (this) {
            if (emitting) {
                missedProducer = newProducer == null ? NULL_PRODUCER : newProducer;
                return;
            }
            emitting = true;
        }
        boolean skipFinal = false;
        try {
            currentProducer = newProducer;
            if (newProducer != null) {
                newProducer.request(requested);
            }

            emitLoop();
            skipFinal = true;
        } finally {
            if (!skipFinal) {
                synchronized (this) {
                    emitting = false;
                }
            }
        }
    }

主要调用 

 newProducer.request(requested);
newProducer为ScalarAsyncProducer 
        @Override
        public void request(long n) {
            if (n < 0L) {
                throw new IllegalArgumentException("n >= 0 required but it was " + n);
            }
            if (n != 0 && compareAndSet(false, true)) {
                actual.add(onSchedule.call(this));
            }
        }
我们看一下onSchedule 

      w.schedule(new Action0() {
                        @Override
                        public void call() {
                            try {
                                a.call();
                            } finally {
                                w.unsubscribe();
                            }
                        }
                    });

------------------------------------------------------------------------------------------------------------

这里的a是ScalarSynchronousObservable，这里已经在另外一个线程执行了

我们看一下他的call

 @Override
        public void call() {
            Subscriber<? super T> a = actual;
            if (a.isUnsubscribed()) {
                return;
            }
            T v = value;
            try {
                a.onNext(v);
            } catch (Throwable e) {
                Exceptions.throwOrReport(e, a, v);
                return;
            }
            if (a.isUnsubscribed()) {
                return;
            }
            a.onCompleted();
        }
这里的a是ConcatMapInnerSubscriber，他的onNext函数我们就不去分析了，我们看一下他的onComplete函数 

 public void onCompleted() {
            parent.innerCompleted(produced);
        }
这里parent为ConcatMapSubscriber 

     void innerCompleted(long produced) {
            if (produced != 0L) {
                arbiter.produced(produced);
            }
            active = false;
            drain();
        }

这里会把active 设置为false重新调用drain函数，如果队列中有值，则继续执行队列中的请求
----------------------------------------------------------------------------------

我们重新回到前面第一个线程在schedule启动一个线程之后，继续回到slowPath，然后处理下一个请求，把值入队列，如果当前有请求执行，则返回。这样所有的执行都是一个接着一个执行的。

所以最终的输出结果也是顺序的

4, 9, 16, 25, 36, 49, 64, 81, 100,
这里在调试的时候为了 延迟一个操作执行的时间，模拟一个操作长时间执行，drain中active 为false状态，我们可以在sursurib中添加sleep 

      ArrayList aa = new ArrayList<>(Arrays.asList(2, 3, 4, 5, 6, 7, 8, 9, 10));
        Observable.from(aa).concatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer number) {
                return Observable.just(number * number).subscribeOn(Schedulers.from(JobExecutor.getInstance()));
            }

        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.print(integer + ", ");
                try {
                    Thread.sleep(60000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });












new_abc
关注
专栏目录
RxJava2 Flowable concatMap（转换操作符）
无问西东的博客
10-05 1381
concatMap系列（变换操作符） 目录 concatMap接口 concatMap系列图解 concatMap测试用例 concatMap测试用例说明 concatMap接口 <R>Flowable<R> concatMap(Function<? superT,? extendsPublisher<? extends R&gt...
RxJava2 系列-1：一篇的比较全面的 RxJava2 方法总结
你好，开发者
11-04 1280
看了许多讲解RxJava的文章，有些文章讲解的内容是基于第一个版本的，有些文章的讲解是通过比较常用的一些API和基础的概念进行讲解的。 但是每次看到RxJava的类中的几十个方法的时候，总是感觉心里没底。所以，我打算自己去专门写篇文章来从API的角度系统地梳理一下RxJava的各种方法和用法。 1、RxJava 基本 1.1 RxJava 简介 RxJava是一个在Java VM上使用可观测的序列...
RXJAVA-concatMap
大新博客
02-22 672
与flatMap类似，concatMap它和flatMap的作用几乎一模一样, 只是它的结果是严格按照上游发送的顺序来发送的, 来看个代码吧: package com.netty.demo.vertx; import io.reactivex.*; import io.reactivex.functions.Consumer; import io.reactivex.functions.Function; import io.reactivex.schedulers.Schedulers; impor
RxJava（四）concatMap 操作符用法详解
热门推荐
Chiclaim
05-29 2万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
flatMap（）与concatMap（）与concatMapEager（）– RxJava常见问题解答
最佳 Java 编程
06-06 584
RxJava 2.x中共有三个无缝相似的运算符： flatMap() ， concatMap()和concatMapEager() 。 它们都接受相同的参数-从原始流的单个项目到任意类型的（子）流的函数。 换句话说，如果您有Flowable<T>则可以为任意R类型提供从T到Flowable<R>的函数。 应用任何这些运算符后，您最终得到Flowable<R&gt...
RxJava转换操作符 conactMap
小炫风技术旅行
02-25 1273
concatMap操作符是将源Observable转换成对各操作符，然后又链接返回给源Observable，这与flatMap十分相似，最大的区别:concatMap 是保证结果的顺序性，就是顺序与输入一致. 例子:在这里最大的数线程延迟最长，照理应该是最大的数最后出来,结果很意外: Observable.just(2, 1).concatMap(new Func1>() {
RxJava-Intro-For-Android:Android中RxJava的快速入门项目
05-12
通过操作符如`map`、`filter`、`reduce`等，可以对数据流进行变换和处理，这些操作符允许开发者编写声明式代码，而不是命令式代码。 **3. 异步编程** 在Android开发中，UI线程不能执行耗时操作，否则会导致应用无...
rxjava-retrofit-okhttp
01-31
它提供了丰富的操作符，如map、filter、concatMap等，用于对数据流进行变换和组合。 **Retrofit** 是由Square公司开发的一个类型安全的HTTP客户端，专门用于Android和Java。Retrofit允许开发者定义API接口，然后...
Rxjava2:Rxjava2源码解析-源码解析
03-24
目录 1，可观察与观察者 2，Rxjava线程调度原理 3，observeOn与subscribeOn控制线程的执行顺序...4，concatMap为何在变换中有序输出 目录 1，zip原始码解析 目录 1，背压的产生 2，Flowable原始解析 欢迎大佬指出问题！
RxJava之concatMap系列转换操作符源码介绍
103style
06-05 1284
转载请以链接形式标明出处： 本文出自:103style的博客 转换相关的操作符 以及 官方介绍 RxJava 之 concatMap 系列 转换操作符 官方介绍 ：Transforming Observables concatMap concatMapCompletable concatMapCompletableDelayError concatMapDelayError concatMa...
RxJava（四） concatMap操作符用法详解
android开发笔记
06-18 1106
concatMap操作符的作用 concatMap操作符和flatMap操作符非常类似。如果对 flatMap操作符 不是很了解可以点击链接去看看我的上一篇博文。下面是concatMap操作符的流程图： concatMap和flatMap最大的区别是concatMap发射的数据集是有序的，flatMap发射的数据集是无序的。 concatMap操作符的用法示例 通过上一篇对flatMap的...
RxJava变换操作符：.concatMap( )与.flatMap( )的比较
tjj93622的专栏
08-01 420
原文链接：http://www.jianshu.com/p/6d16805537efObservable 转换 当你有一个需要订阅的Observable，并且希望转换结果的时候（切记，响应式编程中一切皆流）。即将涉及到observable转换的时候，从队列中取出将要消费的事件，不可能一直是我们需要的格式或者形状，可能每个值都需要扩展成更丰富的对象或者化作更多的值。为了达到目的，我们可以为每一个ob
mysql 正则regrx_RxJava（四） concatMap操作符用法详解
weixin_30016961的博客
02-18 115
concatMap操作符的作用concatMap操作符和flatMap操作符非常类似。如果对 flatMap操作符 不是很了解可以点击链接去看看我的上一篇博文。下面是concatMap操作符的流程图：concatMap和flatMap最大的区别是concatMap发射的数据集是有序的，flatMap发射的数据集是无序的。concatMap操作符的用法示例通过上一篇对flatMap的介绍，我们的例子...
Rxjava从入门到精通：Rxjava转换操作符之 Map(), flatMap() ,，concatmap()，compose() 使用示例
C++ JAVA的专栏
04-23 1859
Rxjava从入门到精通：Rxjava转换操作符之 Map(), flatMap() ,，concatmap()，compose() 使用示例
Haskell-- concatMap详解
Kevin.wang
10-30 1169
经过了几次Haskell的作业后，发现concatMap对于list的作用极其强大，下面就具体讲解一下concatMap的作用： 文章目录1.concatMap定义及类型：2.Map定义及类型：3.举例说明 1.concatMap定义及类型： Map a function over a list and concatenate the results. 将函数映射到列表并连接结果 concatM...
Rxjava合并，连接操作符
路漫漫其修远兮
07-26 936
Rxjava合并操作符 合并操作符 作用 startWith 在Observable发射的数据前添加一个数据， merge, mergeDelayError 将多个Observable合并为一个，mergeDelayError,是全部Observable发射完执行onError zip 使用一个函数组合多个Observable发射的数据，然后再...
concatMap VS flatMap
zhkm_cb的专栏
10-17 1021
今天看WebFlux源码时看到DispatcherHandler了，发现处理请求时寻找匹配的handler使用的时concatMap，于是好奇的开始研究起它于flatMap的区别。 @Override public Mono<Void> handle(ServerWebExchange exchange) { if (this.handlerMappings == null...
RxJava 源码解读之 ConcatMap
weixin_34128839的博客
08-08 140
上一篇文章中我们学习了RxJava2中 FlatMap 的原理，同时知道，FlatMap经过转换后发射的数据不是严格有序的，如果需要数据按顺序被发射，RxJava2提供了另外一个操作符, 也是这篇文章的主角 — ConcatMap. FlatMap vs ConcatMap 之前分析了FlatMap发射数据无序的原因，但是没有实际用代码验证过，这里我们在分析ConcatMap源码之前，我们先运...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值