1. 变换操作符底层实现
1.1 map() 操作符源码解析
// Observable.java
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
return new ObservableMap<>(this, mapper);
}
ObservableMap 实现：
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer<? super U> t) {
// 创建MapObserver代理
source.subscribe(new MapObserver<T, U>(t, function));
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> mapper;
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
if (done) return;
try {
// 关键转换：应用mapper函数
U v = mapper.apply(t);
downstream.onNext(v);
} catch (Throwable ex) {
fail(ex);
}
}
}
}
关键设计：
- 使用装饰器模式包装原始Observable
- 每个事件通过
mapper.apply()转换 - 错误处理通过
fail()方法统一处理
1.2 flatMap() 操作符源码解析
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) {
return flatMap(mapper, false, bufferSize(), bufferSize());
}
public final <R> Observable<R> flatMap(
Function<? super T, ? extends ObservableSource<? extends R>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
return new ObservableFlatMap<>(this, mapper, delayErrors, maxConcurrency, bufferSize);
}
ObservableFlatMap 核心结构：
public final class ObservableFlatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
final boolean delayErrors;
final int maxConcurrency;
final int bufferSize;
public ObservableFlatMap(ObservableSource<T> source,
Function<? super T, ? extends ObservableSource<? extends U>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
super(source);
this.mapper = mapper;
this.delayErrors = delayErrors;
this.maxConcurrency = maxConcurrency;
this.bufferSize = bufferSize;
}
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MergeObserver<>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}
}
MergeObserver 关键实现：
static final class MergeObserver<T, U> extends AtomicInteger
implements Observer<T>, Disposable {
final Observer<? super U> downstream;
final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
final boolean delayErrors;
final int maxConcurrency;
// 并发控制
final AtomicReference<InnerObserver<?, ?>[]> observers;
volatile boolean done;
@Override
public void onNext(T t) {
ObservableSource<? extends U> p;
try {
// 1. 应用mapper函数
p = mapper.apply(t);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
upstream.dispose();
onError(e);
return;
}
// 2. 创建InnerObserver
InnerObserver<T, U> inner = new InnerObserver<>(this, uniqueId++);
// 3. 管理并发
if (get() == maxConcurrency) {
// 处理背压
queue.offer(inner);
} else {
// 4. 订阅内部Observable
p.subscribe(inner);
getAndIncrement();
}
}
void innerComplete(InnerObserver<T, U> inner) {
// 5. 内部流完成处理
observers.remove(inner);
if (decrementAndGet() == 0) {
// 所有内部流完成
downstream.onComplete();
}
}
static final class InnerObserver<U> implements Observer<U> {
final MergeObserver<?, U> parent;
InnerObserver(MergeObserver<?, U> parent, long id) {
this.parent = parent;
}
@Override
public void onNext(U t) {
// 6. 转发数据到下游
parent.downstream.onNext(t);
}
@Override
public void onComplete() {
parent.innerComplete(this);
}
}
}
flatMap 工作流程：
- 接收上游数据项
- 通过mapper函数转换为新Observable
- 创建InnerObserver订阅新Observable
- 管理多个内部流的并发(maxConcurrency)
- 内部流的数据转发到下游
- 所有内部流完成后触发下游onComplete
2. 背压控制（Backpressure）
2.1 背压问题场景
当生产者速度 > 消费者速度时，会导致：
- 内存溢出（OOM）
- 事件丢失
- 系统不稳定
// 问题示例
Observable.interval(1, TimeUnit.MILLISECONDS) // 每秒1000个事件
.observeOn(Schedulers.computation()) // 消费者处理能力有限
.subscribe(value -> {
Thread.sleep(10); // 每个事件处理10ms → 每秒最多处理100个
});
2.2 Flowable 与 Subscriber
RxJava的背压解决方案：
Flowable.interval(1, TimeUnit.MILLISECONDS)
.onBackpressureBuffer(128) // 设置缓冲区大小
.observeOn(Schedulers.computation())
.subscribe(new Subscriber<Long>() {
@Override
public void onSubscribe(Subscription s) {
this.subscription = s;
s.request(64); // 初始请求64个
}
@Override
public void onNext(Long value) {
// 处理数据...
if (processedCount % 16 == 0) {
// 每处理16个请求更多
subscription.request(16);
}
}
});
2.3 onBackpressureBuffer() 源码解析
public final Flowable<T> onBackpressureBuffer(int capacity) {
return onBackpressureBuffer(capacity, false, false);
}
public final Flowable<T> onBackpressureBuffer(int capacity,
boolean delayError, BackpressureOverflowStrategy strategy) {
return new FlowableOnBackpressureBuffer<>(this, capacity, delayError, strategy);
}
FlowableOnBackpressureBuffer 核心实现：
static final class BackpressureBufferSubscriber<T>
extends AtomicInteger
implements FlowableSubscriber<T>, Subscription {
final Subscriber<? super T> downstream;
final SimplePlainQueue<T> queue;
final int capacity;
Subscription upstream;
volatile boolean cancelled;
@Override
public void onNext(T t) {
if (!queue.offer(t)) {
// 队列已满处理
upstream.cancel();
onError(new MissingBackpressureException("Buffer is full"));
return;
}
drain();
}
@Override
public void request(long n) {
if (SubscriptionHelper.validate(n)) {
requested.addAndGet(n);
drain();
}
}
void drain() {
if (getAndIncrement() != 0) return;
int missed = 1;
long r = requested.get();
Subscriber<? super T> a = downstream;
SimplePlainQueue<T> q = queue;
for (;;) {
long e = 0L;
while (e != r) {
T v = q.poll();
if (v == null) break;
a.onNext(v);
e++;
}
r = requested.addAndGet(-e);
if (e == r) {
if (q.isEmpty()) {
break;
}
}
}
}
}
2.4 背压策略对比
| 策略 | 方法 | 适用场景 | 风险 |
|---|---|---|---|
| 缓冲 | onBackpressureBuffer() | 消费者偶尔变慢 | 内存溢出 |
| 丢弃最新 | onBackpressureDrop() | 可容忍数据丢失 | 数据丢失 |
| 丢弃最旧 | onBackpressureLatest() | 只需最新数据 | 数据丢失 |
| 错误处理 | onBackpressureError() | 严格数据一致性 | 频繁错误 |
3. 过滤操作符原理
3.1 filter() 实现分析
public final Observable<T> filter(Predicate<? super T> predicate) {
return new ObservableFilter<>(this, predicate);
}
static final class ObservableFilter<T> extends AbstractObservableWithUpstream<T, T> {
final Predicate<? super T> predicate;
@Override
public void subscribeActual(Observer<? super T> observer) {
source.subscribe(new FilterObserver<>(observer, predicate));
}
static final class FilterObserver<T> extends BasicFuseableObserver<T, T> {
final Predicate<? super T> filter;
FilterObserver(Observer<? super T> actual, Predicate<? super T> filter) {
super(actual);
this.filter = filter;
}
@Override
public void onNext(T t) {
boolean result;
try {
// 应用过滤条件
result = filter.test(t);
} catch (Throwable e) {
fail(e);
return;
}
// 通过过滤则转发
if (result) {
downstream.onNext(t);
}
}
}
}
3.2 take() 实现分析
public final Observable<T> take(long count) {
return new ObservableTake<>(this, count);
}
static final class ObservableTake<T> extends AbstractObservableWithUpstream<T, T> {
final long limit;
@Override
public void subscribeActual(Observer<? super T> observer) {
source.subscribe(new TakeObserver<>(observer, limit));
}
static final class TakeObserver<T> implements Observer<T>, Disposable {
final Observer<? super T> downstream;
long remaining;
Disposable upstream;
TakeObserver(Observer<? super T> actual, long limit) {
this.downstream = actual;
this.remaining = limit;
}
@Override
public void onNext(T t) {
if (remaining > 0) {
remaining--;
downstream.onNext(t);
// 达到数量后取消
if (remaining == 0) {
upstream.dispose();
downstream.onComplete();
}
}
}
}
}
4. 操作符性能优化技巧
4.1 避免嵌套flatMap
不良实践：
Observable.range(1, 100)
.flatMap(i ->
loadFromNetwork(i).flatMap(data ->
processData(data) // 嵌套flatMap导致过度订阅
)
);
优化方案：
Observable.range(1, 100)
.concatMap(i ->
loadFromNetwork(i).map(data ->
processData(data) // 使用concatMap + map
)
);
4.2 操作符组合优化
| 场景 | 不良实践 | 优化方案 | 性能提升 |
|---|---|---|---|
| 过滤+映射 | .filter().map() | .compose(filterAndMap) | 减少中间对象 |
| 多次映射 | .map(f1).map(f2) | .map(data -> f2(f1(data))) | 减少中间Observable |
| 列表处理 | fromIterable().map() | 直接处理列表 | 减少事件数量 |
4.3 背压参数调优
Flowable.interval(1, TimeUnit.MILLISECONDS)
.onBackpressureBuffer(
256, // 缓冲区大小
() -> log("Overflow"), // 溢出回调
BufferOverflowStrategy.DROP_LATEST // 策略
)
.observeOn(Schedulers.io(), false, 128) // 预取128项
.subscribe(...);
关键参数：
bufferSize：平衡内存和吞吐量prefetch：observeOn的预取数量maxConcurrency：flatMap的最大并发流
本章总结
-
变换操作符原理：
map：直接转换每个数据项flatMap：异步转换+合并结果流- 使用装饰器模式包装原始Observable
-
背压控制机制：
- 问题本质：生产者速度 > 消费者速度
- Flowable + Subscriber 解决方案
- 四大策略：缓冲、丢弃最新、丢弃最旧、错误
-
过滤操作符实现：
filter：条件判断转发take：计数完成后取消
-
性能优化要点：
- 避免嵌套flatMap
- 减少中间操作符
- 合理设置背压参数
核心洞察：操作符的本质是创建新的Observable，通过特定的Observer实现数据流的转换。理解操作符的源码实现有助于避免常见性能陷阱，编写高效响应式代码。
在下一章中，我们将深入解析RxJava的高阶功能，包括组合操作符(zip, combineLatest)、错误处理机制和并发模型实现原理
