• Observable Flowable Test


    package com.test.rxjava;
    
    import java.time.Duration;
    import java.time.Instant;
    import java.util.LinkedList;
    import java.util.concurrent.CountDownLatch;
    
    import org.apache.commons.lang3.time.DurationFormatUtils;
    
    import io.reactivex.Flowable;
    import io.reactivex.Observable;
    import io.reactivex.ObservableOnSubscribe;
    import io.reactivex.schedulers.Schedulers;
    
    public class ObservableTest {
      
      public static void main(String[] args) {
        ObservableTest test = new ObservableTest();
        CountDownLatch latch = new CountDownLatch(1);
        test.run();
        try {
          latch.await();
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      }
      private void run() {
        LinkedList<Integer> aList = new LinkedList<Integer>();
        for (int i = 0; i < 10000000; i++) {
          aList.add(i);
        }
        Instant start = Instant.now();
        Observable
        //Flowable
        //.fromIterable(aList)
        .create((ObservableOnSubscribe<Integer>) observableEmitter -> {
          //observableEmitter: 发射器
          Integer i = 0;
          while ( true){
              i++;
              System.out.println(i);
              observableEmitter.onNext(i);
          }
      })
        .observeOn(Schedulers.io())
        .subscribeOn(Schedulers.newThread())
        //.filter(i -> i%2==0)
        .subscribe(this::next, throwable -> throwable.printStackTrace(),()-> System.out.println(DurationFormatUtils.formatDurationWords(Duration.between(start, Instant.now()).toMillis(), true, true)));
      }
      private void next(Integer i) {
        try {
          Thread.sleep(100000);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":"+i);
      }
    }
    package com.test.rxjava;
    
    import java.time.Duration;
    import java.time.Instant;
    import java.util.Iterator;
    import java.util.concurrent.CountDownLatch;
    
    import org.apache.commons.lang3.time.DurationFormatUtils;
    
    import io.reactivex.Flowable;
    import io.reactivex.Observable;
    import io.reactivex.schedulers.Schedulers;
    
    public class ObservableTest implements Iterable<Integer> {
    
      private Integer begin;
      private Integer end;
    
      private ObservableTest(Integer begin, Integer end) {
        this.begin = begin;
        this.end = end;
      }
      
      public static void main(String[] args) {
        ObservableTest test = new ObservableTest(0, 1_000_000);
        CountDownLatch latch = new CountDownLatch(1);
        test.run(test, latch);
        try {
          latch.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    
      private void run(ObservableTest test, CountDownLatch latch) {
        Instant start = Instant.now();
        //Observable
             Flowable
            .fromIterable(test).observeOn(Schedulers.io()).subscribeOn(Schedulers.newThread())
            .subscribe(this::handleNext, e -> {
              e.printStackTrace();
              latch.countDown();
            }, () -> {
              System.out.println(DurationFormatUtils
                  .formatDurationWords(Duration.between(start, Instant.now()).toMillis(), true, true));
              latch.countDown();
            });
      }
    
      private void handleNext(Integer i) {
        System.out.println("consumer: "+Thread.currentThread().getName() + ":" + i);
      }
    
      public Iterator<Integer> iterator() {
        return new Itr(begin, end);
      }
    
      private class Itr implements Iterator<Integer> {
        private Integer begin;
        private Integer end;
    
        private Itr(Integer begin, Integer end) {
          this.begin = begin;
          this.end = end;
        }
    
        @Override
        public boolean hasNext() {
          return begin < end;
        }
    
    
        @Override
        public Integer next() {
          begin++;
          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println("producer: "+Thread.currentThread().getName() + ":" + begin);
          return begin;
        }
      }
    }
    package com.test.rxjava;
    
    import java.time.Duration;
    import java.time.Instant;
    import java.util.Iterator;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    
    import org.apache.commons.lang3.time.DurationFormatUtils;
    
    import io.reactivex.Observable;
    import io.reactivex.schedulers.Schedulers;
    
    public class ObservableTest implements Iterable<Integer> {
    
      private Integer begin;
      private Integer end;
    
      private ObservableTest(Integer begin, Integer end) {
        this.begin = begin;
        this.end = end;
      }
      
      public static void main(String[] args) {
        ObservableTest test = new ObservableTest(0, 100_000_000);
        CountDownLatch latch = new CountDownLatch(1);
        test.run(test, latch);
        try {
          latch.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    
      private void run(ObservableTest test, CountDownLatch latch) {
        Instant start = Instant.now();
        Observable
            .fromIterable(test)
            .observeOn(Schedulers.io())
            .subscribeOn(Schedulers.newThread())
            .filter(i -> i%2==0)
            .buffer(1000)
            .subscribe(this::handleNext, e -> {
              e.printStackTrace();
              latch.countDown();
            }, () -> {
              System.out.println("Observable:" + DurationFormatUtils
                  .formatDurationWords(Duration.between(start, Instant.now()).toMillis(), true, true));
              latch.countDown();
            });
      }
    
      private void handleNext(List<Integer> i) {
        System.out.println("consumer: "+Thread.currentThread().getName() + ":" + i.get(i.size()-1));
      }
    
      public Iterator<Integer> iterator() {
        return new Itr(begin, end);
      }
    
      private class Itr implements Iterator<Integer> {
        private Integer begin;
        private Integer end;
    
        private Itr(Integer begin, Integer end) {
          this.begin = begin;
          this.end = end;
        }
    
        @Override
        public boolean hasNext() {
          return begin < end;
        }
    
    
        @Override
        public Integer next() {
          begin++;
          //System.out.println("producer: "+Thread.currentThread().getName() + ":" + begin);
          return begin;
        }
      }
    }
    package com.test.rxjava;
    
    import java.time.Duration;
    import java.time.Instant;
    import java.util.Iterator;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    
    import org.apache.commons.lang3.time.DurationFormatUtils;
    
    import io.reactivex.Flowable;
    import io.reactivex.schedulers.Schedulers;
    
    public class FlowableTest implements Iterable<Integer> {
    
      private Integer begin;
      private Integer end;
    
      private FlowableTest(Integer begin, Integer end) {
        this.begin = begin;
        this.end = end;
      }
      
      public static void main(String[] args) {
        FlowableTest test = new FlowableTest(0, 100_000_000);
        CountDownLatch latch = new CountDownLatch(1);
        test.run(test, latch);
        try {
          latch.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    
      private void run(FlowableTest test, CountDownLatch latch) {
        Instant start = Instant.now();
        Flowable
            .fromIterable(test)
            .observeOn(Schedulers.io())
            .subscribeOn(Schedulers.newThread())
            .filter(i -> i%2==0)
            .buffer(1000)
            .subscribe(this::handleNext, e -> {
              e.printStackTrace();
              latch.countDown();
            }, () -> {
              System.out.println("Flowable:" + DurationFormatUtils
                  .formatDurationWords(Duration.between(start, Instant.now()).toMillis(), true, true));
              latch.countDown();
            });
      }
    
      private void handleNext(List<Integer> i) {
        System.out.println("consumer: "+Thread.currentThread().getName() + ":" + i.get(i.size()-1));
      }
    
      public Iterator<Integer> iterator() {
        return new Itr(begin, end);
      }
    
      private class Itr implements Iterator<Integer> {
        private Integer begin;
        private Integer end;
    
        private Itr(Integer begin, Integer end) {
          this.begin = begin;
          this.end = end;
        }
    
        @Override
        public boolean hasNext() {
          return begin < end;
        }
    
    
        @Override
        public Integer next() {
          begin++;
          //System.out.println("producer: "+Thread.currentThread().getName() + ":" + begin);
          return begin;
        }
      }
    }

     去掉

    .subscribeOn(Schedulers.newThread())
  • 相关阅读:
    Ionic3 遇到的一些错误-Error: Cannot find module 'reflect-metadata'
    Ionic3 遇到的一些错误-submodule update -q --init --recursive
    Ionic3 一些命令
    Npm 使用淘宝镜像
    在PHP中使用AES加密算法加密数据-2
    php实现AES/CBC/PKCS5Padding加密解密(又叫:对称加密)-1
    php rsa加密解密实例
    composer 安装Laravel、thinkphp5.1
    PHP原生分页的编写
    微信授权登录并获取用户信息接口开发
  • 原文地址:https://www.cnblogs.com/tonggc1668/p/10113641.html
Copyright © 2020-2023  润新知