Rxjava2源码分析（二）

最新推荐文章于 2024-10-11 16:17:20 发布

无名啊啊小辈

最新推荐文章于 2024-10-11 16:17:20 发布

阅读量180

点赞数 1

分类专栏： rxjava android 文章标签： android

本文链接：https://blog.csdn.net/qq_43676395/article/details/104877903

版权

android 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

rxjava

2 篇文章 0 订阅

订阅专栏

Rxjava2线程调度部分

如果rxjava2分析（一）没看完欢迎移步https://blog.csdn.net/qq_43676395/article/details/104864276

提出问题：

1.rxjava2如何进行线程的切换的。
2.rxjava2如何保持线程同步的。
3.Schedulers他是如何进行调度线程的。

1.入口代码

Observable.create(new ObservableOnSubscribe<ArrayList<String>>() {
    @Override
    public void subscribe(ObservableEmitter<ArrayList<String>> emitter) throws Exception {
        ArrayList<String>stringArrayList=new ArrayList<>();
        stringArrayList.add("hello");
        emitter.onNext(stringArrayList);
    }
}).doOnNext(new Consumer<ArrayList<String>>() {
    @Override
    public void accept(ArrayList<String> s) throws Exception {
        Log.i("msg2","第1个线程开始执行"+Thread.currentThread()+s.toString());
        s.add("第一个");
    }
}).observeOn(Schedulers.io()).doOnNext(new Consumer<ArrayList<String>>() {
    @Override
    public void accept(ArrayList<String> s) throws Exception {
        Log.i("msg2","第2个线程开始执行"+Thread.currentThread()+""+s.toString());
        Thread.sleep(8000);
         s.add("第二个");
    }
}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<ArrayList<String>>() {
    @Override
    public void onSubscribe(Disposable d) {
    }

    @Override
    public void onNext(ArrayList<String> s) {
        Log.i("msg2","下游事件线程"+Thread.currentThread()+s.toString());

    }

    @Override
    public void onError(Throwable e) {
    }

    @Override
    public void onComplete() {

    }
});

在这里插入图片描述从输出结果我们可以发现线程从主线程切换到另一个线程又切回到主线程，根据根据上文的分析的结果，我们直接分析Schedulers.io()方法。

//在Scheduler类中
@NonNull
public static Scheduler io() {
//返回一个IO
    return RxJavaPlugins.onIoScheduler(IO);
}
//下面我们来看看IO是什么
@NonNull
static final Scheduler IO;
static {
......
       IO = RxJavaPlugins.initIoScheduler(new IOTask());
   ......
}
//我们发现IO是一个静态的Scheduler类，在Scheduler的static静态代码块中被赋值为IOTask
static final class IOTask implements Callable<Scheduler> {
    @Override
    public Scheduler call() throws Exception {
        return IoHolder.DEFAULT;
    }
}
//IoHolder.DEFAULT又是什么呢
static final class IoHolder {
    static final Scheduler DEFAULT = new IoScheduler();
}
//最后我们发现IO最后为IoScheduler类的实例，他是一个静态的

然后我们继续看observeOn(Schedulers.io()）方法实际上就是传入一个IoScheduler的实例，也就是observeOn(IoScheduler）。
下面我们来看看observeOn方法

public final Observable<T> observeOn(Scheduler scheduler) {
    return observeOn(scheduler, false, bufferSize());
}
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
......
     return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}
//由上面代码可知返回了一个ObservableObserveOn类
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;
  ......
    public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
        super(source);
        this.scheduler = scheduler;
        ......
    }
}
//再来看看observeOn(AndroidSchedulers.mainThread())方法，这里我们直接给出MainThread的调度器类为HandlerScheduler，之后我们在对该类进行分析
//下面我们根据上面代码的和例子生成结构图

在这里插入图片描述

接下来会执行subscribe（Observer）方法，和之前分析的一样，会逐步执行subscribeActual（Observer<? super T> observer）方法，这里我们只需要看ObservableObserveOn类的该方法就行了，因为其他类的该方法我们都分析了。

@Override
protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
    //返回一个EventLoopWorker类
        Scheduler.Worker w = scheduler.createWorker();

        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}
//和之前的类该方法差不多，只是传入参数不同，我们生成如下结构图

在这里插入图片描述接下来根据上个文章的分析，会执行onSubscribe（Disposable d）方法，，我们来看看ObserveOnObserver的onSubscribe方法。

@Override
public void onSubscribe(Disposable d) {
    if (DisposableHelper.validate(this.upstream, d)) {
        this.upstream = d;
        if (d instanceof QueueDisposable) {
            @SuppressWarnings("unchecked")
            QueueDisposable<T> qd = (QueueDisposable<T>) d;

            int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);

            if (m == QueueDisposable.SYNC) {
                sourceMode = m;
                queue = qd;
                done = true;
                downstream.onSubscribe(this);
                schedule();
                return;
            }
            if (m == QueueDisposable.ASYNC) {
                sourceMode = m;
                queue = qd;
                downstream.onSubscribe(this);
                return;
            }
        }
//一般会执行到这里，如果之前没两个相连的调度器
//SpscLinkedArrayQueue是保存onNext（T value）传来的value值，里面的操作是一些原子性操作
        queue = new SpscLinkedArrayQueue<T>(bufferSize);

        downstream.onSubscribe(this);
    }
}

下面就会逐步执行onNext方法了，我们来看看ObserveOnObserver的onNex方法

@Override
public void onNext(T t) {
    if (done) {
        return;
    }

    if (sourceMode != QueueDisposable.ASYNC) {
        queue.offer(t);
    }
    
    schedule();
}

void schedule() {
    if (getAndIncrement() == 0) {
        worker.schedule(this);
    }
}
//这里是执行EventLoopWorker 的schedule方法，下面我们进行分析

Scheduler调度器的该方法。
@Override
public Worker createWorker() {
//pool.get()为一个静态的CachedWorkerPool类实例
    return new EventLoopWorker(pool.get());
}
//返回了一个EventLoopWorker类实例，那我们来看看这个类。
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;
        //CompositeDisposable中保存一个Disposable的集合
        this.tasks = new CompositeDisposable();
        //获取一个ThreadWorker，先从ConcurrentLinkedQueue的缓存中获取，如果缓存没有那么就生成一个实例
        this.threadWorker = pool.get();
    }
......
    @Override
    public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
        if (tasks.isDisposed()) {
            // don't schedule, we are unsubscribed
            return EmptyDisposable.INSTANCE;
        }

        return threadWorker.scheduleActual(action, delayTime, unit, tasks);
    }
}
//这里接收一个runable作为参数，那么ObserveOnObserver的run方法为
@Override
public void run() {
    if (outputFused) {
        drainFused();
    } else {
        drainNormal();
    }
}

那ThreadWorker 类是一个什么东西呢

static final class ThreadWorker extends NewThreadWorker {
   ......

    ThreadWorker(ThreadFactory threadFactory) {
        super(threadFactory);
        this.expirationTime = 0L;
    }
    ......
}

//NewThreadWorker类
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
    private final ScheduledExecutorService executor;

......

    public NewThreadWorker(ThreadFactory threadFactory) {
//这里生成一个线程池
        executor = SchedulerPoolFactory.create(threadFactory);
    }
 @NonNull
@Override
public Disposable schedule(@NonNull final Runnable action, long delayTime, @NonNull TimeUnit unit) {
    if (disposed) {
        return EmptyDisposable.INSTANCE;
    }
    //执行到这里
    return scheduleActual(action, delayTime, unit, null);
}
@NonNull
public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
    Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

    ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

    if (parent != null) {
        if (!parent.add(sr)) {
            return sr;
        }
    }

    Future<?> f;
    try {
    //这里将runnable加入线程池
        if (delayTime <= 0) {
            f = executor.submit((Callable<Object>)sr);
        } else {
            f = executor.schedule((Callable<Object>)sr, delayTime, unit);
        }
        sr.setFuture(f);
    } catch (RejectedExecutionException ex) {
        if (parent != null) {
            parent.remove(sr);
        }
        RxJavaPlugins.onError(ex);
    }

    return sr;
}
 }

这里我们来总结一下 worker.schedule(this);执行过程其实就是创建一个线程池，将ObserveOnObserver的run方法加入到线程池中执行

@Override
public void run() {
    if (outputFused) {
        drainFused();
    } else {
        drainNormal();
    }
}
//我们来看看drainNormal方法
void drainNormal() {
    int missed = 1;

    final SimpleQueue<T> q = queue;
    final Observer<? super T> a = downstream;

    for (;;) {
        if (checkTerminated(done, q.isEmpty(), a)) {
            return;
        }

        for (;;) {
            boolean d = done;
            T v;

            try {
            //从队列中取出值
                v = q.poll();
            } catch (Throwable ex) {
           ......
                return;
            }
            ......
            //执行downstrem的onNext方法
            a.onNext(v);
            ......
         }
}

我们来总结一下ObserveOnObserver的onNext方法其实就是将其run方法加入到ThreadWorker 的线程池中执行，run方法中执行了downstrem的onNext方法，也就是下一链表的onNext方法。那么后面切换到主线程是如和做到的呢，其实就是获取一个Message，利用主线程的handler执行messag中的run方法，这个run方法中会执行downstrem中的onNext方法。
1.rxjava2如何进行线程的切换的。
如果前面由线程的切换方法，那么利用Scheduler中的ThreadWorker 创建线程池，将run方法加入到线程池中执行
2.rxjava2如何保持线程同步的。
因为该线程执行完onNext方法才会继续往下执行onNext方法
3.Schedulers他是如何进行调度线程的。
和第一个问题重叠了emmm。