Rxjava(创建类)--Range

最新推荐文章于 2021-11-24 11:11:37 发布

new_abc

最新推荐文章于 2021-11-24 11:11:37 发布

阅读量642

点赞数

CC 4.0 BY-SA版权

分类专栏： RxJava RxJava系列文章

本文链接：https://blog.youkuaiyun.com/new_abc/article/details/52913981

RxJava 同时被 2 个专栏收录

50 篇文章

订阅专栏

RxJava系列文章

46 篇文章

订阅专栏

本文详细介绍了RxJava中的Range操作符，该操作符用于创建发射特定整数序列的Observable。文章解释了Range操作符的实现原理，包括其如何处理正数、零和负数的计数情况，并展示了具体的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

创建一个发射特定整数序列的Observable,Range操作符发射一个范围内的有序整数序列，你可以指定范围的起始和长度。

RxJava将这个操作符实现为range函数，它接受两个参数，一个是范围的起始值，一个是范围的数据的数目。如果你将第二个参数设为0，将导致Observable不发射任何数据（如果设置为负数，会抛异常）。

Observable.<String>range(10, 10).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                log(integer + "");
            }
        });
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

我们看下range实现

public static Observable<Integer> range(int start, int count) {
        if (count < 0) {
            throw new IllegalArgumentException("Count can not be negative");
        }
        if (count == 0) {
            return Observable.empty();
        }
        if (start > Integer.MAX_VALUE - count + 1) {
            throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");
        }
        if(count == 1) {
            return Observable.just(start);
        }
        return Observable.create(new OnSubscribeRange(start, start + (count - 1)));
    }

我们看一下OnSubscribeRange的call方法

    @Override
    public void call(final Subscriber<? super Integer> childSubscriber) {
        childSubscriber.setProducer(new RangeProducer(childSubscriber, startIndex, endIndex));
    }

这里它也是通过Producer实现的

根据前面的分析，我们看下它的Producer的request的实现

public void request(long requestedAmount) {
            if (get() == Long.MAX_VALUE) {
                // already started with fast-path
                return;
            }
            if (requestedAmount == Long.MAX_VALUE && compareAndSet(0L, Long.MAX_VALUE)) {
                // fast-path without backpressure
                fastPath();
            } else if (requestedAmount > 0L) {
                long c = BackpressureUtils.getAndAddRequest(this, requestedAmount);
                if (c == 0L) {
                    // backpressure is requested
                    slowPath(requestedAmount);
                }
            }
        }

这里requestedAmount为MAX_VALUE进入fastPath

void fastPath() {
            final long endIndex = this.endOfRange + 1L;
            final Subscriber<? super Integer> childSubscriber = this.childSubscriber;
            for (long index = currentIndex; index != endIndex; index++) {
                if (childSubscriber.isUnsubscribed()) {
                    return;
                }
                childSubscriber.onNext((int) index);
            }
            if (!childSubscriber.isUnsubscribed()) {
                childSubscriber.onCompleted();
            }
        }

这里可以看到，从currentIndex到endIndex一次调用了onNext,最后调用onCompleted