RxJava流控机制之Flowable

背景

对于生产者和消费者模型，存在一个问题就是当生产者生产的速度大于消费者消费速度，并且生产过程不会停止，生产者和消费者位于不同的线程中，这是要如何对待多余出来的生产内容？是丢掉，是缓冲？
在强大的异步处理框架中，RxJava又是怎么处理的呢？如果在工作中万一发生丢包事件怎么办？

使用环境与本文目的

RxJava版本：2.1.0
默认条件：观察者和被观察者位于main线程中，且使用了默认的事件发射器。
目的：通过Flowable，探究RxJava的流控机制。

Flowable创建过程

Flowable flowable = Flowable.create(new FlowableOnSubscribe() {
                            @Override
                            public void subscribe(FlowableEmitter e) throws Exception {
                                for(int i =0 ; i<10;i++){
                                    e.onNext(i);
                                }
                            }
                        }
                , BackpressureStrategy.BUFFER);

在create方法中，完成了对Flowable的构建过程：

public static  Flowable create(FlowableOnSubscribe source, BackpressureStrategy mode) {
        ObjectHelper.requireNonNull(source, "source is null");
        ObjectHelper.requireNonNull(mode, "mode is null");
        //在工厂中构建出一个Flowable对象。需要传入对向FlowableCreate
        //如果要构建Observable，则传入的是ObservableDefer
        return RxJavaPlugins.onAssembly(new FlowableCreate(source, mode));
    }

FlowableCreate实际上是Flowable子类。当调用Flowable的subscribe方法时，实际上将执行FlowableCreate中的subscribeActual(该方法在Flowable是一个抽象方法，在FlowableCreate中实现)方法：

public final void subscribe(FlowableSubscriber s) {
        ObjectHelper.requireNonNull(s, "s is null");
        try {
            Subscriber z = RxJavaPlugins.onSubscribe(this, s);

            ObjectHelper.requireNonNull(z, "Plugin returned null Subscriber");

            subscribeActual(z);
        }
......

subscribe过程分析

实际执行的是subscribeActual，这个方法非常重要，该方法的实现为：

BaseEmitter emitter;
        switch (backpressure) {
        case MISSING: {
            emitter = new MissingEmitter(t);
            break;
        }
        case ERROR: {
            emitter = new ErrorAsyncEmitter(t);
            break;
        }
        case DROP: {
            emitter = new DropAsyncEmitter(t);
            break;
        }
        case LATEST: {
            emitter = new LatestAsyncEmitter(t);
            break;
        }
        default: {
            emitter = new BufferAsyncEmitter(t, bufferSize());
            break;
        }
        }

        t.onSubscribe(emitter);
        try {
            source.subscribe(emitter);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            emitter.onError(ex);
        }

我们可以看到：

• 它首先会根据我们选择的背压模式，设置不同的emitter；如果没有设置，默认将开启带有缓存的emitter；
• Subscriber中的onSubscribe在事件没有发射前就执行了；
• 事件的发射，是通过source.subscribe(emitter)实现的，而这个source，实际上就是我们在构建Flowable时创建的FlowableOnSubscribe。
  现在回过来我们看看在构建时，FlowableOnSubscribe的内容,通常我们会这么写：

new FlowableOnSubscribe() {
                            @Override
                            public void subscribe(FlowableEmitter e) throws Exception {
                                for(int i =0 ; i<10;i++){
                                    e.onNext(i);
                                }
                            }
                        }

转了一圈，又回到了这里。FlowableEmitter来发射事件。默认的，将使用BufferAsyncEmitter，这是一个支持背压处理的Emitter。
该Emitter中，onNext方法是这样的：

@Override
        public void onNext(T t) {
            if (done || isCancelled()) {
                return;
            }

            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            queue.offer(t); //生产
            drain();       //实际消费过程会执行queue.poll
        }

我们看到，queue就是它维护的一个SpscLinkedArrayQueue队列(其中使用的大量的原子类型处理多线程访问问题)，队列容量会根据生产消费情况自动扩容。
生产过程，或者说事件发射过程，直接调用了队列的offer方法，进行入队操作；
消费过程，或者说消费事件，则是先使用了drain方法，该方法的本质，是执行队列的poll方法取出事件，然后在onNext()中消费。
在 offer 中主要完成生产：

//producerLookAhead相当于一个生产者的斥候，主要用于检测边界
//这里将检测，要插入的位置，是否已经越界了
 if (index < producerLookAhead) {
            return writeToQueue(buffer, e, index, offset);
        }
//else这种情况，主要时考虑到循环队列
 else {
            //producerLookAheadStep实际上是一个定值，表示固定步长
            final int lookAheadStep = producerLookAheadStep;
            // go around the buffer or resize if full (unless we hit max capacity)
            //首先检查前进了固定步长之后，是否还有位置用来插入，注意，使用calcWrappedOffset方法，
           //包括很多其他用到mask的地方，实际上是将数组作为一个循环队列使用。
           //如果前进固定步长之后，还可以插入，那么，说明生产者可用空间还有很多
            int lookAheadElementOffset = calcWrappedOffset(index + lookAheadStep, mask);
            if (null == lvElement(buffer, lookAheadElementOffset)) { // LoadLoad
                producerLookAhead = index + lookAheadStep - 1; // joy, there's plenty of room
                return writeToQueue(buffer, e, index, offset);
            }
            //检查下一插入位是否为空，如果不为空，则使用 ；
            //反之，插入位已经满了，需要创建一个新的数组以完成生产者的工作
           else if (null == lvElement(buffer, calcWrappedOffset(index + 1, mask))) { // buffer is not full
                return writeToQueue(buffer, e, index, offset);
            } else {
                //现有数组容量已经满了，消费者速度无法跟上生产者速度，
                //需要开辟一块新的空间用于生产。空间大小和现有数组大小一致。
                //这里将完成对已经生产并且尚未消费的数组进行保存的工作；
                //同时，开辟一个新的数组，用于生产
                resize(buffer, index, offset, e, mask); // add a buffer and link old to new
                return true;
            }
}

在poll中主要完成事件取出，以在onNext中消费：

public T poll() {
        // local load of field to avoid repeated loads after volatile reads
        final AtomicReferenceArray