Rxjava 学习总结

https://www.jianshu.com/p/52cd2d514528 RxJava的使用（三）转换——map、flatMap
https://blog.csdn.net/wenyingzhi/article/details/80453464 教你轻松理解Rxjava之线程切换流程(observeOn与subscribeOn)
http://gank.io/post/560e15be2dca930e00da1083 给 Android 开发者的 RxJava 详解
https://www.jianshu.com/p/0cd258eecf60 这可能是最好的RxJava 2.x 教程（完结版）
https://www.jianshu.com/p/88aacbed8aa5 RxJava基本原理分析
https://www.jianshu.com/p/ecfb9d68d2a2 【Android】RxJava的使用（四）线程控制 —— Scheduler
https://blog.csdn.net/briblue/article/details/52447098 RxAndroid从零开始学之三（线程调度）
https://frank909.blog.csdn.net/column/info/24684
https://frank909.blog.csdn.net/article/details/52411707 RxAndroid从零开始学习之一(RxJava的简单Demo)
https://blog.csdn.net/linchangjian_/article/details/82782397 一张图告诉你 AndroidSchedulers.mainThread() + Schedulers.io() 怎么理解和使用？
https://www.jianshu.com/p/cd3557b1a474 RxJava2.0——从放弃到入门
https://juejin.im/post/5b17560e6fb9a01e2862246f RxJava2 只看这一篇文章就够了
https://www.cnblogs.com/WoodJim/p/5970937.html RxJava简介
https://cloud.tencent.com/developer/article/1035917 彻底搞清楚 RxJava 是什么东西
https://blog.csdn.net/yalinfendou/article/details/80752021 自己动手实现RxJava
https://www.cnblogs.com/mengdd/p/6047948.html Retrofit结合RxJava使用指南
https://www.jianshu.com/p/ecfb9d68d2a2 【Android】RxJava的使用（四）线程控制 —— Scheduler
线程调度：
https://www.jianshu.com/p/12638513424f
https://blog.csdn.net/niubitianping/article/details/54952827
https://www.jianshu.com/p/9e3930fbcb26
https://www.jianshu.com/p/3b99f3f58ffd
https://www.jianshu.com/p/b037dbae9d8f
https://www.jianshu.com/p/30e13d874a61

https://www.jianshu.com/p/7687365aa946 Retrofit网络请求参数注解，@Path、@Query、@QueryMap…
Rxjava1
app gradle中添加如下依赖

implementation 'io.reactivex:rxjava:1.0.14'
implementation 'io.reactivex:rxandroid:1.0.1'

RxJava在不指定线程的情况下，发起时间和消费时间默认使用当前线程。
subscribeOn()：指定subscribe()所发生的线程，即Observable.OnSubscribe被激活时所处的线程，或者叫做事件产生的线程。subscribeOn()的位置放在哪里都可以，但它是只能调用一次(第一次调用的才有用)。不过，可以在Observable.doOnSubscribe()后使用subscribeOn()来指定subscribe()时，执行doOnSubscribe()所在线程。
observeOn()：指定Subscriber 所运行在的线程。或者叫做事件消费的线程。其实，observeOn() 指定的是它之后的操作所在的线程，即链式调用过程中，此句代码（observeOn(xx.xx)）之后的代码所运行在的线程
https://blog.csdn.net/jdsjlzx/article/details/51607875
线程调度器 Scheduler

Scheduler：线程控制器，可以指定每一段代码在什么样的线程中执行。 
模拟一个需求：新的线程发起事件，在主线程中消费
Observable.just("Hello", "Word")
                .subscribeOn(Schedulers.newThread())//指定 subscribe() 发生在新的线程
                .observeOn(AndroidSchedulers.mainThread())// 指定 Subscriber 的回调发生在主线程
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

上面用到了subscribeOn()，和observeOn()方法来指定发生的线程和消费的线程。

多次切换线程

看完上面的介绍想必对RxJava线程的切换有了一些理解，上面只是对事件的发起和消费制定了线程。如果中间有map之类的操作呢？是否可以实现发起的线程在新线程中，map的处理在IO线程，最后的消费在主线程中。

Observable.just("Hello", "Wrold")
                .subscribeOn(Schedulers.newThread())//指定：在新的线程中发起
                .observeOn(Schedulers.io())         //指定：在io线程中处理
                .map(new Func1<String, String>() {
                    @Override
                    public String call(String s) {
                        return handleString(s);       //处理数据
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())//指定：在主线程中处理
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        show(s);                       //消费事件
                    }
                });
可以看到observeOn()被调用了两次，分别指定了map的处理的现场和消费事件show(s)的线程。

若将observeOn(AndroidSchedulers.mainThread())去掉会怎么样？不为消费事件show(s)指定线程后，show(s)会在那里执行？ 
其实，observeOn() 指定的是它之后的操作所在的线程。也就是说，map的处理和最后的消费事件show(s)都会在io线程中执行。 
observeOn()可以多次使用，可以随意变换线程

默认情况下rxjava中生产者和订阅者都是在当前线程中执行。Scheduler就是用来切换生产者和订阅者执行的线程。
https://blog.csdn.net/a910626/article/details/79298356
subscribeOn指定subscribe()所发生的线程，或者叫做事件产生的线程
observeOn 指定 Subscriber 所运行在的线程，或者叫做事件消费的线程

//new Observable.just()执行在新线程
  Observable.create(new Observable.just(getFilePath())
          .subscribeOn(Schedulers.newThread()) // //指定在新线程中创建被观察者，第一个subscribeOn指定的事件源发生线程
          .observeOn(Schedulers.io()) //将接下来执行的线程环境指定为io线程
          .map(mMapOperater)     //map就处在io线程
          .observeOn(AndroidSchedulers.mainThread())  //将后面执行的线程环境切换为主线程，但是这一句依然执行在io线程
          .subscribeOn(Schedulers.io()) //指定事件源发生的线程无效<但这句代码本身执行在主线程>，当有多个subscribeOn指定事件源发生线程的时候，只有第一个subscribeOn指定的事件源才起作用
          .subscribe(mSubscriber);    //执行在主线程<离这个最近的observeOn指定的事件处理线程是main线程>

Observable
                .create(new Observable.OnSubscribe<Integer>() {
                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        //main
                        Log.i(TAG, "OnSubscribe call method in thread: " + Thread.currentThread().getName());
                        subscriber.onNext(1);
                    }
                })
                .subscribeOn(Schedulers.io())
                .map(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        //io
                        Log.i(TAG, "map call method in thread: " + Thread.currentThread().getName());
                        return integer;
                    }
                })
                .subscribeOn(AndroidSchedulers.mainThread())
                .observeOn(Schedulers.io())
                .map(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        //io
                        Log.i(TAG, "map call method in thread: " + Thread.currentThread().getName());
                        return integer;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        //main
                        Log.i(TAG, "map call method in thread: " + Thread.currentThread().getName());
                        return integer;
                    }
                })
                .observeOn(Schedulers.io())
                .map(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        //io
                        Log.i(TAG, "map call method in thread: " + Thread.currentThread().getName());
                        return integer;
                    }
                })
                .observeOn(Schedulers.newThread())
                .map(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        //main
                        Log.i(TAG, "map method in thread: " + Thread.currentThread().getName());
                        return integer;
                    }
                })
                .observeOn(Schedulers.computation())
                .map(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        //main
                        Log.i(TAG, "map method in thread: " + Thread.currentThread().getName());
                        return integer;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        //main
                        Log.i(TAG, "map method in thread: " + Thread.currentThread().getName());
                        return integer;
                    }
                })
                .observeOn(Schedulers.io())
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        //io
                        Log.i(TAG, "map method in thread: " + Thread.currentThread().getName());
                        System.out.print(integer + '\n');
                    }
                });

以及参数Scheduler，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 主线程运行。

链接：https://www.jianshu.com/p/ecfb9d68d2a2

Android异步框架RxJava 1.x系列(三) - 线程调度器Scheduler https://blog.csdn.net/baidu_22254181/article/details/81066449
subscribeOn() 的线程切换发生在 OnSubscribe 中，即在它通知上一级 OnSubscribe 时，这时事件还没有开始发送，因此 subscribeOn() 的线程控制只能在事件发出的开端造成影响，即只允许一次线程切换。

observeOn() 的线程切换则发生在它内建的 Subscriber 中，即发生在它即将给下一级 Subscriber 发送事件时，因此 observeOn() 控制的是它后面的线程，允许多次线程切换。

与 Subscriber.onStart() 相对应的，有一个方法 Observable.doOnSubscribe()。它和 Subscriber.onStart() 同样是在 subscribe() 调用后而且在事件发送前执行，但区别在于它可以指定线程。默认情况下，doOnSubscribe() 执行在 subscribe() 发生的线程；而如果在 doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。

原文：https://blog.csdn.net/baidu_22254181/article/details/81066449

Observable.create(onSubscribe)
    .subscribeOn(Schedulers.io())
    .doOnSubscribe(new Action0() {
        @Override
        public void call() {
            // 需要在主线程执行
            progressBar.setVisibility(View.VISIBLE); 
        }
    })
    .subscribeOn(AndroidSchedulers.mainThread()) 
    // 指定主线程
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(subscriber);

Observable.just(student1, student2, student2)
                //使用map进行转换，参数1：转换前的类型，参数2：转换后的类型
                .map(new Func1<Student, String>() {
                    @Override
                    public String call(Student i) {
                        String name = i.getName();//获取Student对象中的name
                        return name;//返回name
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        nameList.add(s);
                    }
                });

https://www.jianshu.com/p/52cd2d514528

所有的业务代码都是在subscribe()调用以后才会执行的 https://www.jianshu.com/p/88aacbed8aa5
https://blog.csdn.net/yankebin/article/details/80844891 RxJava2探索-线程切换原理之subscribeOn

Rxjava2
http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2016/0907/6604.html RxJava2 浅析
https://blog.csdn.net/weixin_34232617/article/details/87983546 RxJava1 升级到 RxJava2 所踩过的坑
https://www.jianshu.com/p/a5dbab3068c8 RxJava 2.x.y与Retrofit结合使用出现时出现无法创建Observable
更新于2019年6月30日 云台山 7贤宾馆

Rxjava1

Observable
                        .create(new Observable.OnSubscribe<Integer>() {
                            @Override
                            public void call(Subscriber<? super Integer> subscriber) {
                                Log.i(TAG, "OnSubscribe call method in thread: " + Thread.currentThread().getName());
                                subscriber.onNext(1);
                            }
                        })
                        //.subscribeOn(AndroidSchedulers.mainThread())
                        .subscribeOn(Schedulers.io())
                        .map(new Func1<Integer, Integer>() {
                            @Override
                            public Integer call(Integer integer) {
                                Log.w(TAG, "1 map call method in thread: " + Thread.currentThread().getName());
                                return integer;
                            }
                        })
                        //.observeOn(AndroidSchedulers.mainThread())
                        .map(new Func1<Integer, Integer>() {
                            @Override
                            public Integer call(Integer integer) {
                                Log.w(TAG, "7 map method in thread: " + Thread.currentThread().getName());
                                return integer;
                            }
                        })
                        //.observeOn(Schedulers.io())
                        .observeOn(Schedulers.immediate())
                        .subscribe(new Subscriber<Integer>() {
                            @Override
                            public void onCompleted() {

                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onNext(Integer integer) {
                                //io
                                Log.d(TAG, "8 subscribe method in thread: " + Thread.currentThread().getName());
                                System.out.print(integer + '\n');
                            }
                        });

Rxjava2

Observable
                        .create(new ObservableOnSubscribe<Integer>() {
                            @Override
                            public void subscribe(ObservableEmitter<Integer> subscriber) {
                                Log.i(TAG, "OnSubscribe call method in thread: " + Thread.currentThread().getName());
                                subscriber.onNext(1);
                            }
                        });