第二章：RXJAVA基础操作与线程控制(源码分析)

1. Observable 创建源码分析

1.1 Observable.create() 源码解析

让我们深入分析RxJava最核心的创建方法：

csharp 复制代码

// Observable.java
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    return new ObservableCreate<>(source);
}

实现流程：

创建ObservableCreate实例
包装用户提供的ObservableOnSubscribe对象
当订阅发生时，触发实际的数据发射

核心类图：

scss 复制代码

Observable
    ↑
ObservableCreate (extends Observable)
    ↑
ObservableOnSubscribe (接口)

1.2 ObservableCreate 源码解析

scala 复制代码

// ObservableCreate.java
public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;
    
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
    
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        // 1. 创建发射器
        CreateEmitter<T> parent = new CreateEmitter<>(observer);
        
        // 2. 调用Observer的onSubscribe方法
        observer.onSubscribe(parent);
        
        try {
            // 3. 调用用户代码，传入发射器
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
}

1.3 CreateEmitter 实现分析

typescript 复制代码

static final class CreateEmitter<T> 
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {
    
    final Observer<? super T> observer;
    
    CreateEmitter(Observer<? super T> observer) {
        this.observer = observer;
    }
    
    @Override
    public void onNext(T t) {
        // 检查是否已dispose
        if (isDisposed()) return;
        
        if (t == null) {
            onError(new NullPointerException("onNext called with null"));
            return;
        }
        
        // 实际调用下游Observer的onNext
        observer.onNext(t);
    }
    
    @Override
    public void onError(Throwable t) {
        if (!tryOnError(t)) {
            // 处理未处理的错误
            RxJavaPlugins.onError(t);
        }
    }
    
    @Override
    public boolean tryOnError(Throwable t) {
        if (t == null) t = new NullPointerException();
        if (isDisposed()) return false;
        
        try {
            observer.onError(t);
        } finally {
            dispose();
        }
        return true;
    }
    
    @Override
    public void onComplete() {
        if (isDisposed()) return;
        try {
            observer.onComplete();
        } finally {
            dispose();
        }
    }
    
    @Override
    public void dispose() {
        DisposableHelper.dispose(this);
    }
}

关键设计：

使用AtomicReference<Disposable>管理生命周期
所有事件发送前检查dispose状态
错误处理遵循"失败快速"原则

2. 线程调度原理

2.1 subscribeOn() 源码解析

arduino 复制代码

// Observable.java
public final Observable<T> subscribeOn(Scheduler scheduler) {
    return new ObservableSubscribeOn<>(this, scheduler);
}

ObservableSubscribeOn 实现：

java 复制代码

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observer<? super T> observer) {
        // 1. 创建中间Observer
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<>(observer);
        
        // 2. 调用下游Observer的onSubscribe
        observer.onSubscribe(parent);
        
        // 3. 调度任务
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver<T> parent;

        SubscribeTask(SubscribeOnObserver<T> parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            // 4. 在指定线程执行订阅
            source.subscribe(parent);
        }
    }
}

线程切换流程：

arduino 复制代码

主线程: subscribeActual() 创建任务
↓
Scheduler线程: 执行SubscribeTask.run()
↓
在Scheduler线程调用: source.subscribe(parent)
↓
后续操作都在Scheduler线程执行

2.2 observeOn() 源码解析

arduino 复制代码

public final Observable<T> observeOn(Scheduler scheduler) {
    return new ObservableObserveOn<>(this, scheduler, false, bufferSize());
}

ObservableObserveOn 核心实现：

java 复制代码

public void subscribeActual(Observer<? super T> observer) {
    // 1. 根据调度器创建Worker
    Scheduler.Worker w = scheduler.createWorker();
    
    // 2. 订阅上游
    source.subscribe(new ObserveOnObserver<>(observer, w, delayError, bufferSize));
}

ObserveOnObserver 关键方法：

java 复制代码

@Override
public void onNext(T t) {
    if (done) return;
    
    // 1. 将数据加入队列
    if (queue.offer(t)) {
        // 2. 调度处理
        schedule();
    } else {
        // 处理背压溢出
        onError(new MissingBackpressureException("Queue is full?"));
    }
}

void schedule() {
    if (getAndIncrement() == 0) {
        // 3. 使用Worker调度
        worker.schedule(this);
    }
}

@Override
public void run() {
    // 4. 在目标线程处理事件
    drainNormal();
}

void drainNormal() {
    int missed = 1;
    final SimpleQueue<T> q = queue;
    final Observer<? super T> a = downstream;
    
    for (;;) {
        // 5. 从队列取数据
        T v = q.poll();
        
        if (v != null) {
            // 6. 实际调用下游Observer
            a.onNext(v);
        }
        
        // ... 处理完成和错误
    }
}

线程切换流程：

css 复制代码

上游线程: 调用onNext()将数据加入队列
↓
Worker线程: 执行drainNormal()处理队列
↓
调用下游Observer的onNext()

2.3 subscribeOn vs observeOn 对比

特性	subscribeOn	observeOn
作用位置	指定订阅发生的线程	指定事件消费的线程
影响范围	影响上游操作	影响下游操作
调用次数	多次调用仅第一次有效	可多次调用切换不同线程
实现机制	改变订阅源头	使用队列+线程调度

3. Scheduler 实现类剖析

3.1 Schedulers.io() 实现

scala 复制代码

public final class IoScheduler extends Scheduler {
    final AtomicReference<CachedWorkerPool> pool;
    
    @Override
    public Worker createWorker() {
        return new EventLoopWorker(pool.get());
    }
    
    static final class EventLoopWorker extends Scheduler.Worker {
        private final CompositeDisposable tasks;
        private final CachedWorkerPool pool;
        private final ThreadWorker threadWorker;
        
        EventLoopWorker(CachedWorkerPool pool) {
            this.pool = pool;
            this.tasks = new CompositeDisposable();
            this.threadWorker = pool.get();
        }
        
        @Override
        public Disposable schedule(Runnable action) {
            // 委托给ThreadWorker执行
            return threadWorker.scheduleActual(action, 0, TimeUnit.MILLISECONDS, tasks);
        }
    }
    
    static final class ThreadWorker extends NewThreadWorker {
        private long expirationTime;
        
        ThreadWorker(ThreadFactory threadFactory) {
            super(threadFactory);
            this.expirationTime = 0L;
        }
    }
}

关键设计：

使用线程池（默认是CachedThreadScheduler）
线程缓存机制（expirationTime控制）
自动回收空闲线程

3.2 AndroidSchedulers.mainThread() 实现

java 复制代码

public final class HandlerScheduler extends Scheduler {
    private final Handler handler;
    
    HandlerScheduler(Handler handler) {
        this.handler = handler;
    }
    
    @Override
    public Worker createWorker() {
        return new HandlerWorker(handler);
    }
    
    private static final class HandlerWorker extends Worker {
        private final Handler handler;
        private volatile boolean disposed;
        
        HandlerWorker(Handler handler) {
            this.handler = handler;
        }
        
        @Override
        public Disposable schedule(Runnable run) {
            // 封装为Runnable
            ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
            
            // 通过Handler发送到主线程
            Message message = Message.obtain(handler, scheduled);
            message.obj = this; // 用于取消
            
            handler.sendMessage(message);
            
            // 如果已dispose，立即取消
            if (disposed) {
                handler.removeCallbacks(scheduled);
                return Disposables.disposed();
            }
            
            return scheduled;
        }
    }
    
    private static final class ScheduledRunnable implements Runnable, Disposable {
        private final Handler handler;
        private final Runnable delegate;
        private volatile boolean disposed;
        
        ScheduledRunnable(Handler handler, Runnable delegate) {
            this.handler = handler;
            this.delegate = delegate;
        }
        
        @Override
        public void run() {
            try {
                delegate.run();
            } finally {
                dispose();
            }
        }
        
        @Override
        public void dispose() {
            disposed = true;
            handler.removeCallbacks(this);
        }
    }
}

关键设计：

基于Android Handler机制
使用Message.obj存储任务引用
自动取消已dispose的任务

4. 线程调度实践

4.1 典型使用场景

kotlin 复制代码

Observable.create(emitter -> {
    // 在IO线程执行耗时操作
    String data = loadFromDatabase();
    emitter.onNext(data);
})
.subscribeOn(Schedulers.io()) // 指定上游执行线程
.observeOn(AndroidSchedulers.mainThread()) // 指定下游执行线程
.subscribe(data -> {
    // 在主线程更新UI
    updateUI(data);
});

4.2 多级线程切换

rust 复制代码

Observable.just("Starting")
    .subscribeOn(Schedulers.io())
    .map(str -> {
        // 在IO线程执行
        return processData(str);
    })
    .observeOn(Schedulers.computation())
    .map(data -> {
        // 在计算线程执行
        return heavyComputation(data);
    })
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(result -> {
        // 在主线程显示结果
        showResult(result);
    });

4.3 常见问题及解决方案

问题1：subscribeOn多次调用

scss 复制代码

observable
    .subscribeOn(Schedulers.io()) // 有效
    .map(...)
    .subscribeOn(Schedulers.computation()) // 无效!

解决方案：仅第一次subscribeOn生效

问题2：observeOn影响后续操作

less 复制代码

observable
    .observeOn(AndroidSchedulers.mainThread())
    .doOnNext(item -> {
        // 在主线程执行
    })
    .observeOn(Schedulers.io())
    .subscribe(item -> {
        // 在IO线程执行
    });

问题3：内存泄漏

scss 复制代码

// 在Activity中使用
Disposable disposable = observable
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(...);

@Override
protected void onDestroy() {
    super.onDestroy();
    disposable.dispose(); // 必须取消订阅
}

本章总结

Observable创建：
- create()方法创建ObservableCreate
- 通过CreateEmitter连接Observer
- 严格的null检查和生命周期管理
线程调度机制：
- subscribeOn：改变订阅源头线程
- observeOn：通过队列和Worker切换下游线程
- 多次调用规则：subscribeOn首次有效，observeOn多次生效
Scheduler实现：
- Schedulers.io()：基于动态大小线程池
- AndroidSchedulers.mainThread()：基于Handler
- 内置调度器：computation、single、trampoline等
最佳实践：
- IO操作用subscribeOn(Schedulers.io())
- UI更新用observeOn(AndroidSchedulers.mainThread())
- 及时使用Disposable管理生命周期

核心理解：RxJava的线程调度本质是通过封装Runnable和队列机制，在不同线程间传递事件流。subscribeOn改变事件源头的执行线程，而observeOn改变事件处理链下游的执行线程。

在下一章中，我们将深入解析RxJava的核心操作符实现原理，包括map、flatMap等变换操作符的源码实现和背压机制。