RxJava编程思想3-（实现简易版Rxjava，如何实现线程切换）

前言

已经使用rxjava两个月了，觉得rxjava特别好用，爱不释手。本文目的是通过几百行的代码，帮助大家理解rxjava中的链式调用，操作符，线程切换是如何实现的。如果有写的不对的地方欢迎在评论区留言，如果觉得写的可以，请点赞，关注，谢谢。

代码链接： github

目录：

RxJava编程思想1-（实现简易版Rxjava，如何基本功能和链式调用？）
RxJava编程思想2-（实现简易版Rxjava，如何实现操作符？）
RxJava编程思想3-（实现简易版Rxjava，如何实现线程切换？）

如何做线程切换？

如何实现？其实就是对被观察者的数据处理过程进行装饰，设计思想跟操作符一样，使用装饰者模式，对被被观察者的数据处理进行线程装饰。
操作起来：
先想一下，线程切换的几种场景：指定新线程，指定io线程，指定Android主线程等。
定义：抽象，约定线程的公共行为

public abstract class Scheduler {
    public abstract void scheduleDirect(Runnable runnable);
}

新线程实现：NewThreadScheduler

public class NewThreadScheduler extends Scheduler {
    private static final String TAG = "NewThreadScheduler";

    public static NewThreadScheduler getInstance(){
        return NewThreadSchedulerHolder.INSTANCE;
    }

    private static class NewThreadSchedulerHolder{
        private static NewThreadScheduler INSTANCE = new NewThreadScheduler();
    }

    @Override
    public void scheduleDirect(Runnable runnable) {
        executorService().execute(runnable);
    }

    private static ExecutorService executorService;

    private static synchronized ExecutorService executorService() {
        if (executorService == null) {
            executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), threadFactory
                    (false));
        }
        return executorService;
    }

    private static ThreadFactory threadFactory(final boolean daemon) {
        final AtomicInteger mCount = new AtomicInteger(1);
        return new ThreadFactory() {
            @Override
            public Thread newThread(Runnable runnable) {
                Thread result = new Thread(runnable, "RxJava New Thread #" + mCount.getAndIncrement());
                result.setDaemon(daemon);
                return result;
            }
        };
    }

}

Android主线程实现AndroidSchedulers

public class AndroidSchedulers extends Scheduler {

    private static final String TAG = "AndroidSchedulers";
    private final Handler handler = new Handler(Looper.getMainLooper());

    public static AndroidSchedulers getInstance() {
        return AndroidSchedulersHolder.INSTANCE;
    }

    private static class AndroidSchedulersHolder {
        private static AndroidSchedulers INSTANCE = new AndroidSchedulers();
    }

    @Override
    public void scheduleDirect(Runnable runnable) {
        Message message = Message.obtain(handler, runnable);
        message.obj = this;
        handler.sendMessage(message);
    }

}

提供方便用户使用的静态实例对象

public final class Schedulers {
    public static final Scheduler IO = IoScheduler.getInstance();
    public static final Scheduler NEW_THREAD = NewThreadScheduler.getInstance();
    public static final Scheduler ANDROID_MAIN_THREAD = AndroidSchedulers.getInstance();

}

装饰指定线程工具做好了。下面直接使用就行了。
装饰者模式走起。。。。。。。。。。。。

实际的装饰者对象ObservableSubscribeOn ：指定被观察者发射数据的线程

public class ObservableSubscribeOn<T> extends Observable<T> {

    final Scheduler scheduler;
    final ObservableSource<T> source;

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

    public final ObservableSource<T> source() {
        return source;
    }

    @Override
    public void subscribeActual(final Observer<? super T> s) {
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
        scheduler.scheduleDirect(new Runnable() {
            @Override
            public void run() {
                RLog.printInfo("我在这里切换");
                source.subscribe(parent);
            }
        });
    }


    static final class SubscribeOnObserver<T> implements Observer<T> {
        final Observer<? super T> actual;

        SubscribeOnObserver(Observer<? super T> actual) {
            this.actual = actual;
        }

        @Override
        public void onSubscribe() {
            actual.onSubscribe();
        }

        @Override
        public void onNext(T t) {
            CheckUtils.checkNotNull(t, "onNext called parameter can not be null");
            actual.onNext(t);
        }

        @Override
        public void onError(Throwable error) {
            actual.onError(error);

        }

        @Override
        public void onComplete() {
            actual.onComplete();
        }

    }
}

实际的装饰者对象ObservableObserveOn ：指定观察者接收数据的线程

public class ObservableObserveOn<T> extends Observable<T> {

    final Scheduler scheduler;
    final ObservableSource<T> source;

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

    public final ObservableSource<T> source() {
        return source;
    }

    @Override
    public void subscribeActual(final Observer<? super T> s) {
        final ObserveOnObserver<T> parent = new ObserveOnObserver<T>(s, scheduler);
        source.subscribe(parent);

    }

    static final class ObserveOnObserver<T> implements Observer<T> {
        final Observer<? super T> actual;
        final Scheduler scheduler;

        public ObserveOnObserver(Observer<? super T> actual, Scheduler scheduler) {
            this.actual = actual;
            this.scheduler = scheduler;
        }

        @Override
        public void onSubscribe() {
            scheduler.scheduleDirect(new Runnable() {
                @Override
                public void run() {
                    actual.onSubscribe();
                }
            });
        }

        @Override
        public void onNext(final T t) {
            scheduler.scheduleDirect(new Runnable() {
                @Override
                public void run() {
                    CheckUtils.checkNotNull(t, "onNext called parameter can not be null");
                    actual.onNext(t);
                }
            });
        }

        @Override
        public void onError(final Throwable error) {
            scheduler.scheduleDirect(new Runnable() {
                @Override
                public void run() {
                    actual.onError(error);
                }
            });
        }

        @Override
        public void onComplete() {
            scheduler.scheduleDirect(new Runnable() {
                @Override
                public void run() {
                    actual.onComplete();
                }
            });
        }
    }

}

同样为了方便用户使用 使用和链式调用，在装饰者组件Observable中 加入工具方法

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

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

现在就可以使用了：

Observable.create(new ObservableOnSubscribe<Integer>() {
			@Override
			public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
				RLog.printInfo("emitter发送第一个onNext，value = 1");
				emitter.onNext(1);
				RLog.printInfo("emitter发送onComplete");
				emitter.onComplete();
			}
		}).subscribeOn(Schedulers.NEW_THREAD).subscribeOn(Schedulers.IO).subscribeOn(Schedulers.NEW_THREAD).subscribeOn(Schedulers.IO).observeOn
				(Schedulers.IO).map(new Function<Integer, String>() {
			@Override
			public String apply(Integer integer) throws Exception {
				RLog.printInfo("切换线程");
				return "切换线程" + integer;
			}
		}).observeOn(Schedulers.ANDROID_MAIN_THREAD).subscribe(new Observer<String>() {

			@Override
			public void onSubscribe() {
				RLog.printInfo("Observer被订阅");
			}

			@Override
			public void onNext(String value) {
				RLog.printInfo("Observer接收到onNext，被转换之后的value = " + value);
			}

			@Override
			public void onError(Throwable e) {
				RLog.printInfo("Observer接收到onError，errorMsg = " + e.getMessage());
			}

			@Override
			public void onComplete() {
				RLog.printInfo("Observer接收到onComplete");
			}
		});

这里只是非常简单的带领大家理解rxjava主体的设计思想。为了方便理解，代码也尽可能简化到了极点。真正的rxjava源码做了很多优化，比如，数据流缓冲（背压）等。到此，大家应该对Rxjava的设计思想有了很好的理解了。其它操作符的架构设计思想是一样的，只是实现细节不同，相信看到这里在去看看rxjava源码应该很轻松就可以理解了。