Reactor3 Flux#create()#subscribe()源码解读：

Flux#create(Consumer<? super FluxSink>, OverflowStrategy)源码:

public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter, OverflowStrategy backpressure) {
    //接收一个Consumer，通过FluxSink来发射元素，默认背压策略OverflowStrategy.BUFFER
	return onAssembly(new FluxCreate<>(emitter, backpressure, FluxCreate.CreateMode.PUSH_PULL));
}


public final Disposable subscribe(
		@Nullable Consumer<? super T> consumer,
		@Nullable Consumer<? super Throwable> errorConsumer,
		@Nullable Runnable completeConsumer,
		@Nullable Consumer<? super Subscription> subscriptionConsumer) {
	//产生订阅，创建通用LambdaSubscriber	
	return subscribeWith(new LambdaSubscriber<>(consumer, errorConsumer,
			completeConsumer,
			subscriptionConsumer));
}

@Override
public void subscribe(CoreSubscriber<? super T> actual) {
    //创建一个源，包装LambdaSubscriber和背压策略
	BaseSink<T> sink = createSink(actual, backpressure);

    //若订阅时自定义传入了参数subscriptionConsumer，则执行subscriptionConsumer.accept(s)，也就是执行FluxCreate#subscribe(x,x,x,x)的第四个参数Consumer<? super Subscription> subscriptionConsumer，实际上也就是执行s.request(long)，long自定义传入值。
    //这句其实就是Subscriber#onSubscribe(Subscription)，之后会调用Subscription#request(long)，只有在Subscription#request(long)执行后，数据才真正流动
	actual.onSubscribe(sink);
	try {
	    
	    //Consumer<? super FluxSink>执行过程，下发元素。需要传入一个FluxSink，这里创建一个SerializedSink通过维护一个BufferAsyncSink增强，调用BaseSink#onNext()
		source.accept(
				createMode == CreateMode.PUSH_PULL ? new SerializedSink<>(sink) :
						sink);
	}
	catch (Throwable ex) {
		Exceptions.throwIfFatal(ex);
		sink.error(Operators.onOperatorError(ex, actual.currentContext()));
	}
}

//Subscription#request(long)会调用BufferAsyncSink#drain()，这块也是背压的体现
void drain() {
		if (WIP.getAndIncrement(this) != 0) {
			return;
		}

		int missed = 1;
		final Subscriber<? super T> a = actual;
		final Queue<T> q = queue;

		for (; ; ) {
		    //消费者消费能力，请求消费个数
			long r = requested;
			
			//queue中弹出的元素数量
			long e = 0L;

			while (e != r) {
				if (isCancelled()) {
					Operators.onDiscardQueueWithClear(q, ctx, null);
					return;
				}

				boolean d = done;

                //当queue size为0时，弹出o为null
				T o = q.poll();

				boolean empty = o == null;

				if (d && empty) {
					Throwable ex = error;
					if (ex != null) {
						super.error(ex);
					}
					else {
						super.complete();
					}
					return;
				}
                
                    //queue没弹出元素时，直接退出while
				if (empty) {
					break;
				}

				a.onNext(o);

				e++;
			}

			if (e == r) {
				if (isCancelled()) {
					Operators.onDiscardQueueWithClear(q, ctx, null);
					return;
				}

				boolean d = done;

				boolean empty = q.isEmpty();

				if (d && empty) {
					Throwable ex = error;
					if (ex != null) {
						super.error(ex);
					}
					else {
						super.complete();
					}
					return;
				}
			}

			if (e != 0) {
			    //如果从queue中取到了元素，将request请求元素数量-1
				Operators.produced(REQUESTED, this, e);
			}

			missed = WIP.addAndGet(this, -missed);
			if (missed == 0) {
				break;
			}
		}
	}

    //BufferAsyncSink#next
	@Override
	public FluxSink<T> next(T t) {
	    //存入queue
		queue.offer(t);
		
	    //根据Subscription#request(n)参数，下发n个元素并调用Subscriber#onNext()消费.
		drain();
		return this;
	}

总结:Flux#create()传入Consumer<? super FluxSink>对象通过定义一系列下发元素过程、背压策略、拉取元素模式创建生产者，其包装了源、背压、拉取元素模式。当调用subscriber()产生订阅时，通过传入一系列消费过程Consumer<>对象创建基础消费者LambdaSubscriber，之后通过Publisher.subscribe(Sbscriber)建立发布订阅过程。在该过程中，包装源、Subscription，调用Subscriber#onSubscribe(Subscription)建立生产者订阅者关系即数据流动，进而下发元素调用消费者消费。在下发元素时，源维护一个queue用来实现背压，消费者根据自身消费能力发出Subscription.request()进而调用FluxSink#next()发射元素，元素下发时从queue中弹出,消费后请求元素数-1.