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())
Observable Flowable Test的更多相关文章
- Retrofit 简介 wiki 文档
简介 Type-safe HTTP client for Android and Java by Square, Inc. GitHub主页:https://github.com/square/ret ...
- 实战SpringCloud响应式微服务系列教程（第三章）
接着之前的: 实战SpringCloud响应式微服务系列教程(第一章) 实战SpringCloud响应式微服务系列教程(第二章) 1.1.3Reactor框架 响应式编程是一种编程模型,本节将介绍这种 ...
- Rxjava2 介绍与详解实例
目录 前言 RX介绍 Rx模式 Rx使用依赖: Rxjava的入门基础 1. Observable 2. Flowable 3. Single 4. Completable 5. Maybe 6. S ...
- Android RxJava 2 的用法 just 、from、map、subscribe、flatmap、Flowable、Function、Consumer ...【转】
先简单说说RxJava的用途与价值 原文出处:Android RxJava 2 的用法 用途: 异步 (也就是开线程跳转) 价值: 面对复杂的逻辑,它依然 简洁 ,代码 易读 RxJava2 与 Rx ...
- angular2系列教程（八）In-memory web api、HTTP服务、依赖注入、Observable
大家好,今天我们要讲是angular2的http功能模块,这个功能模块的代码不在angular2里面,需要我们另外引入: index.html <script src="lib/htt ...
- Angular2学习笔记——Observable
Reactive Extensions for Javascript 诞生于几年前,随着angular2正式版的发布,它将会被更多开发者所认知.RxJs提供的核心是Observable对象,它是一个使 ...
- Rxjava cold/hot Observable
create Observable分为cold以及hot两种,cold主要是静态的,每次subscribe都是从头开始互不干扰,而hot的在同一时刻获得的值是一致的 cold Observable 使 ...
- 设计模式--观察者模式初探和java Observable模式
初步认识观察者模式 观察者模式又称为发布/订阅(Publish/Subscribe)模式,因此我们可以用报纸期刊的订阅来形象的说明: 报社方负责出版报纸. 你订阅了该报社的报纸,那么只要报社发布了新报 ...
- 观察者模式（Observer和Observable实现）
package com.wzy.java8.thread; import java.util.Observable; import java.util.Observer; public class D ...
随机推荐
- ngx-bootstrap使用03 Alerts组件、利用Object.assign复制对象
1 Alerts 该组件用于给用户操作提供反馈信息或者提供一些警告信息 2 用法 2.1 下载ngx-bootstrap依赖 参考博文:点击前往 2.2 在模块级别导入AlertModule模块 技巧 ...
- java中public static void main(String[] args)中String[] args代表什么意思？
这是java程序的入口地址,java虚拟机运行程序的时候首先找的就是main方法.跟C语言里面的main()函数的作用是一样的.只有有main()方法的java程序才能够被java虚拟机欲行,可理解为 ...
- ZROI2018提高day4t3
传送门 分析 我们假设如果一个点是0则它的值为-1,如果一个点是1则值为1,则一个区间的答案便是max(pre[i]+sur[i]),这里的pre[i]表示此区间i点和它之前的的前缀的最大值,sur[ ...
- SPOJ LCMSUM - LCM Sum
题意是求: $\sum_{i = 1}^{n}lcm(i, n)$ $= \sum_{i = 1}^{n}\frac{ni}{gcd(i, n)}$ $= n\sum_{i = 1}^{n}\frac ...
- Luogu 3457 [POI2007]POW-The Flood
感觉自己什么题都写不动了. 又是一个神贪心:把所有城市中的点按照高度从小到大排序之后拿出来逐个计算,枚举其他高度小于它的点向四周扩展,如果这个点不能被之前放过的抽水机覆盖,那么把答案加一,并在这个点放 ...
- Javascript parseInt()和parseFloat（）的用法
parseInt()方法首先查看位置0处的 字符,判断它是否是个有效数字:如果不是,该方法将返回NaN,不再继续执行其他操作.但如果该字符是有效数字,该方法将查看位置1处的字符,进行同样的 测试.这一 ...
- IDEA工作中常用快捷键
ctrl+shift+t: Ubuntu中在一个工具栏中打开两个终端 shift+shift: 搜索任何类 ctrl+N: 搜索任何类 ctrl+right: forward----自定义 ctrl+ ...
- 形式化验证工具（PAT）Reader-Writers Problem学习
经过前几次的学习,我们应该对PAT有一点点的了解了,我们加下来就直接看例子中的一个问题,这个问题比较简单. 看代码: //The classic Readers/Writers Example mod ...
- Windows系统编程之进程同步试验
试验过程中调用了不少系统函数,并且涉及到一些系统级的概念,在此记录下来做为解决问题的一种方式.也许在以后的编程的过程中是否可以通过调用系统平台上的东西来完成一些任务,这仍不失为一种好的思维方式. 多线 ...
- 使用 create 命令建立数据库v， 并利用sp_helpdb查看数据库文件
create database v on primary (name = v, filename='D:\v.mdf', size=3mb, maxsize=10mb, filegrowth=2mb ...