Fork/Join是一种基于“分治”的算法:通过分解任务,并行执行,最后合并结果得到最终结果。
ForkJoinPool
线程池可以把一个大任务分拆成小任务并行执行,任务类必须继承自RecursiveTask(带返回值)
或RecursiveAction(不带返回值)
。使用Fork/Join模式可以进行并行计算以提高效率。
案例:从1加到1000000000
public class ForkJoinCalculate extends RecursiveTask<Long> {
private long strat;
private long end;
// 临界值
private static final long THRESHOLD = 10000;
public ForkJoinCalculate(long strat,long end){
this.strat = strat;
this.end = end;
}
@Override
protected Long compute() {
long length = end-strat;
if(length<=THRESHOLD){
long sum =0;
for(long i =strat;i<=end;i++){
sum+=i;
}
return sum;
}else{
long middle =(strat+end)/2;
// 创建类的实例
ForkJoinCalculate left = new ForkJoinCalculate(strat,middle);
// 拆分子任务,同时压入线程队列
left.fork();
ForkJoinCalculate right = new ForkJoinCalculate(middle+1,end);
// 串行流:比单线程(for循环)效率高得多
// Instant start1 = Instant.now();
rangeClosed生成一系列连续的数
// LongStream.rangeClosed(1,10000000000L)
串行流
// .parallel()
// .reduce(Long::sum);
// Instant end1 = Instant.now();
// System.out.println(Duration.between(start1, end1).toMillis());
right.fork();
// 合并
return left.join()+right.join();
}
}
}
public class TestForkjoin {
public static void main(String[] args) {
// 计算时间戳
Instant start = Instant.now();
// 创建线程池
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinCalculate(0,10000000000L);
// invoke调用我们所提供的方法以及调用方法的参数来完成动态调用。
Long sum =pool.invoke(task);
System.out.println(sum);
Instant end = Instant.now();
System.out.println(Duration.between(start, end).toMillis());
// 顺行流:比单线程(for循环)效率高得多
// Instant start1 = Instant.now();
rangeClosed生成一系列连续的数
// LongStream.rangeClosed(1,10000000000L)
串行流
// .parallel()
// .reduce(Long::sum);
// Instant end1 = Instant.now();
// System.out.println(Duration.between(start1, end1).toMillis());
数值太大所以显示结果错误
Optional容器类
实例
public class Test {
public static void main(String[] args) {
/*
Optional.of(T t):创建一个Optional实例
Optional.empty():创建一个空的 Optional实例
Optional。ofNullable(T t):若t不为空,创建 Optional实例,否则创建空实例
isPresent():判断是否包含值
orElse(T t):如果调用对象包含值,返回该值,否则返回t
orElseGet(Supplier s):如果调用对象包含值,返回该值否则返回s获取的值
map(Function f):如果有值对其处理,并返回处理后的 Optional,否则返回 Optional。empty()
flatMap(Function mapper):与map类似,要求返回值必须是 Optional
*/
// Optional.of(null):若传入null快速锁定空指针位置
Optional<Employee> op = Optional.of(new Employee());
Employee emp = op.get();
System.out.println(emp);
Optional<Employee> op1 =Optional.empty();
System.out.println(op.get());
Optional<Employee> op3 = Optional.ofNullable(new Employee());
System.out.println(op3.get());
ofNullable(null):若传入null快速锁定空指针位置
// Optional<Employee> op2 = Optional.ofNullable(null);
// System.out.println(op2.get());
// 判断是否有值有值get获取
Optional<Employee> op4 = Optional.ofNullable(new Employee());
if(op4.isPresent()){
System.out.println(op3.get());
}
// 如果有值返回该值,没值获取默认值(自己写的值)
Employee emp1 = op4.orElse(new Employee("张三",18,111111));
// orElseGet(Supplier s):Supplier供给型接口与上边的区别可将new Employee()换成{任何功能}
Employee emp3 = op4.orElseGet(()->new Employee());
System.out.println(emp3);
Optional<Employee> op5 = Optional.ofNullable(new Employee("张三",18,111111));
//把容器对象new Employee应用到map上
Optional<String> str =op.map((e)->e.getName());
System.out.println(str);
}