Rxjava是一个可观察的异步的基于事件的库，现在已经到了3.0.1版本了
本片文章会分析一下rxjava部分源码，主要看看大体的流程，不会拘泥于细节，让人对rxjava有一个基本的认识。
我们都知道，Rxjava是可以链式调用的，Observable可以通过很多的操作符转化成另外一种Observable。来看一个基本的例子 。
public void testInt(){
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(100);
}
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return integer+"";
}
}).subscribe(new io.reactivex.functions.Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d("rx",s);
}
});
}
上面的方法会依次执行subsCribe()->apply()->accept()。完成一个链式调用，它是如何完场链式调用的呢？
首先来看每一级的Observable结构。这里采用最经典的ObservableCreate
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) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
if (!isDisposed()) {
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (t == null) {
t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
if (!isDisposed()) {
try {
observer.onError(t);
} finally {
dispose();
}
} else {
RxJavaPlugins.onError(t);
}
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
......
}
可以发现三点，
1.Observable持有上一级的对象Observable引用(source)。
2.ObservableEmitter持有当前的Observer引用。
3.通过source把ObservableEmitter传递给了上一级。
以上三个特征机会每个Observable都有，这里可以做一个推论。
这里做一个说明，再一次链式rxjava调用过程中，最先生产的Obserbable为最上级，订阅者为最底层（最下级）
每一级的Observable会保存上一级的Observable。所有每两个相邻的Observable都会又一个引用关联，从顶层到底层的observable就连载一起，像链表一样。当前层级的Observable.subscribe()会触发上一级的obserbable.subscribe(），这一行为最终会触发到最顶级的Observable.subscribe()。至此订阅链完成。
每一级的Observer也有保存又下一级的observer引用，底层到顶层的Observable会连在一起，就像链表一样。当前层级的onNext(xx)会触发引用Observer的onNext()。所以这一行为最终会把事件通过中间的种种observer传递到最后一个observer中。事件消费链完成。
每一级的Observable订阅时会把当前订阅的Obserber传递给上一级。这样就建立的订阅链和消费链的通路。完成链式调用。
总的来讲是从底层向上订阅事件，然后从顶层向下消费事件。在上图中红色箭头时最后一个的订阅过程，是完成订阅链和执行的全过程的开始位置。
2.线程切换原理是什么？
线程切换的代码如下
public void testInt(){
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(100);
}
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return integer+"";
}
})
.subscribeOn(Schedulers.computation())
.observeOn(Schedulers.io())
.subscribe(new io.reactivex.functions.Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d("rx",s);
}
});
}
subscribeOn(xx),指定事件发射线程，其返回值也是一个Observable,源码如下
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> s) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
s.onSubscribe(parent);
parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
@Override
public void run() {
source.subscribe(parent);
}
}));
}
static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
private static final long serialVersionUID = 8094547886072529208L;
final Observer<? super T> actual;
final AtomicReference<Disposable> s;
SubscribeOnObserver(Observer<? super T> actual) {
this.actual = actual;
this.s = new AtomicReference<Disposable>();
}
@Override
public void onSubscribe(Disposable s) {
DisposableHelper.setOnce(this.s, s);
}
@Override
public void onNext(T t) {
actual.onNext(t);
}
@Override
public void onError(Throwable t) {
actual.onError(t);
}
@Override
public void onComplete() {
actual.onComplete();
}
......
}
}
可以看到在从下向上订阅中过程中，用scheduler.scheduleDirect(Runnable），指定了的发生的线程。从这一步之后向上订阅过程和从最顶层向下发射事件的多过程都在该线程中运行。
observeOn(xx)指定事件消费发生的线程。产生的Observable如下
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
final boolean delayError;
final int bufferSize;
public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
super(source);
this.scheduler = scheduler;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
Scheduler.Worker w = scheduler.createWorker();
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
private static final long serialVersionUID = 6576896619930983584L;
final Observer<? super T> actual;
final Scheduler.Worker worker;
final boolean delayError;
final int bufferSize;
SimpleQueue<T> queue;
Disposable s;
Throwable error;
volatile boolean done;
volatile boolean cancelled;
int sourceMode;
boolean outputFused;
ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
this.actual = actual;
this.worker = worker;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
@Override
public void onSubscribe(Disposable s) {
if (DisposableHelper.validate(this.s, s)) {
this.s = s;
if (s instanceof QueueDisposable) {
@SuppressWarnings("unchecked")
QueueDisposable<T> qd = (QueueDisposable<T>) s;
int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);
if (m == QueueDisposable.SYNC) {
sourceMode = m;
queue = qd;
done = true;
actual.onSubscribe(this);
schedule();
return;
}
if (m == QueueDisposable.ASYNC) {
sourceMode = m;
queue = qd;
actual.onSubscribe(this);
return;
}
}
queue = new SpscLinkedArrayQueue<T>(bufferSize);
actual.onSubscribe(this);
}
}
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
schedule();
}
@Override
public void onError(Throwable t) {
if (done) {
RxJavaPlugins.onError(t);
return;
}
error = t;
done = true;
schedule();
}
@Override
public void onComplete() {
if (done) {
return;
}
done = true;
schedule();
}
@Override
public void dispose() {
if (!cancelled) {
cancelled = true;
s.dispose();
worker.dispose();
if (getAndIncrement() == 0) {
queue.clear();
}
}
}
@Override
public boolean isDisposed() {
return cancelled;
}
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}
void drainNormal() {
int missed = 1;
final SimpleQueue<T> q = queue;
final Observer<? super T> a = actual;
for (;;) {
if (checkTerminated(done, q.isEmpty(), a)) {
return;
}
for (;;) {
boolean d = done;
T v;
try {
v = q.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
s.dispose();
q.clear();
a.onError(ex);
return;
}
boolean empty = v == null;
if (checkTerminated(d, empty, a)) {
return;
}
if (empty) {
break;
}
a.onNext(v);
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
void drainFused() {
int missed = 1;
for (;;) {
if (cancelled) {
return;
}
boolean d = done;
Throwable ex = error;
if (!delayError && d && ex != null) {
actual.onError(error);
worker.dispose();
return;
}
actual.onNext(null);
if (d) {
ex = error;
if (ex != null) {
actual.onError(ex);
} else {
actual.onComplete();
}
worker.dispose();
return;
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
@Override
public void run() {
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
......
}
}
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));指定了事件发生的线程。
每一次事件的发射是运行的worker.schedule(this)，事件的处理是发生在Worker线程池里面。
3.可观察的原理是什么？
是通过定义一个原子操作的变量Disposable，每个发射器都是Disposable的子类。在Emitter发送事件的时候会看Disposable状态按需发送，没有抛弃（dispose()）会直接派发，如果已经dispose中断新消费事件。
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
//这里会判断取消，如果没有取消就向下传递。
if (!isDisposed()) {
observer.onNext(t);
}
}
......
}
订阅的时候会在observer.onSubscribe(Disposable) 把disposable传递出去，有了这个值我们就能够用Disposable.dispose()切断事件处理过程了。
6.主动拉取请求和背压
一个常见的例子
public void testFlow(){
Flowable.create(new FlowableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull FlowableEmitter<String> emitter) throws Throwable {
emitter.onNext("hello");
}
}, BackpressureStrategy.MISSING)
.subscribe(new FlowableSubscriber<String>() {
@Override
public void onSubscribe(@NonNull Subscription s) {
s.request(1);
// s.cancel();
}
@Override
public void onNext(String s) {
}
@Override
public void onError(Throwable t) {
}
@Override
public void onComplete() {
}
});
}
创建Flowable的时候会传入背压策略。这里来看一下create()方法生成的Flowable。
public final class FlowableCreate<T> extends Flowable<T> {
final FlowableOnSubscribe<T> source;
final BackpressureStrategy backpressure;
public FlowableCreate(FlowableOnSubscribe<T> source, BackpressureStrategy backpressure) {
this.source = source;
this.backpressure = backpressure;
}
@Override
public void subscribeActual(Subscriber<? super T> t) {
BaseEmitter<T> emitter;
switch (backpressure) {
case MISSING: {
emitter = new MissingEmitter<>(t);
break;
}
case ERROR: {
emitter = new ErrorAsyncEmitter<>(t);
break;
}
case DROP: {
emitter = new DropAsyncEmitter<>(t);
break;
}
case LATEST: {
emitter = new LatestAsyncEmitter<>(t);
break;
}
default: {
emitter = new BufferAsyncEmitter<>(t, bufferSize());
break;
}
}
t.onSubscribe(emitter);
try {
source.subscribe(emitter);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
emitter.onError(ex);
}
}
订阅过程是根据不同背压策略来来生成发射器，然后开始调用上级的subscribe(xx).
这里看一下默认的缓存的发射器
static final class BufferAsyncEmitter<T> extends BaseEmitter<T> {
private static final long serialVersionUID = 2427151001689639875L;
final SpscLinkedArrayQueue<T> queue;
Throwable error;
volatile boolean done;
final AtomicInteger wip;
BufferAsyncEmitter(Subscriber<? super T> actual, int capacityHint) {
super(actual);
this.queue = new SpscLinkedArrayQueue<>(capacityHint);
this.wip = new AtomicInteger();
}
@Override
public void onNext(T t) {
if (done || isCancelled()) {
return;
}
if (t == null) {
onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
return;
}
queue.offer(t);
drain();
}
@Override
public boolean signalError(Throwable e) {
if (done || isCancelled()) {
return false;
}
error = e;
done = true;
drain();
return true;
}
@Override
public void onComplete() {
done = true;
drain();
}
@Override
void onRequested() {
drain();
}
@Override
void onUnsubscribed() {
if (wip.getAndIncrement() == 0) {
queue.clear();
}
}
void drain() {
if (wip.getAndIncrement() != 0) {
return;
}
int missed = 1;
final Subscriber<? super T> a = downstream;
final SpscLinkedArrayQueue<T> q = queue;
for (;;) {
long r = get();
long e = 0L;
while (e != r) {
if (isCancelled()) {
q.clear();
return;
}
boolean d = done;
T o = q.poll();
boolean empty = o == null;
if (d && empty) {
Throwable ex = error;
if (ex != null) {
errorDownstream(ex);
} else {
completeDownstream();
}
return;
}
if (empty) {
break;
}
a.onNext(o);
e++;
}
if (e == r) {
if (isCancelled()) {
q.clear();
return;
}
boolean d = done;
boolean empty = q.isEmpty();
if (d && empty) {
Throwable ex = error;
if (ex != null) {
errorDownstream(ex);
} else {
completeDownstream();
}
return;
}
}
if (e != 0) {
BackpressureHelper.produced(this, e);
}
missed = wip.addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
}
可以看到，在调用下一级发射器的时候，会把T存入对队列中，然后用drain()来派发队列中的事件。
Subscription .request(n)设置了拉去数据的最大值，在drain()方法中会最多从事件队列中取n次事件并向下转发。
Subscrption.cancel() 取消发射事件的原理和上问题中的Observerable取消发送是一样的。就是一个变量控制的，每次向下转发数据之前都会判读一下这个变量是否已经设置为取消状体。
发射器的构建是洋葱的接口，在最后订阅的时候，新构建的的发射器A把事件传递给了订阅事件，然后parent.subscribe(a)把发射器传递给了上级，上级会在A的外面再包一层发射器，这一优势一个任务链，到最上面的时候，发射器的链完成，组后只要调用最上面的一个发射，就会法事件输送下来。
总体上rxjava可以从一下4个方面来讲
1，链式结构
2，observable的连接，发射器的连接
3，线程切换原理，上去订阅，下观察，
4，可观察原理。
扫一扫
1360
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
