操作符（Operator）
合并多个Flux
combineLatest
concat
concatMap
merge
repeat
cache
行为（behavior）
聚合操作
collect
reduce
distinct
group by
scan
其他
错误处理
Backpressure（背压）
event
retry
using
dematerialize，materialize
发布和订阅（hot流和cold流）
subscribe
//subscribe(consumer,...) 最终调用
public final Disposable subscribe(
@Nullable Consumer<? super T> consumer,
@Nullable Consumer<? super Throwable> errorConsumer,
@Nullable Runnable completeConsumer,
@Nullable Context initialContext) {
return subscribeWith(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();
if (newSource == null) {
publisher = operator.source();
break;
}
operator = newSource;
}
}
publisher.subscribe(subscriber);
}
catch (Throwable e) {
Operators.reportThrowInSubscribe(subscriber, e);
return;
}
}
public final Flux<T> subscriberContext(Context mergeContext) {
return subscriberContext(c -> c.putAll(mergeContext));
}
public final Flux<T> subscriberContext(Function<Context, Context> doOnContext) {
return new FluxContextStart<>(this, doOnContext);
}
将已有Cold流转变为Hot流
使用Processor构造Hot流
replay
基于时间的操作
timeout
超过设置的时间没有emit 元素，则抛出异常。
delay
defer
元素相关Operator
filter
public final Flux<T> filter(Predicate<? super T> p) {
if (this instanceof Fuseable) {
return onAssembly(new FluxFilterFuseable<>(this, p));
}
return onAssembly(new FluxFilter<>(this, p));
}
final class FluxFilter<T> extends InternalFluxOperator<T, T> {
final Predicate<? super T> predicate;
static final class FilterSubscriber<T>
implements InnerOperator<T, T>,
Fuseable.ConditionalSubscriber<T> {
final CoreSubscriber<? super T> actual;
final Context ctx;
final Predicate<? super T> predicate;
Subscription s;
boolean done;
... ... ...
@Override
public void onSubscribe(Subscription s) {
if (Operators.validate(this.s, s)) {
this.s = s;
actual.onSubscribe(this);
}
}
@Override
public void onNext(T t) {
if (done) {
Operators.onNextDropped(t, this.ctx);
return;
}
boolean b;
try {
b = predicate.test(t);
}
catch (Throwable e) {
Throwable e_ = Operators.onNextError(t, e, this.ctx, s);
if (e_ != null) {
onError(e_);
}
else {
s.request(1);
}
Operators.onDiscard(t, this.ctx);
return;
}
if (b) {
//发射出 元素。
actual.onNext(t);
}
else {
//触发 onDiscard
Operators.onDiscard(t, this.ctx);
//请求下一个。
s.request(1);
}
}
}
}
filterWhen与filter过程类似，不过将发射这一步修改为放入buffer中，直到流结束将整个buffer返回。
//把upstream的值通过一个Publisher把 value 映射为一个true或false，仅Publisher第一个发射的值被考虑，如果Publisher发射的值为empty，则 输入值不会映射成任何值。
class FluxFilterWhen<T> extends InternalFluxOperator<T, T> {
final Function<? super T, ? extends Publisher<Boolean>> asyncPredicate;
final int bufferSize;
@Override
public CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super T> actual) {
return new FluxFilterWhenSubscriber<>(actual, asyncPredicate, bufferSize);
}
static final class FluxFilterWhenSubscriber<T> implements InnerOperator<T, T> {
final Function<? super T, ? extends Publisher<Boolean>> asyncPredicate;
//缓存大小
final int bufferSize;
//缓存数组，数组大小会被初始化：大于bufferSize的2个指数值的最小值。通过hash值计算下标
final AtomicReferenceArray<T> toFilter;
final CoreSubscriber<? super T> actual;
final Context ctx;
int consumed;
//消费者下标
long consumerIndex;
long emitted;
Boolean innerResult;
//生产者下标
long producerIndex;
Subscription upstream;
volatile boolean cancelled;
volatile FilterWhenInner current;
volatile boolean done;
volatile Throwable error;
volatile long requested;
volatile int state;
volatile int wip;
//条件常量。代表取消。
static final FilterWhenInner INNER_CANCELLED = new FilterWhenInner(null, false);
@Override
public void request(long n) {
if (Operators.validate(n)) {
Operators.addCap(REQUESTED, this, n);
drain();
}
}
@Override
public void onNext(T t) {
long pi = producerIndex;
int m = toFilter.length() - 1;
//计算下标
int offset = (int)pi & m;
//把元素加入缓存。
toFilter.lazySet(offset, t);
producerIndex = pi + 1;
drain();
}
@Override
public void onSubscribe(Subscription s) {
if (Operators.validate(upstream, s)) {
upstream = s;
actual.onSubscribe(this);
s.request(bufferSize);
}
}
void drain() {
if (WIP.getAndIncrement(this) != 0) {
return;
}
int missed = 1;
int limit = Operators.unboundedOrLimit(bufferSize);
long e = emitted;
long ci = consumerIndex;
int f = consumed;
int m = toFilter.length() - 1;
Subscriber<? super T> a = actual;
for (;;) {
long r = requested;
//发射的数量与requested数量不一样，则一直发送。
while (e != r) {
if (cancelled) {
clear();
return;
}
boolean d = done;
//下标
int offset = (int)ci & m;
T t = toFilter.get(offset);
boolean empty = t == null;
//如果取消并且未获取到数据，则中断。
if (d && empty) {
Throwable ex = Exceptions.terminate(ERROR, this);
if (ex == null) {
a.onComplete();
} else {
a.onError(ex);
}
return;
}
//未取消，但是获取到null，退出。
if (empty) {
break;
}
int s = state;
if (s == STATE_FRESH) {
Publisher<Boolean> p;
try {
//获取映射到的Publisher
p = Objects.requireNonNull(asyncPredicate.apply(t), "The asyncPredicate returned a null value");
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
Exceptions.addThrowable(ERROR, this, ex);
p = null; //discarded as "old" below
}
//有Publisher，
if (p != null) {
//
if (p instanceof Callable) {
Boolean u;
try {
u = ((Callable<Boolean>)p).call();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
Exceptions.addThrowable(ERROR, this, ex);
u = null; //triggers discard below
}
//返回true，则发射元素元素t。
if (u != null && u) {
a.onNext(t);
e++;
}
//false，则取消元素t。
else {
Operators.onDiscard(t, ctx);
}
} else {
//Publisher不是callable，
FilterWhenInner inner = new FilterWhenInner(this, !(p instanceof Mono));
if (CURRENT.compareAndSet(this,null, inner)) {
state = STATE_RUNNING;
p.subscribe(inner);
break;
}
}
}
T old = toFilter.getAndSet(offset, null);
Operators.onDiscard(old, ctx);
ci++;
if (++f == limit) {
f = 0;
upstream.request(limit);
}
} else
if (s == STATE_RESULT) {
Boolean u = innerResult;
innerResult = null;
if (u != null && u) {
a.onNext(t);
e++;
}
else {
Operators.onDiscard(t, ctx);
}
toFilter.lazySet(offset, null);
ci++;
if (++f == limit) {
f = 0;
upstream.request(limit);
}
state = STATE_FRESH;
} else {
break;
}
}
//发射的数量与requested数量一样。
if (e == r) {
if (cancelled) {
clear();
return;
}
boolean d = done;
int offset = (int)ci & m;
T t = toFilter.get(offset);
boolean empty = t == null;
if (d && empty) {
Throwable ex = Exceptions.terminate(ERROR, this);
if (ex == null) {
a.onComplete();
} else {
a.onError(ex);
}
return;
}
}
int w = wip;
if (missed == w) {
consumed = f;
consumerIndex = ci;
emitted = e;
missed = WIP.addAndGet(this, -missed);
if (missed == 0) {
break;
}
} else {
missed = w;
}
}
}
}
static final class FilterWhenInner implements InnerConsumer<Boolean> {
final FluxFilterWhenSubscriber<?> parent;
final boolean cancelOnNext;
//是否已完成。
boolean done;
volatile Subscription sub;
static final AtomicReferenceFieldUpdater<FilterWhenInner, Subscription> SUB =
AtomicReferenceFieldUpdater.newUpdater(FilterWhenInner.class, Subscription.class, "sub");
... ... ...
@Override
public void onSubscribe(Subscription s) {
//设置sub，并且请求所有元素。
if (Operators.setOnce(SUB, this, s)) {
s.request(Long.MAX_VALUE);
}
}
@Override
public void onNext(Boolean t) {
if (!done) {
if (cancelOnNext) {
sub.cancel();
}
done = true;
parent.innerResult(t);
}
}
@Override
public void onError(Throwable t) {
if (!done) {
done = true;
parent.innerError(t);
} else {
Operators.onErrorDropped(t, parent.currentContext());
}
}
@Override
public void onComplete() {
if (!done) {
done = true;
parent.innerComplete();
}
}
void cancel() {
Operators.terminate(SUB, this);
}
}
take
final class FluxTake<T> extends InternalFluxOperator<T, T> {
@Override
public void onNext(T t) {
if (done) {
Operators.onNextDropped(t, actual.currentContext());
return;
}
long r = remaining;
if (r == 0) {
s.cancel();
onComplete();
return;
}
remaining = --r;
boolean stop = r == 0L;
actual.onNext(t);
if (stop) {
s.cancel();
onComplete();
}
}
}
skip
final class FluxSkip<T> extends InternalFluxOperator<T, T> {
static final class SkipSubscriber<T>
}
}
sample
single
element
插入元素
switch
忽略元素值
then
sort
map
public final <V> Flux<V> map(Function<? super T, ? extends V> mapper) {
if (this instanceof Fuseable) {
return onAssembly(new FluxMapFuseable<>(this, mapper));
}
return onAssembly(new FluxMap<>(this, mapper));
}
final class FluxMap<T, R> extends InternalFluxOperator<T, R> {
final Function<? super T, ? extends R> mapper;
public CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super R> actual) {
if (actual instanceof Fuseable.ConditionalSubscriber) {
Fuseable.ConditionalSubscriber<? super R> cs =
(Fuseable.ConditionalSubscriber<? super R>) actual;
return new MapConditionalSubscriber<>(cs, mapper);
}
//包装Subscriber为MapSubscriber
return new MapSubscriber<>(actual, mapper);
}
static final class MapSubscriber<T, R>
implements InnerOperator<T, R> {
final CoreSubscriber<? super R> actual;
final Function<? super T, ? extends R> mapper;
boolean done;
//原始 Subscription
Subscription s;
... ...
@Override
public void onSubscribe(Subscription s) {
if (Operators.validate(this.s, s)) {
this.s = s;
actual.onSubscribe(this);
}
}
@Override
public void onNext(T t) {
if (done) {
Operators.onNextDropped(t, actual.currentContext());
return;
}
R v;
try {
//应用mapper
v = Objects.requireNonNull(mapper.apply(t),
"The mapper returned a null value.");
}
catch (Throwable e) {
//对异常进行处理。
Throwable e_ = Operators.onNextError(t, e, actual.currentContext(), s);
if (e_ != null) {
onError(e_);
}
else {
s.request(1);
}
return;
}
//把mapper处理之后的值 发射出去。
actual.onNext(v);
}
@Override
public void onError(Throwable t) {
if (done) {
Operators.onErrorDropped(t, actual.currentContext());
return;
}
done = true;
actual.onError(t);
}
@Override
public void onComplete() {
if (done) {
return;
}
done = true;
actual.onComplete();
}
... ...
@Override
public void request(long n) {
//
s.request(n);
}
}
}
expand
杂项
拆分
window
buffer
回到同步操作
to
调试类Operator
log
elapsed
timestamp
checkpoint