基础
顶级接口
Subscription： 生产消费对象参数 。用于发布者与订阅者之间的通信(实现背压：订阅者能够告诉生产者需要多少数据)
package org.reactivestreams;
public interface Publisher<T> {
//注册订阅者
public void subscribe(Subscriber<? super T> s);
}
public interface Subscriber<T> {
/* 该方法在订阅Publisher之后执行，在订阅之前不会有数据流的消费
无论何时当需要数据时，由当前Subscriber调用Subscription#request(long)
Publisher仅当响应Subscription#request(long)时才会发送通知。
*/
public void onSubscribe(Subscription s);
/** Publisher响应Subscription#request(long)调用发送的数据。
* 消费下一个消息，在执行request方法之后通知Publisher，可被调用多次，有request（x），参数x决定执行几次
*
* @param t the element signaled
*/
public void onNext(T t);
/**
* 订阅失败事件。即使Subscription#request(long)再次被调用，也不会发送任何事件。
* @param t the throwable signaled
*/
public void onError(Throwable t);
/**
* 订阅成功事件
*/
public void onComplete();
}
public interface Subscription {
/**
* 消费请求 。request(n)来决定这次subscribe获取元素的最大数目
*/
public void request(long n);
/**
* 取消请求。并且清除resources。cancel执行后，不一定会立即取消，可能由于前面的信号。
*/
public void cancel();
}
public interface Processor<T, R> extends Subscriber<T>, Publisher<R> {
}
reactor
public interface CorePublisher<T> extends Publisher<T> {
void subscribe(CoreSubscriber<? super T> subscriber);
}
public interface CoreSubscriber<T> extends Subscriber<T> {
/** 上下文。可以包含下游操作。
*/
default Context currentContext(){
return Context.empty();
}
@Override
void onSubscribe(Subscription s);
}
/**指示一个任务或资源可以被取消，清理。
*/
public interface Disposable {
/**此方法需要幂等。*/
void dispose();
/**返回false，状态不定义正确，但是返回true，必须表示资源被释放。*/
default boolean isDisposed() {
return false;
}
}
/*可融合的，指示生产者是否支持QueueSubscription
*/
public interface Fuseable{
/** Indicates the QueueSubscription can't support the requested mode. */
int NONE = 0;
/** Indicates the QueueSubscription can perform sync-fusion. */
int SYNC = 1;
/** Indicates the QueueSubscription can perform only async-fusion. */
int ASYNC = 2;
/** Indicates the QueueSubscription should decide what fusion it performs (input only). */
int ANY = 3;
/** Indicates that the queue will be drained from another thread */
int THREAD_BARRIER = 4;
//可快速返回结果的Subscriber，即可以try。
interface ConditionalSubscriber<T> extends CoreSubscriber<T> {
/**尝试消费，成功返回true。丢弃或者发送一个新的值时返回false。
* @param t the value to consume, not null
* @return 成功返回true。丢弃或者发送一个新的值时返回false。
*/
boolean tryOnNext(T t);
}
/*Support contract for queue-fusion based optimizations on subscriptions.*/
interface QueueSubscription<T> extends Queue<T>, Subscription{
}
interface SynchronousSubscription<T> extends QueueSubscription<T> {
@Override
default int requestFusion(int requestedMode) {
if ((requestedMode & Fuseable.SYNC) != 0) {
return Fuseable.SYNC;
}
return NONE;
}
}
/*标记接口，表示一个target可以返回一个值或null，或立即失败。*/
interface ScalarCallable<T> extends Callable<T> {
}
}
/*返回状态*/
public interface Scannable {
Object scanUnsafe(Attr key);
}
//表明Publisher是个source，产生数据
interface SourceProducer<O> extends Scannable, Publisher<O> {
@Override
@Nullable
default Object scanUnsafe(Attr key) {
if (key == Attr.PARENT) return Scannable.from(null);
if (key == Attr.ACTUAL) return Scannable.from(null);
return null;
}
@Override
default String stepName() {
return "source(" + getClass().getSimpleName() + ")";
}
}
//可以返回真实的订阅者。
interface InnerProducer<O>
extends Scannable, Subscription {
CoreSubscriber<? super O> actual();
@Override
@Nullable
default Object scanUnsafe(Attr key){
if (key == Attr.ACTUAL) {
return actual();
}
return null;
}
}
//InnerConsumer是一个Scannable的 CoreSubscriber
interface InnerConsumer<I>
extends CoreSubscriber<I>, Scannable {
@Override
default String stepName() {
String name = getClass().getSimpleName();
if (name.contains("@") && name.contains("$")) {
name = name
.substring(0, name.indexOf('$'))
.substring(name.lastIndexOf('.') + 1);
}
String stripped = OPERATOR_NAME_UNRELATED_WORDS_PATTERN
.matcher(name)
.replaceAll("");
if (!stripped.isEmpty()) {
return stripped.substring(0, 1).toLowerCase() + stripped.substring(1);
}
return stripped;
}
}
核心原理
Reactor 项目主要包含 Reactor Core 和 Reactor Netty 两部分。Reactor Core 实现了反应式编程的核心功能，Reactor Netty 则是 Spring WebFlux 等技术的基础。
core
整个 Project Reactor 的核心调用分为下面几个阶段：
- 声明阶段
- subscribe 阶段
- onSubscribe 阶段
- request 阶段
- 调用阶段
声明阶段
反应式编程和传统风格的编程一个最大的不同点在于，开发人员编写的大部分代码都是在声明处理过程。即这些代码并不会被实际的执行，直到开始被订阅。这便是为何第一阶段是声明阶段的原因。
声明阶段也可以看做构造责任链阶段，每调用一次处理函数，即产生一个中间操作。中间操作会产生一个Publisher，同时
内部还会构造一个Subscription和Subscriber来控制中间操作的订阅。
FluxOperator
public abstract class FluxOperator<I, O> extends Flux<O> implements Scannable {
//源，即upstream。
protected final Flux<? extends I> source;
protected FluxOperator(Flux<? extends I> source) {
this.source = Objects.requireNonNull(source);
}
... ...
}
OptimizableOperator
优化操作。把操作封装成链式调用。
interface OptimizableOperator<IN, OUT> extends CorePublisher<IN> {
@Nullable
//对实际Subscriber进行封装。
CoreSubscriber<? super OUT> subscribeOrReturn(CoreSubscriber<? super IN> actual) throws Throwable;
CorePublisher<? extends OUT> source();
//把递归调用调整为looping时，返回下一个调用。
OptimizableOperator<?, ? extends OUT> nextOptimizableSource();
}
InternalFluxOperator
abstract class InternalFluxOperator<I, O> extends FluxOperator<I, O> implements Scannable,OptimizableOperator<O, I> {
protected InternalFluxOperator(Flux<? extends I> source) {
super(source);
if (source instanceof OptimizableOperator) {
@SuppressWarnings("unchecked")
OptimizableOperator<?, I> optimSource = (OptimizableOperator<?, I>) source;
this.optimizableOperator = optimSource;
}
else {
this.optimizableOperator = null;
}
}
@Nullable
public abstract CoreSubscriber<? super I> subscribeOrReturn(CoreSubscriber<? super O> actual) throws Throwable;
@Override
public final OptimizableOperator<?, ? extends I> nextOptimizableSource() {
return optimizableOperator;
}
//Publisher#subscribe，调整为looping调用
public final void subscribe(CoreSubscriber<? super O> subscriber) {
OptimizableOperator operator = this;
try {
while (true) {
//包装subscriber
subscriber = operator.subscribeOrReturn(subscriber);
if (subscriber == null) {
// null means "I will subscribe myself", returning...
return;
}
OptimizableOperator newSource = operator.nextOptimizableSource();
if (newSource == null) {
//Publish源er。
operator.source().subscribe(subscriber);
return;
}
operator = newSource;
}
}
catch (Throwable e) {
Operators.reportThrowInSubscribe(subscriber, e);
return;
}
}
}
InnerOperator
interface InnerOperator<I, O>
extends InnerConsumer<I>, InnerProducer<O> {
@Override
default Context currentContext() {
return actual().currentContext();
}
}
核心类继承结构
subscribe 阶段
subscribe 阶段会触发数据发送 。 当调用 subscribe(...) 时，整个执行过程便进入 subscribe 阶段。经过一系列的调用之后，subscribe 动作会代理给具体的 Flux 来实现 。
//subscribe(consumer,...) 最终调用
public final Disposable subscribe(
@Nullable Consumer<? super T> consumer,
@Nullable Consumer<? super Throwable> errorConsumer,
@Nullable Runnable completeConsumer,
@Nullable Context initialContext) {
return subscribeWith(
//lambda表达式构造的subscriber。
new LambdaSubscriber<>(consumer, errorConsumer,
completeConsumer,
null,
initialContext));
}
public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber) {
subscribe(subscriber);
return subscriber;
}
public final void subscribe(Subscriber<? super T> actual) {
CorePublisher publisher = Operators.onLastAssembly(this);
CoreSubscriber subscriber = Operators.toCoreSubscriber(actual);
try {
//如果Publisher是OptimizableOperator，则转换递归调用为loop调用。
if (publisher instanceof OptimizableOperator) {
OptimizableOperator operator = (OptimizableOperator) publisher;
while (true) {
subscriber = operator.subscribeOrReturn(subscriber);
if (subscriber == null) {
// null means "I will subscribe myself", returning...
return;
}
OptimizableOperator newSource = operator.nextOptimizableSource();
//返回最原始的publisher
if (newSource == null) {
publisher = operator.source();
break;
}
operator = newSource;
}
}
publisher.subscribe(subscriber);
}
catch (Throwable e) {
Operators.reportThrowInSubscribe(subscriber, e);
return;
}
}
//抽象订阅方法，InternalFluxOperator实现了此方法。
public abstract void subscribe(CoreSubscriber<? super T> actual);
source 变量对应的是当前 Flux 的上一个 ，把当前Subscriber和操作封装在一起，订阅upstream，类似 Stream 的wrapper。
中间过程Subscriber的subscribe都是订阅upstream，source 的订阅 则是要执行 Subscriber.onSubscribe(Subscription s) 方法。
onSubscribe 阶段
onSubscribe 阶段指的是 Subscriber#onSubscribe 方法被依次调用（所有Subscriber）的阶段。这个阶段会让各 Subscriber 知道 subscribe 方法已被触发，真正的处理流程马上就要开始。
request 阶段
onSubscribe 阶段是表示订阅动作的方式，让各 Subscriber 知悉，准备开始处理数据。当最终的 Subscriber 做好处理数据的准备之后，它便会调用 Subscription 的 request 方法请求数据。
如 MapFuseableSubscriber、FilterFuseableSubscriber，这些中间过程Subscriber它们都有两个角色。一个角色是 Subscriber，另一个角色是 Subscription。因为它们都位于调用链的中间，本身并不产生数据，也不需要对数据暂存，但是需要对数据做各式处理。因此，在 onSubscribe、request 阶段，以及后面要讲到的调用阶段都需要起到代理的作用。这就解释了 actual.onSubscribe(this) onSubscribe 自己的原因。
调用阶段
这一阶段将会通过调用 Subscriber 的 onNext 方法，从而进行真正的反应式的数据处理。
调用流程图
onAssembly
用于在组装期进行hook，以对调用过程进行监控。
protected static <T> Flux<T> onAssembly(Flux<T> source) {
Function<Publisher, Publisher> hook = Hooks.onEachOperatorHook;
if(hook != null) {
source = (Flux<T>) hook.apply(source);
}
if (Hooks.GLOBAL_TRACE) {
AssemblySnapshot stacktrace = new AssemblySnapshot(null, Traces.callSiteSupplierFactory.get());
source = (Flux<T>) Hooks.addAssemblyInfo(source, stacktrace);
}
return source;
}
源码解析
SourceProducer
SourceProducer是提供数据源的Publisher。
just (T data)
public static <T> Flux<T> just(T data) {
return onAssembly(new FluxJust<>(data));
}
final class FluxJust<T> extends Flux<T>
implements Fuseable.ScalarCallable<T>, Fuseable,
SourceProducer<T> {
//仅有一个元素
final T value;
@Override
public void subscribe(final CoreSubscriber<? super T> actual) {
//被订阅，由于是数据源，则调用Subscriber#onSubscribe
actual.onSubscribe(new WeakScalarSubscription<>(value, actual));
}
static final class WeakScalarSubscription<T> implements QueueSubscription<T>,
InnerProducer<T>{
boolean terminado;
final T value;
final CoreSubscriber<? super T> actual;
WeakScalarSubscription(@Nullable T value, CoreSubscriber<? super T> actual) {
this.value = value;
this.actual = actual;
}
@Override
public void request(long elements) {
//如果终止了，直接退出
if (terminado) {
return;
}
terminado = true;
if (value != null) {
//调用onNext。
actual.onNext(value);
}
//由于只有一个元素，直接完成。
actual.onComplete();
}
@Override
public void cancel() {
terminado = true;
}
@Override
public int requestFusion(int requestedMode) {
if ((requestedMode & Fuseable.SYNC) != 0) {
return Fuseable.SYNC;
}
return 0;
}
... ... ...
@Override
public CoreSubscriber<? super T> actual() {
return actual;
}
@Override
@Nullable
public Object scanUnsafe(Attr key) {
if (key == Attr.TERMINATED || key == Attr.CANCELLED) return terminado;
return InnerProducer.super.scanUnsafe(key);
}
}
}
just(T … data)
public static <T> Flux<T> just(T... data) {
return fromArray(data);
}
public static <T> Flux<T> fromArray(T[] array) {
if (array.length == 0) {
return empty();
}
if (array.length == 1) {
return just(array[0]);
}
//多个元素
return onAssembly(new FluxArray<>(array));
}
//FluxArray是个 SourceProducer
final class FluxArray<T> extends Flux<T> implements Fuseable, SourceProducer<T> {
final T[] array;
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
subscribe(actual, array);
}
public static <T> void subscribe(CoreSubscriber<? super T> s, T[] array) {
if (array.length == 0) {
//个数为0，直接完成
Operators.complete(s);
return;
}
//是否可以tryNext
if (s instanceof ConditionalSubscriber) {
s.onSubscribe(new ArrayConditionalSubscription<>((ConditionalSubscriber<? super T>) s, array));
}
else {
s.onSubscribe(new ArraySubscription<>(s, array));
}
}
static final class ArraySubscription<T>
implements InnerProducer<T>, SynchronousSubscription<T> {
final CoreSubscriber<? super T> actual;
final T[] array;
//当前已处理。
int index;
volatile boolean cancelled;
//希望发出的元素个数。
volatile long requested;
@SuppressWarnings("rawtypes")
static final AtomicLongFieldUpdater<ArraySubscription> REQUESTED =
AtomicLongFieldUpdater.newUpdater(ArraySubscription.class, "requested");
... ...
@Override
public void request(long n) {
if (Operators.validate(n)) {
//原子增加n。如果原值为0，则表示未处理过。
if (Operators.addCap(REQUESTED, this, n) == 0) {
if (n == Long.MAX_VALUE) {
fastPath();
}
else {
slowPath(n);
}
}
}
}
void slowPath(long n) {
final T[] a = array;
final int len = a.length;
final Subscriber<? super T> s = actual;
int i = index;
int e = 0;
for (; ; ) {
if (cancelled) {
return;
}
//发出n个元素。
while (i != len && e != n) {
T t = a[i];
if (t == null) {
s.onError(new NullPointerException("The " + i + "th array element was null"));
return;
}
s.onNext(t);
if (cancelled) {
return;
}
i++;
e++;
}
if (i == len) {
s.onComplete();
return;
}
//requested，可能被多线程修改。
n = requested;
if (n == e) {
//修改index的值。
index = i;
//requested 减 去已经发出的。
n = REQUESTED.addAndGet(this, -e);
if (n == 0) {
return;
}
e = 0;
}
}
}
void fastPath() {
final T[] a = array;
final int len = a.length;
final Subscriber<? super T> s = actual;
//循环发送元素。
for (int i = index; i != len; i++) {
//判断是否取消
if (cancelled) {
return;
}
T t = a[i];
if (t == null) {
s.onError(new NullPointerException("The " + i + "th array element was null"));
return;
}
//发送元素
s.onNext(t);
}
if (cancelled) {
return;
}
s.onComplete();
}
@Override
public void cancel() {
cancelled = true;
}
... ...
@Override
public CoreSubscriber<? super T> actual() {
return actual;
}
}
static final class ArrayConditionalSubscription<T>
implements InnerProducer<T>, SynchronousSubscription<T> {
final ConditionalSubscriber<? super T> actual;
final T[] array;
int index;
volatile boolean cancelled;
volatile long requested;
@SuppressWarnings("rawtypes")
static final AtomicLongFieldUpdater<ArrayConditionalSubscription> REQUESTED =
AtomicLongFieldUpdater.newUpdater(ArrayConditionalSubscription.class,
"requested");
... ...
@Override
public CoreSubscriber<? super T> actual() {
return actual;
}
@Override
public void request(long n) {
if (Operators.validate(n)) {
if (Operators.addCap(REQUESTED, this, n) == 0) {
if (n == Long.MAX_VALUE) {
fastPath();
}
else {
slowPath(n);
}
}
}
}
void slowPath(long n) {
final T[] a = array;
final int len = a.length;
final ConditionalSubscriber<? super T> s = actual;
int i = index;
int e = 0;
for (; ; ) {
if (cancelled) {
return;
}
while (i != len && e != n) {
T t = a[i];
if (t == null) {
s.onError(new NullPointerException("The " + i + "th array element was null"));
return;
}
boolean b = s.tryOnNext(t);
if (cancelled) {
return;
}
i++;
if (b) {
e++;
}
}
if (i == len) {
s.onComplete();
return;
}
n = requested;
if (n == e) {
index = i;
n = REQUESTED.addAndGet(this, -e);
if (n == 0) {
return;
}
e = 0;
}
}
}
void fastPath() {
final T[] a = array;
final int len = a.length;
final Subscriber<? super T> s = actual;
for (int i = index; i != len; i++) {
if (cancelled) {
return;
}
T t = a[i];
if (t == null) {
s.onError(new NullPointerException("The " + i + "th array element was null"));
return;
}
s.onNext(t);
}
if (cancelled) {
return;
}
s.onComplete();
}
... ...
}
}
empty()
只发出complete信号
final class FluxEmpty extends Flux<Object>
implements Fuseable.ScalarCallable<Object>, SourceProducer<Object> {
private static final Flux<Object> INSTANCE = new FluxEmpty();
... ...
@Override
public void subscribe(CoreSubscriber<? super Object> actual) {
Operators.complete(actual);
}
}
error()
public static <T> Flux<T> error(Supplier<? extends Throwable> errorSupplier) {
//类似FluxError
return onAssembly(new FluxErrorSupplied<>(errorSupplier));
}
public static <O> Flux<O> error(Throwable throwable, boolean whenRequested) {
if (whenRequested) {
return onAssembly(new FluxErrorOnRequest<>(throwable));
}
else {
return onAssembly(new FluxError<>(throwable));
}
}
final class FluxError<T> extends Flux<T> implements Fuseable.ScalarCallable, SourceProducer<T> {
public void subscribe(CoreSubscriber<? super T> actual) {
Operators.error(actual, error);
}
}
//Operators#error
public static void error(Subscriber<?> s, Throwable e) {
s.onSubscribe(EmptySubscription.INSTANCE);
s.onError(e);
}
final class FluxErrorOnRequest<T> extends Flux<T> implements SourceProducer<T> {
... ...
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
actual.onSubscribe(new ErrorSubscription(actual, error));
}
static final class ErrorSubscription implements InnerProducer {
@Override
public void request(long n) {
if (Operators.validate(n)) {
if (ONCE.compareAndSet(this, 0, 1)) {
actual.onError(error);
}
}
}
}
}
never()
final class FluxNever extends Flux<Object> implements SourceProducer<Object> {
@Override
public void subscribe(CoreSubscriber<? super Object> actual) {
actual.onSubscribe(Operators.emptySubscription());
}
}
final static class EmptySubscription implements QueueSubscription<Object>, Scannable {
@Override
public void request(long n) {
// deliberately no op
}
}
range(int start, int count)
final class FluxRange extends Flux<Integer>
implements Fuseable, SourceProducer<Integer> {
public void subscribe(CoreSubscriber<? super Integer> actual) {
long st = start;
long en = end;
if (st == en) {
//complete
Operators.complete(actual);
return;
} else
if (st + 1 == en) {
//仅发射一个元素。值为start。
actual.onSubscribe(Operators.scalarSubscription(actual, (int)st));
return;
}
if (actual instanceof ConditionalSubscriber) {
actual.onSubscribe(new RangeSubscriptionConditional((ConditionalSubscriber<? super Integer>) actual, st, en));
return;
}
//类似FluxArray。
actual.onSubscribe(new RangeSubscription(actual, st, en));
}
}
interval
public static Flux<Long> interval(Duration delay, Duration period, Scheduler timer) {
return onAssembly(new FluxInterval(delay.toMillis(), period.toMillis(), TimeUnit.MILLISECONDS, timer));
}
final class FluxInterval extends Flux<Long> implements SourceProducer<Long> {
final Scheduler timedScheduler;
final long initialDelay;
final long period;
final TimeUnit unit;
@Override
public void subscribe(CoreSubscriber<? super Long> actual) {
Worker w = timedScheduler.createWorker();
IntervalRunnable r = new IntervalRunnable(actual, w);
actual.onSubscribe(r);
try {
//周期性的调度
w.schedulePeriodically(r, initialDelay, period, unit);
}
catch (RejectedExecutionException ree) {
if (!r.cancelled) {
actual.onError(Operators.onRejectedExecution(ree, r, null, null,
actual.currentContext()));
}
}
}
static final class IntervalRunnable implements Runnable, Subscription,
InnerProducer<Long> {
final CoreSubscriber<? super Long> actual;
//为什么保持住worker ？由run来释放workder。
final Worker worker;
volatile long requested;
static final AtomicLongFieldUpdater<IntervalRunnable> REQUESTED =
AtomicLongFieldUpdater.newUpdater(IntervalRunnable.class, "requested");
long count;
volatile boolean cancelled;
@Override
public void run() {
if (!cancelled) {
if (requested != 0L) {
//发射一个元素
actual.onNext(count++);
if (requested != Long.MAX_VALUE) {
//减1
REQUESTED.decrementAndGet(this);
}
} else {
//requested == 0 取消
cancel();
actual.onError(Exceptions.failWithOverflow("Could not emit tick " + count + " due to lack of requests" +
" (interval doesn't support small downstream requests that replenish slower than the ticks)"));
}
}
}
@Override
public void request(long n) {
if (Operators.validate(n)) {
//请求数加n。
Operators.addCap(REQUESTED, this, n);
}
}
}
}
create，push，generator
public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter) {
return create(emitter, OverflowStrategy.BUFFER);
}
public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter, OverflowStrategy backpressure) {
return onAssembly(new FluxCreate<>(emitter, backpressure, FluxCreate.CreateMode.PUSH_PULL));
}
public static <T> Flux<T> push(Consumer<? super FluxSink<T>> emitter) {
return onAssembly(new FluxCreate<>(emitter, OverflowStrategy.BUFFER, FluxCreate.CreateMode.PUSH_ONLY));
}
public static <T> Flux<T> push(Consumer<? super FluxSink<T>> emitter, OverflowStrategy backpressure) {
return onAssembly(new FluxCreate<>(emitter, backpressure, FluxCreate.CreateMode.PUSH_ONLY));
}
溢出（背压）策略
enum OverflowStrategy {
/**忽略downstream requests*/
IGNORE,
/**抛出IllegalStateException*/
ERROR,
/**丢弃信号。*/
DROP,
/**获取upstream的最后一个信号*/
LATEST,
/**缓存*/
BUFFER
}
enum CreateMode {
PUSH_ONLY, PUSH_PULL
}
FluxSink
public interface FluxSink<T> {
void complete();
/**Return the current subscriber {@link Context}.*/
Context currentContext();
/**@see Subscriber#onError(Throwable)*/
void error(Throwable e);
/**Try emitting, might throw an unchecked exception.*/
FluxSink<T> next(T t);
/**
* The current outstanding request amount.
* @return the current outstanding request amount
*/
long requestedFromDownstream();
/**if the downstream cancelled the sequence*/
boolean isCancelled();
FluxSink<T> onRequest(LongConsumer consumer);
FluxSink<T> onCancel(Disposable d);
FluxSink<T> onDispose(Disposable d);
}
final class FluxCreate<T> extends Flux<T> implements SourceProducer<T> {
final Consumer<? super FluxSink<T>> source;
final OverflowStrategy backpressure;
final CreateMode createMode;
static <T> BaseSink<T> createSink(CoreSubscriber<? super T> t,
OverflowStrategy backpressure) {
switch (backpressure) {
case IGNORE: {
return new IgnoreSink<>(t);
}
case ERROR: {
return new ErrorAsyncSink<>(t);
}
case DROP: {
return new DropAsyncSink<>(t);
}
case LATEST: {
return new LatestAsyncSink<>(t);
}
default: {
return new BufferAsyncSink<>(t, Queues.SMALL_BUFFER_SIZE);
}
}
}
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
BaseSink<T> sink = createSink(actual, backpressure);
actual.onSubscribe(sink);
try {
source.accept(
createMode == CreateMode.PUSH_PULL ? new SerializedSink<>(sink) :
sink);
}
catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
sink.error(Operators.onOperatorError(ex, actual.currentContext()));
}
}
}
Schedulers
Schedulers 它提供了多个创建Scheduler的方法，它的本质就是对ExecutorService和ScheduledExecutorService进行封装，将其做为Supplier来创建Schedule。
- Schedulers.immediate() - 使用当前线程
- Schedulers.elastic() - 使用线程池
- Schedulers.newElastic(“test1”) - 使用(新)线程池(可以指定名称，更方便调试)
- Schedulers.single() - 单个线程
- Schedulers.newSingle(“test2”) - (新)单个线程(可以指定名称，更方便调试)
- Schedulers.parallel() - 使用并行处理的线程池（取决于CPU核数)
- Schedulers.newParallel(“test3”) - 使用并行处理的线程池（取决于CPU核数，可以指定名称，方便调试)
- Schedulers.fromExecutorService() - 自定义调度器，使用Executor（这个最灵活)
- newBoundedElastic，有界线程池。
主要接口
public interface Scheduler extends Disposable {
Disposable schedule(Runnable task);
/** 延迟执行
throw a {@link RejectedExecutionException} if the Scheduler is not capable of scheduling periodically.
*/
default Disposable schedule(Runnable task, long delay, TimeUnit unit) {
throw Exceptions.failWithRejectedNotTimeCapable();
}
/** 周期性的执行，
* @param initialDelay 初始延迟 ，毫秒
*/
default Disposable schedulePeriodically(Runnable task, long initialDelay, long period, TimeUnit unit) {
throw Exceptions.failWithRejectedNotTimeCapable();
}
/**返回当前时间*/
default long now(TimeUnit unit) {
return unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
}
/**
* Creates a worker of this Scheduler. 不再使用，需调用dispose()释放
* @return the Worker instance.
*/
Worker createWorker();
default void dispose() {
}
/**指示已准备好。线程安全，但是最好不要并发执行。
*/
default void start() {
}
interface Worker extends Disposable {
Disposable schedule(Runnable task);
default Disposable schedule(Runnable task, long delay, TimeUnit unit) {
throw Exceptions.failWithRejectedNotTimeCapable();
}
default Disposable schedulePeriodically(Runnable task, long initialDelay, long period, TimeUnit unit) {
throw Exceptions.failWithRejectedNotTimeCapable();
}
}
//构造Scheduler的工厂，依赖ThreadFactory
public interface Factory {
default Scheduler newElastic(int ttlSeconds, ThreadFactory threadFactory) {
return new ElasticScheduler(threadFactory, ttlSeconds);
}
default Scheduler newBoundedElastic(int threadCap, int queuedTaskCap, ThreadFactory threadFactory, int ttlSeconds) {
return new BoundedElasticScheduler(threadCap, queuedTaskCap, threadFactory, ttlSeconds);
}
default Scheduler newParallel(int parallelism, ThreadFactory threadFactory) {
return new ParallelScheduler(parallelism, threadFactory);
}
default Scheduler newSingle(ThreadFactory threadFactory) {
return new SingleScheduler(threadFactory);
}
}
}
通过整体阅读Schedulers代码，ElasticScheduler，BoundedElasticScheduler，ParallelScheduler，SingleScheduler 等几个Scheduler都是对***ScheduledExecutorService的封装，worker是使用Scheduler内部的ScheduledExecutorService***，最后都调用Schedulers的static 方法。
ReactorThreadFactory
Reactor的通用线程工厂
class ReactorThreadFactory implements ThreadFactory,
Supplier<String>,
Thread.UncaughtExceptionHandler {
final private String name;
final private AtomicLong counterReference;
final private boolean daemon;
final private boolean rejectBlocking;
@Nullable
final private BiConsumer<Thread, Throwable> uncaughtExceptionHandler;
@Override
public final Thread newThread(@NotNull Runnable runnable) {
//线程名称是 分组名 + 序号
String newThreadName = name + "-" + counterReference.incrementAndGet();
Thread t = rejectBlocking
? new NonBlockingThread(runnable, newThreadName)
: new Thread(runnable, newThreadName);
if (daemon) {
//守护线程
t.setDaemon(true);
}
if (uncaughtExceptionHandler != null) {
t.setUncaughtExceptionHandler(this);
}
return t;
}
@Override
public void uncaughtException(Thread t, Throwable e) {
if (uncaughtExceptionHandler == null) {
return;
}
uncaughtExceptionHandler.accept(t,e);
}
}
SchedulerTask
可调度任务
final class SchedulerTask implements Runnable, Disposable, Callable<Void> {
final Runnable task;
static final Future<Void> FINISHED = new FutureTask<>(() -> null);
static final Future<Void> CANCELLED = new FutureTask<>(() -> null);
//哨兵，
static final Disposable TAKEN = Disposables.disposed();
volatile Future<?> future;
static final AtomicReferenceFieldUpdater<SchedulerTask, Future> FUTURE =
AtomicReferenceFieldUpdater.newUpdater(SchedulerTask.class, Future.class, "future");
volatile Disposable parent;
static final AtomicReferenceFieldUpdater<SchedulerTask, Disposable> PARENT =
AtomicReferenceFieldUpdater.newUpdater(SchedulerTask.class, Disposable.class, "parent");
Thread thread;
SchedulerTask(Runnable task, @Nullable Disposable parent) {
this.task = task;
PARENT.lazySet(this, parent);
}
@Override
@Nullable
public Void call() {
thread = Thread.currentThread();
Disposable d = null;
try {
//确认此线程能够竞争到此Scheduler。
for (;;) {
d = parent;
if (d == TAKEN || d == null) {
break;
}
if (PARENT.compareAndSet(this, d, TAKEN)) {
break;
}
}
try {
task.run();
}
catch (Throwable ex) {
Schedulers.handleError(ex);
}
}
finally {
//执行完之后，线程释放。
thread = null;
Future f;
for (;;) {
//释放future。
f = future;
if (f == CANCELLED || FUTURE.compareAndSet(this, f, FINISHED)) {
break;
}
}
if (d != null) {
d.dispose();
}
}
return null;
}
@Override
public void run() {
call();
}
void setFuture(Future<?> f) {
for (;;) {
Future o = future;
if (o == FINISHED) {
return;
}
if (o == CANCELLED) {
f.cancel(thread != Thread.currentThread());
return;
}
if (FUTURE.compareAndSet(this, o, f)) {
return;
}
}
}
@Override
public boolean isDisposed() {
Future<?> a = future;
return FINISHED == a || CANCELLED == a;
}
@Override
public void dispose() {
for (;;) {
Future f = future;
if (f == FINISHED || f == CANCELLED) {
break;
}
if (FUTURE.compareAndSet(this, f, CANCELLED)) {
if (f != null) {
f.cancel(thread != Thread.currentThread());
}
break;
}
}
Disposable d;
for (;;) {
d = parent;
if (d == TAKEN || d == null) {
break;
}
if (PARENT.compareAndSet(this, d, TAKEN)) {
d.dispose();
break;
}
}
}
}
WorkerTask
final class WorkerTask implements Runnable, Disposable, Callable<Void> {
final Runnable task;
/** marker that the Worker was disposed and the parent got notified */
static final Composite DISPOSED = new EmptyCompositeDisposable();
/** marker that the Worker has completed, for the PARENT field */
static final Composite DONE = new EmptyCompositeDisposable();
/** marker that the Worker has completed, for the FUTURE field */
static final Future<Void> FINISHED = new FutureTask<>(() -> null);
/**
* marker that the Worker was cancelled from the same thread (ie. within call()/run()),
* which means setFuture might race: we avoid interrupting the Future in this case.
*/
static final Future<Void> SYNC_CANCELLED = new FutureTask<>(() -> null);
/**
* marker that the Worker was cancelled from another thread, making it safe to
* interrupt the Future task.
*/
//see https://github.com/reactor/reactor-core/issues/1107
static final Future<Void> ASYNC_CANCELLED = new FutureTask<>(() -> null);
volatile Future<?> future;
static final AtomicReferenceFieldUpdater<WorkerTask, Future> FUTURE =
AtomicReferenceFieldUpdater.newUpdater(WorkerTask.class, Future.class, "future");
volatile Composite parent;
static final AtomicReferenceFieldUpdater<WorkerTask, Composite> PARENT =
AtomicReferenceFieldUpdater.newUpdater(WorkerTask.class, Composite.class, "parent");
volatile Thread thread;
static final AtomicReferenceFieldUpdater<WorkerTask, Thread> THREAD =
AtomicReferenceFieldUpdater.newUpdater(WorkerTask.class, Thread.class, "thread");
@Override
@Nullable
public Void call() {
THREAD.lazySet(this, Thread.currentThread());
try {
try {
task.run();
}
catch (Throwable ex) {
Schedulers.handleError(ex);
}
}
finally {
THREAD.lazySet(this, null);
Composite o = parent;
//note: the o != null check must happen after the compareAndSet for it to always mark task as DONE
if (o != DISPOSED && PARENT.compareAndSet(this, o, DONE) && o != null) {
o.remove(this);
}
Future f;
for (;;) {
f = future;
if (f == SYNC_CANCELLED || f == ASYNC_CANCELLED || FUTURE.compareAndSet(this, f, FINISHED)) {
break;
}
}
}
return null;
}
@Override
public void run() {
call();
}
... ...
}
主要调度方法
onSchedule
如果注册了hook，则应用hook。即可以通过hook对Runnable进行包装。
public static Runnable onSchedule(Runnable runnable) {
Function<Runnable, Runnable> hook = onScheduleHook;
if (hook != null) {
return hook.apply(runnable);
}
else {
return runnable;
}
}
directSchedule
static Disposable directSchedule(ScheduledExecutorService exec,
Runnable task,
@Nullable Disposable parent,
long delay,
TimeUnit unit) {
task = onSchedule(task);
SchedulerTask sr = new SchedulerTask(task, parent);
Future<?> f;
if (delay <= 0L) {
f = exec.submit((Callable<?>) sr);
}
else {
f = exec.schedule((Callable<?>) sr, delay, unit);
}
//保存future。
sr.setFuture(f);
return sr;
}
directSchedulePeriodically
static Disposable directSchedulePeriodically(ScheduledExecutorService exec,
Runnable task,
long initialDelay,
long period,
TimeUnit unit) {
task = onSchedule(task);
if (period <= 0L) {
//
InstantPeriodicWorkerTask isr =
new InstantPeriodicWorkerTask(task, exec);
Future<?> f;
if (initialDelay <= 0L) {
f = exec.submit(isr);
}
else {
f = exec.schedule(isr, initialDelay, unit);
}
isr.setFirst(f);
return isr;
}
else {
//SchedulerTask
PeriodicSchedulerTask sr = new PeriodicSchedulerTask(task);
Future<?> f = exec.scheduleAtFixedRate(sr, initialDelay, period, unit);
sr.setFuture(f);
return sr;
}
}
workerSchedule
static Disposable workerSchedule(ScheduledExecutorService exec,
Disposable.Composite tasks,
Runnable task,
long delay,
TimeUnit unit) {
task = onSchedule(task);
//WorkerTask
WorkerTask sr = new WorkerTask(task, tasks);
if (!tasks.add(sr)) {
throw Exceptions.failWithRejected();
}
try {
Future<?> f;
if (delay <= 0L) {
f = exec.submit((Callable<?>) sr);
}
else {
f = exec.schedule((Callable<?>) sr, delay, unit);
}
sr.setFuture(f);
}
catch (RejectedExecutionException ex) {
sr.dispose();
//RejectedExecutionException are propagated up
throw ex;
}
return sr;
}
workerSchedulePeriodically
static Disposable workerSchedulePeriodically(ScheduledExecutorService exec,
Disposable.Composite tasks,
Runnable task,
long initialDelay,
long period,
TimeUnit unit) {
task = onSchedule(task);
if (period <= 0L) {
InstantPeriodicWorkerTask isr =
new InstantPeriodicWorkerTask(task, exec, tasks);
if (!tasks.add(isr)) {
throw Exceptions.failWithRejected();
}
try {
Future<?> f;
if (initialDelay <= 0L) {
f = exec.submit(isr);
}
else {
f = exec.schedule(isr, initialDelay, unit);
}
isr.setFirst(f);
}
catch (RejectedExecutionException ex) {
isr.dispose();
//RejectedExecutionException are propagated up
throw ex;
}
catch (IllegalArgumentException | NullPointerException ex) {
isr.dispose();
//IllegalArgumentException are wrapped into RejectedExecutionException and propagated up
throw new RejectedExecutionException(ex);
}
return isr;
}
PeriodicWorkerTask sr = new PeriodicWorkerTask(task, tasks);
if (!tasks.add(sr)) {
throw Exceptions.failWithRejected();
}
try {
Future<?> f = exec.scheduleAtFixedRate(sr, initialDelay, period, unit);
sr.setFuture(f);
}
catch (RejectedExecutionException ex) {
sr.dispose();
//RejectedExecutionException are propagated up
throw ex;
}
catch (IllegalArgumentException | NullPointerException ex) {
sr.dispose();
//IllegalArgumentException are wrapped into RejectedExecutionException and propagated up
throw new RejectedExecutionException(ex);
}
return sr;
}
创建方法
immediate()
public static Scheduler immediate() {
return ImmediateScheduler.instance();
}
final class ImmediateScheduler implements Scheduler, Scannable {
private static final ImmediateScheduler INSTANCE = new ImmediateScheduler();
//AlwaysDisposable。不需要dispose。
static final Disposable FINISHED = Disposables.disposed();
@Override
public Disposable schedule(Runnable task) {
//直接在当前线程执行。
task.run();
return FINISHED;
}
@Override
public void dispose() {
//NO-OP
}
@Override
public Worker createWorker() {
return new ImmediateSchedulerWorker();
}
static final class ImmediateSchedulerWorker implements Scheduler.Worker, Scannable {
volatile boolean shutdown;
@Override
public Disposable schedule(Runnable task) {
if (shutdown) {
throw Exceptions.failWithRejected();
}
//当前线程执行
task.run();
return FINISHED;
}
@Override
public void dispose() {
shutdown = true;
}
@Override
public boolean isDisposed() {
return shutdown;
}
}
}
single()
public static Scheduler single() {
//把通过newSingle方法生成的Scheduler缓存住。
return cache(CACHED_SINGLE, SINGLE, SINGLE_SUPPLIER);
}
//通过其他Scheduler 生成的worker构造一个Scheduler。
public static Scheduler single(Scheduler original) {
return new SingleWorkerScheduler(original);
}
//单个worker构造的Scheduler。
final class SingleWorkerScheduler implements Scheduler, Executor, Scannable {
//真实worker。
final Worker main;
SingleWorkerScheduler(Scheduler actual) {
//通过某个Scheduler生成一个worker。
this.main = actual.createWorker();
}
@Override
public void dispose() {
main.dispose();
}
@Override
public Disposable schedule(Runnable task) {
return main.schedule(task);
}
@Override
public Disposable schedule(Runnable task, long delay, TimeUnit unit) {
return main.schedule(task, delay, unit);
}
@Override
public Disposable schedulePeriodically(Runnable task, long initialDelay,
long period, TimeUnit unit) {
return main.schedulePeriodically(task, initialDelay, period, unit);
}
@Override
public void execute(Runnable command) {
main.schedule(command);
}
@Override
public Worker createWorker() {
return new ExecutorScheduler.ExecutorSchedulerWorker(this);
}
@Override
public boolean isDisposed() {
return main.isDisposed();
}
}
newSingle()
public static Scheduler newSingle(String name) {
return newSingle(name, false);
}
//daemon 是否守护线程。
public static Scheduler newSingle(String name, boolean daemon) {
return newSingle(new ReactorThreadFactory(name, SingleScheduler.COUNTER, daemon,
true, Schedulers::defaultUncaughtException));
}
//通过ThreadFactory构造Scheduler。
public static Scheduler newSingle(ThreadFactory threadFactory) {
//调用的也是Schedulers.newSingle方法。
return factory.newSingle(threadFactory);
}
final class SingleScheduler implements Scheduler, Supplier<ScheduledExecutorService>,
Scannable {
static final AtomicLong COUNTER = new AtomicLong();
final ThreadFactory factory;
volatile ScheduledExecutorService executor;
static final AtomicReferenceFieldUpdater<SingleScheduler, ScheduledExecutorService> EXECUTORS =
AtomicReferenceFieldUpdater.newUpdater(SingleScheduler.class,
ScheduledExecutorService.class,
"executor");
static final ScheduledExecutorService TERMINATED;
static {
TERMINATED = Executors.newSingleThreadScheduledExecutor();
TERMINATED.shutdownNow();
}
SingleScheduler(ThreadFactory factory) {
this.factory = factory;
init();
}
/**
* Instantiates the default {@link ScheduledExecutorService} for the SingleScheduler
* ({@code Executors.newScheduledThreadPoolExecutor} with core and max pool size of 1).
*/
@Override
public ScheduledExecutorService get() {
ScheduledThreadPoolExecutor e = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(1, this.factory);
e.setRemoveOnCancelPolicy(true);
e.setMaximumPoolSize(1);
return e;
}
private void init() {
EXECUTORS.lazySet(this, Schedulers.decorateExecutorService(this, this.get()));
}
@Override
public boolean isDisposed() {
return executor == TERMINATED;
}
@Override
public void start() {
//TODO SingleTimedScheduler didn't implement start, check if any particular reason?
ScheduledExecutorService b = null;
for (; ; ) {
//如果当前executor未shutdown，则shutdown。
ScheduledExecutorService a = executor;
if (a != TERMINATED) {
if (b != null) {
b.shutdownNow();
}
return;
}
if (b == null) {
b = Schedulers.decorateExecutorService(this, this.get());
}
//executor 替换成新创建的。
if (EXECUTORS.compareAndSet(this, a, b)) {
return;
}
}
}
@Override
public void dispose() {
ScheduledExecutorService a = executor;
if (a != TERMINATED) {
//原子替换
a = EXECUTORS.getAndSet(this, TERMINATED);
//未关闭则关闭
if (a != TERMINATED) {
a.shutdownNow();
}
}
}
@Override
public Disposable schedule(Runnable task) {
return Schedulers.directSchedule(executor, task, null, 0L, TimeUnit.MILLISECONDS);
}
@Override
public Disposable schedule(Runnable task, long delay, TimeUnit unit) {
return Schedulers.directSchedule(executor, task, null, delay, unit);
}
@Override
public Disposable schedulePeriodically(Runnable task,
long initialDelay,
long period,
TimeUnit unit) {
return Schedulers.directSchedulePeriodically(executor,
task,
initialDelay,
period,
unit);
}
@Override
public Worker createWorker() {
return new ExecutorServiceWorker(executor);
}
}
elastic()
使用缓存的Scheduler，通过newElastic(ELASTIC, ElasticScheduler.DEFAULT_TTL_SECONDS, true)创建。
public static Scheduler elastic() {
return cache(CACHED_ELASTIC, ELASTIC, ELASTIC_SUPPLIER);
}
newElastic()
public static Scheduler newElastic(String name, int ttlSeconds, boolean daemon) {
return newElastic(ttlSeconds,
new ReactorThreadFactory(name, ElasticScheduler.COUNTER, daemon, false,
Schedulers::defaultUncaughtException));
}
/*通过线程工厂
*/
public static Scheduler newElastic(int ttlSeconds, ThreadFactory threadFactory) {
//ElasticScheduler
return factory.newElastic(ttlSeconds, threadFactory);
}
//Factory接口方法
default Scheduler newElastic(int ttlSeconds, ThreadFactory threadFactory) {
return new ElasticScheduler(threadFactory, ttlSeconds);
}
final class ElasticScheduler implements Scheduler, Scannable {
//计数器
static final AtomicLong COUNTER = new AtomicLong();
//清理线程工厂。
static final ThreadFactory EVICTOR_FACTORY = r -> {
Thread t = new Thread(r, "elastic-evictor-" + COUNTER.incrementAndGet());
t.setDaemon(true);
return t;
};
static final CachedService SHUTDOWN = new CachedService(null);
static final int DEFAULT_TTL_SECONDS = 60;
final ThreadFactory factory;
final int ttlSeconds;
final Deque<ScheduledExecutorServiceExpiry> cache;
final Queue<CachedService> all;
//清理线程池，coresize：1，定时清理。通过eviction方法清理，
final ScheduledExecutorService evictor;
volatile boolean shutdown;
void eviction() {
long now = System.currentTimeMillis();
//过期即清理。
List<ScheduledExecutorServiceExpiry> list = new ArrayList<>(cache);
for (ScheduledExecutorServiceExpiry e : list) {
if (e.expireMillis < now) {
if (cache.remove(e)) {
e.cached.exec.shutdownNow();
all.remove(e.cached);
}
}
}
}
//ElasticWorker的调度是通过 ScheduledExecutorService 调度的。
static final class ElasticWorker extends AtomicBoolean implements Worker, Scannable {
@Override
public Disposable schedule(Runnable task) {
return Schedulers.workerSchedule(cached.exec,
tasks,
task,
0L,
TimeUnit.MILLISECONDS);
}
}
}
parallel()
public static Scheduler parallel() {
return cache(CACHED_PARALLEL, PARALLEL, PARALLEL_SUPPLIER);
}
newParallel()
// parallelism:并发数量
public static Scheduler newParallel(int parallelism, ThreadFactory threadFactory) {
return factory.newParallel(parallelism, threadFactory);
}
final class ParallelScheduler implements Scheduler, Supplier<ScheduledExecutorService>,
Scannable {
static final AtomicLong COUNTER = new AtomicLong();
final int n;
final ThreadFactory factory;
//多个ScheduledExecutorService
volatile ScheduledExecutorService[] executors;
static final AtomicReferenceFieldUpdater<ParallelScheduler, ScheduledExecutorService[]> EXECUTORS =
AtomicReferenceFieldUpdater.newUpdater(ParallelScheduler.class, ScheduledExecutorService[].class, "executors");
static final ScheduledExecutorService[] SHUTDOWN = new ScheduledExecutorService[0];
static final ScheduledExecutorService TERMINATED;
static {
TERMINATED = Executors.newSingleThreadScheduledExecutor();
TERMINATED.shutdownNow();
}
int roundRobin;
ParallelScheduler(int n, ThreadFactory factory) {
... ...
init(n);
}
void init(int n) {
ScheduledExecutorService[] a = new ScheduledExecutorService[n];
for (int i = 0; i < n; i++) {
//构造ScheduledExecutorService
a[i] = Schedulers.decorateExecutorService(this, this.get());
}
EXECUTORS.lazySet(this, a);
}
@Override
public void start() {
ScheduledExecutorService[] b = null;
for (;;) {
//把已有的shutdown
ScheduledExecutorService[] a = executors;
if (a != SHUTDOWN) {
if (b != null) {
for (ScheduledExecutorService exec : b) {
exec.shutdownNow();
}
}
return;
}
//构造新的。
if (b == null) {
b = new ScheduledExecutorService[n];
for (int i = 0; i < n; i++) {
b[i] = Schedulers.decorateExecutorService(this, this.get());
}
}
if (EXECUTORS.compareAndSet(this, a, b)) {
return;
}
}
}
//同SingleScheduler
public Worker createWorker() {
return new ExecutorServiceWorker(pick());
}
from
//trampoline:通过队列方式按顺序处理task。
public static Scheduler fromExecutor(Executor executor, boolean trampoline) {
if(!trampoline && executor instanceof ExecutorService){
return fromExecutorService ((ExecutorService) executor);
}
return new ExecutorScheduler(executor, trampoline);
}
public static Scheduler fromExecutorService(ExecutorService executorService) {
String executorServiceHashcode = Integer.toHexString(System.identityHashCode(executorService));
return fromExecutorService(executorService, "anonymousExecutor@" + executorServiceHashcode);
}
public static Scheduler fromExecutorService(ExecutorService executorService, String executorName) {
//代理对象
return new DelegateServiceScheduler(executorName, executorService);
}
newBoundedElastic
public static Scheduler newBoundedElastic(int threadCap, int queuedTaskCap, String name) {
return newBoundedElastic(threadCap, queuedTaskCap, name, BoundedElasticScheduler.DEFAULT_TTL_SECONDS, false);
}
public static Scheduler newBoundedElastic(int threadCap, int queuedTaskCap, String name, int ttlSeconds) {
return newBoundedElastic(threadCap, queuedTaskCap, name, ttlSeconds, false);
}
public static Scheduler newBoundedElastic(int threadCap, int queuedTaskCap, String name, int ttlSeconds, boolean daemon) {
return newBoundedElastic(threadCap, queuedTaskCap,
new ReactorThreadFactory(name, ElasticScheduler.COUNTER, daemon, false,
Schedulers::defaultUncaughtException),
ttlSeconds);
}
public static Scheduler newBoundedElastic(int threadCap, int queuedTaskCap, ThreadFactory threadFactory, int ttlSeconds) {
return factory.newBoundedElastic(threadCap, queuedTaskCap, threadFactory, ttlSeconds);
}
//创建0-N个单独线程的Scheduler。
final class BoundedElasticScheduler implements Scheduler, Scannable {
final int maxThreads;
final int maxTaskQueuedPerThread;
}
publishOn 和 subscribeOn
publishOn和subscribeOn主要用来进行切换Scheduler的执行上下文。
在链式调用中，publishOn可以切换Scheduler，但是subscribeOn并不会起作用。
这是因为真正的publish-subscribe关系只有在subscriber开始subscribe的时候才建立。
subscribeOn是用来切换Subscriber的执行上下文，不管subscribeOn出现在调用链的哪个部分，最终都会应用到整个调用链上。
publishOn
/*Run onNext, onComplete and onError on a supplied Scheduler
delayError：是否延迟抛出异常。
prefetch：队列大小
*/
final Flux<T> publishOn(Scheduler scheduler, boolean delayError, int prefetch, int lowTide) {
if (this instanceof Callable) {
//前一步操作仅返回0/1 个值的，
if (this instanceof Fuseable.ScalarCallable) {
@SuppressWarnings("unchecked")
Fuseable.ScalarCallable<T> s = (Fuseable.ScalarCallable<T>) this;
try {
//直接调用 call()方法
return onAssembly(new FluxSubscribeOnValue<>(s.call(), scheduler));
}
catch (Exception e) {
//leave FluxSubscribeOnCallable defer exception call
}
}
@SuppressWarnings("unchecked")
Callable<T> c = (Callable<T>)this;
return onAssembly(new FluxSubscribeOnCallable<>(c, scheduler));
}
return onAssembly(new FluxPublishOn<>(this, scheduler, delayError, prefetch, lowTide, Queues.get(prefetch)));
}
final class FluxSubscribeOnValue<T> extends Flux<T> implements Fuseable, Scannable {
final T value;
final Scheduler scheduler;
FluxSubscribeOnValue(@Nullable T value, Scheduler scheduler) {
this.value = value;
this.scheduler = Objects.requireNonNull(scheduler, "scheduler");
}
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
T v = value;
if (v == null) {
//
ScheduledEmpty parent = new ScheduledEmpty(actual);
actual.onSubscribe(parent);
try {
//Future。
parent.setFuture(scheduler.schedule(parent));
}
catch (RejectedExecutionException ree) {
if (parent.future != OperatorDisposables.DISPOSED) {
actual.onError(Operators.onRejectedExecution(ree,
actual.currentContext()));
}
}
}
else {
actual.onSubscribe(new ScheduledScalar<>(actual, v, scheduler));
}
}
static final class ScheduledScalar<T>
implements QueueSubscription<T>, InnerProducer<T>, Runnable {
final CoreSubscriber<? super T> actual;
final T value;
final Scheduler scheduler;
volatile int once;
... ... ...
static final Disposable FINISHED = Disposables.disposed();
int fusionState;
static final int NO_VALUE = 1;
static final int HAS_VALUE = 2;
static final int COMPLETE = 3;
ScheduledScalar(CoreSubscriber<? super T> actual, T value, Scheduler scheduler) {
this.actual = actual;
this.value = value;
this.scheduler = scheduler;
}
@Override
public void request(long n) {
if (Operators.validate(n)) {
if (ONCE.compareAndSet(this, 0, 1)) {
try {
//调度任务，返回Disposable
Disposable f = scheduler.schedule(this);
if (!FUTURE.compareAndSet(this,
null,
f) && future != FINISHED && future != OperatorDisposables.DISPOSED) {
f.dispose();
}
}
catch (RejectedExecutionException ree) {
... ..
}
}
}
}
/* 定时发送 */
@Override
public void run() {
try {
if (fusionState == NO_VALUE) {
fusionState = HAS_VALUE;
}
actual.onNext(value);
actual.onComplete();
}
finally {
FUTURE.lazySet(this, FINISHED);
}
}
... ... ...
}
}
subscribeOn