RxJava响应式编程框架设计（二）

RxJava线程切换、背压原理、生命周期

Scheduler:线程调度器

背压：
当上下游在不同的线程中，通过Observable发射，处理，响应数据流时，如果上游发射数据的速度快于下游接收处理数据的速度，
这样对于那些没来得及处理的数据就会造成积压，这样数据既不会丢失，也不会被垃圾回收机制回收，而是存放在一个异步缓存池中，
如果缓存池中的数据一直得不到处理，越积越多，最后就会造成内存溢出，这便是响应式编程中的背压(backpressure)问题

背压策略的解决思路：
 /**
     * 未添加背压策略
     */
    @Test
    public void test8() {
        System.out.println("test8");
        // 内存增长很大
        Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
                int i = 0;
                // 上游不停地发
                while (true) {
                    i++;
                    emitter.onNext(i);
                }
            })
            .subscribeOn(Schedulers.newThread())
            .observeOn(Schedulers.newThread())
            .subscribe(integer -> {
                Thread.sleep(500);
                System.out.println(integer);
            });
    }

    /**
         * 添加背压策略
         */
        @Test
        public void test9() {
            System.out.println("test9");
            Flowable.create((FlowableOnSubscribe<Integer>) emitter -> {
                int i = 0;
                // 上游不停地发
                while (true) {
                    i++;
                    System.out.println("subscribe" + i);
                    emitter.onNext(i);
                }
                // emitter.onComplete();
            }, BackpressureStrategy.BUFFER) // 指定背压策略
                .subscribeOn(Schedulers.newThread())
                .observeOn(Schedulers.newThread())
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        // 限制下游处理的数据条数
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        try {
                            Thread.sleep(500);
                            System.out.println(integer);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    @Override
                    public void onError(Throwable t) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

BackpressureStrategy背压策略:

Subscription:

生命周期：
Compose
RxLifeCycle
.compose(this,<Long>bindUntilEvent(ActivityEvent.PAUSE));

  @Test
    public void test10() {
        // super:可以读写，向上转型 可以强转 读出来的是Object，需要强转
        // super一般当作一个参数去传递
        // extends:只能取，不能写 一般可以当作一个返回值来使用
        List<? super Person> persons = new ArrayList<>();
        persons.add(new Person("lisi"));
        Person person = (Person) persons.get(0);
        System.out.println(person);
    }

    class Person {
        private String name;

        public Person(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Person{" +
                "name='" + name + '\'' +
                '}';
        }
    }