项目地址：
https://github.com/ReactiveX/RxJava
https://github.com/ReactiveX/RxAndroid 
引入依赖： 
compile ‘io.reactivex:rxjava:1.1.0‘
compile ‘io.reactivex:rxandroid:1.1.0‘
RxJava 是什么？
一个词：异步。
RxJava 在 GitHub 主页上的自我介绍是【"a library for composing组成 asynchronous异步的 and event-based programs using observable可观测的 sequences序列 for the Java VM"】（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。
其实， RxJava 的本质可以压缩为异步这一个词。说到根上，它就是一个实现异步操作的库，而别的定语都是基于这之上的。
RxJava 好在哪？
一个词：简洁。
异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。 Android 创造的AsyncTask 和Handler ，其实都是为了让异步代码更加简洁。RxJava 的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。
假设有这样一个需求：界面上有一个自定义的视图，它的作用是显示多张图片，并能任意增加显示的图片。现在需要将一个给出的目录数组中每个目录下的 png 图片都加载出来并显示在View中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在 UI 线程执行。其中一种方式：
        new Thread() {
            void run() {
                super.run();
                for (File folder : folders) {
                    File[] files = folder.listFiles();
                    for (File file : files) {
                        if (file.getName().endsWith(".png")) {
                            final Bitmap bitmap = getBitmapFromFile(file);
                            getActivity().runOnUiThread(new Runnable() {
                                void run() {
                                    imageCollectorView.addImage(bitmap);
                                }
                            });
                        }
                    }
                }
            }
        }.start();
而如果使用 RxJava ，实现方式是这样的：
        Observable.from(folders)
           .flatMap(new Func1<File, Observable<File>>() {
            Observable<File> call(File file) {return Observable.from(file.listFiles());}
        }).filter(new Func1<File, Boolean>() {
            Boolean call(File file) {return file.getName().endsWith(".png");}
        }).map(new Func1<File, Bitmap>() {
            Bitmap call(File file) {return getBitmapFromFile(file);}
        }).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Action1<Bitmap>() {
            void call(Bitmap bitmap) {
                imageCollectorView.addImage(bitmap);
            }
        });
观察一下你会发现， RxJava 的这个实现，是一条从上到下的链式调用，没有任何嵌套，这在逻辑的简洁性上是具有优势的。当需求变得复杂时，这种优势将更加明显。
另外，如果你的 IDE 是 Android Studio ，其实每次打开某个 Java 文件的时候，你会看到被自动 Lambda 化的预览，这将让你更加清晰地看到程序逻辑。

RxJava 的异步实现，是通过一种【扩展的观察者模式】来实现的。
RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。
Observable 和Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。
与传统观察者模式不同， RxJava 的事件回调方法除了普通事件 onNext()之外，还定义了两个特殊的事件：onCompleted() 和 one rror()。
onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的onNext() 发出时，需要触发 onCompleted() 方法作为标志。
onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。
在一个正确运行的事件序列中, onCompleted() 和 one rror() 有且只有一个，并且是事件序列中的最后一个。
需要注意的是，onCompleted() 和 one rror() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。
基于以上的概念， RxJava 的基本实现主要有三点：
1、创建 Observer，它决定事件触发的时候将有怎样的行为。 
RxJava 中的 Observer 接口的实现方式：
        Observer<String> observer = new Observer<String>() {
            void onNext(String s) {
                Log.d(tag, "Item: " + s);
            }
            void onCompleted() {
                Log.d(tag, "Completed!");
            }
            void onError(Throwable e) {
                Log.d(tag, "Error!");
            }
        };
除了 Observer 接口之外，RxJava 还内置了一个实现了 Observer 的抽象类：Subscriber。 Subscriber 对 Observer 接口进行了一些扩展，但他们的基本使用方式是完全一样的。实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能，选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点：
onStart(): 这是 Subscriber 增加的方法。它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求， onStart() 就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用 doOnSubscribe() 方法。
unsubscribe(): 这是 Subscriber 所实现的另一个 Subscription 接口的方法，用于取消订阅。在这个方法被调用后，Subscriber 将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed() 先判断一下状态。 unsubscribe() 这个方法很重要，因为在subscribe() 之后， Observable 会持有 Subscriber 的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。
正如前面所提到的原因，从这里开始，后面的描述我将用 Subscriber 来代替 Observer ，这样更加严谨。
2、创建 Observable，它决定什么时候触发事件以及触发怎样的事件。 
RxJava 使用 create() 方法来创建一个 Observable ，并为它定义事件触发规则：
        Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Overridepublic
            void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello");
                subscriber.onNext("Hi");
                subscriber.onNext("Aloha");
                subscriber.onCompleted();
            }
        });
可以看到，这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中，它的作用相当于一个计划表，当 Observable 被订阅的时候，OnSubscribe 的 call() 方法会自动被调用，事件序列就会依照设定依次触发。这样，由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。

create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法， RxJava 还提供了一些方法用来快捷创建事件队列，如上面的示例等价于
just(T...)：将传入的参数依次发送出来 Observable observable = Observable.just("Hello", "Hi", "Aloha");
from(T[]) / from(Iterable<? extends T>)：将传入的数组或 Iterable 拆分成具体对象后依次发送出来  Observable observable = Observable.from(new String[]{"Hello", "Hi", "Aloha"});
3、使用订阅方法subscribe()将它们联结起来
代码形式很简单：
observable.subscribe(observer或subscriber);
有人可能会注意到， subscribe() 这个方法有点怪：它看起来是『observalbe 订阅了 observer / subscriber』而不是『observer /subscriber 订阅了 observalbe』，这看起来就像『杂志订阅了读者』一样颠倒了对象关系。这让人读起来有点别扭，不过如果按照那种设计虽然更加符合思维逻辑，但对流式 API 的设计就造成影响了，比较起来明显是得不偿失的。
Observable.subscribe(Subscriber) 的内部实现是这样的（仅核心代码）：
    public Subscription subscribe(Subscriber subscriber) {
        subscriber.onStart();
        onSubscribe.call(subscriber);
        return subscriber;
    }
可以看到，subscribe() 做了3件事：
调用 Subscriber.onStart() ，这是一个可选的准备方法
调用 Observable 中的 OnSubscribe.call(Subscriber) 。在这里，事件发送的逻辑开始运行。从这也可以看出，在 RxJava 中，Observable 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当 subscribe() 方法执行的时候
将传入的 Subscriber 作为 Subscription 返回。这是为了方便 unsubscribe()
不完整定义回调
除了 subscribe(Observer) 和 subscribe(Subscriber) ，subscribe() 还支持不完整定义的回调，RxJava 会自动根据定义创建出Subscriber 。形式如下：
        Action1<String> onNextAction = new Action1<String>() {
            public void call(String s) { // onNext()
            }
        };
        Action1<Throwable> onErrorAction = new Action1<Throwable>() {
            public void call(Throwable throwable) { // onError()
            }
        };
        Action0 onCompletedAction = new Action0() {
            @Override
            public void call() {// onCompleted()
            }
        };
        observable.subscribe(onNextAction);// 自动创建 Subscriber，并使用 onNextAction 来定义 onNext()
        observable.subscribe(onNextAction, onErrorAction);
        observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
        这段代码中出现的Action0 是 RxJava 中定义的一个接口，它只有一个方法 call()，这个方法是无参无返回值的，由于 onCompleted() 方法也是无参无返回值的，因此 Action0 可以被当成一个包装对象，将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe() 以实现不完整定义的回调。这样其实也可以看做将 onCompleted() 方法作为参数传进了subscribe()，相当于其他某些语言中的『闭包』。 
        Action1 也是一个接口，它同样只有一个方法 call(T param)，这个方法也无返回值，但有一个参数；与 Action0 同理，由于 onNext(T obj) 和 one rror(Throwable error) 也是单参数无返回值的，因此 Action1 可以将onNext(obj) 和 one rror(error) 打包起来传入 subscribe() 以实现不完整定义的回调。
        事实上，虽然 Action0 和 Action1 在 API 中使用最广泛，但 RxJava 是提供了多个 ActionX 形式的接口 (例如 Action2, Action3) 的，它们可以被用以包装不同的无返回值的方法。
场景示例
将字符串数组中的所有字符串依次打印出来：
        Observable.from(new String[]{"包青天", "白乾涛", "baiqiantao"}).subscribe(new Action1<String>() {
            @Override
            public void call(String name) {Log.i("bqt", name);}
        });

在 RxJava 的默认规则中，事件的发出和消费都是在同一个线程的。也就是说，如果只用上面的方法，实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于 RxJava 是至关重要的。而要实现异步，则需要用到 RxJava 的另一个概念： Scheduler （调度程序，日程安排程序）。
Scheduler 的 API 
在RxJava 中，Scheduler（调度器）相当于线程控制器，RxJava 通过它来指定每一段代码应该运行在什么样的线程。RxJava 已经内置了几个 Scheduler ，它们已经适合大多数的使用场景：
Schedulers.immediate()：直接在当前线程运行，相当于不指定线程，这是默认的 Scheduler。
Schedulers.newThread()：总是启用新线程，并在新线程执行操作。
Schedulers.io()：I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
Schedulers.computation()：计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
AndroidSchedulers.mainThread()，是Android 专用的Scheduler，它指定的操作将在 Android 主线程运行。
有了这几个 Scheduler ，就可以使用 subscribeOn() 或 observeOn() 两个方法来对线程进行控制了。
subscribeOn(): 指定subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。
observeOn(): 指定Subscriber 所运行在的线程。或者叫做事件消费的线程。
示例
        Observable.just(1, 2, 3, 4)
                .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
                .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer number) {
                        Log.d(tag, "number:" + number);
                    }
                });
事实上，这种在 subscribe() 之前写上两句 subscribeOn(Scheduler.io()) 和 observeOn(AndroidSchedulers.mainThread()) 的使用方式非常常见，它适用于多数的 『后台线程取数据，主线程显示』的程序策略。
Scheduler 的原理
╮(╯▽╰)╭，以后再扯了

变换