Stream流式计算与ForkJoin

Stream流式计算与ForkJoin

一、Stream流式计算

什么是Stream流式计算

大数据:存储＋计算

集合、 MySQL本质就是存储东西的;

计算都应该交给流来操作！

/*题目要求:一分钟内 完成此题，只能用一行代码实现!
* 现在有5个用户！筛选:
* 1、ID必须是偶数
* 2、年龄必须大于23岁
* 3、用户名转为大写字母
* 4、用户名字母倒着排序
* 5、只输出一个用户!
*/
public class Test {
    
    
    public static void main(String[] args) {
    
    
        User u1 = new User(1, "a", 21);
        User u2 = new User(2, "b", 22);
        User u3 = new User(3, "c", 23);
        User u4 = new User(4, "d", 24);
        User u5 = new User(6, "e", 25);

        // 集合就是存储
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);

        // 计算交给Stream
        // 链式编程 lambda表达式 函数式接口 Stream流式计算
        // 效率高， 代码简洁
        list.stream()
                .filter(user -> {
    
     return user.getId() % 2 == 0; })
                .filter(user -> {
    
     return user.getAge() > 23; })
                .map(user -> {
    
    return user.getName().toUpperCase();})
                .sorted((uu1,uu2)->{
    
    return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);


        // System.out::println打印的是传入的参数，也就是Customer的
        // 参数泛型T，这个T就是从list的流对象获取的T,最终都是
        // List对象创建时指定的泛型

    }

}

二、ForkJoin

什么是ForkJoin

ForkJoin在JDK 1.7 ，并行执行任务！提高效率。大数据量！

大数据：Map Reduce （把大任务拆分为小任务）

ForkJoin特点：工作窃取

这个里面维护的都是双端队列

扫描二维码关注公众号，回复： 13142983 查看本文章

ForkJoin使用

/** * 求和计算的任务！ 
* 3000   6000（ForkJoin）  9000（Stream并行流） 
* // 如何使用 forkjoin 
* // 1、forkjoinPool 通过它来执行 
* // 2、计算任务 forkjoinPool.execute(ForkJoinTask task) 
* // 3. 计算类要继承 ForkJoinTask 
*/ 
public class ForkJoinDemo extends RecursiveTask<Long> {
    
    
     //1
    private Long start;
    //1990900000
    private Long end;

    // 临界值
    private Long temp=10000L;

    public ForkJoinDemo(Long start, Long end) {
    
    
        this.start = start;
        this.end = end;
    }

    //计算方法
    @Override
    protected Long compute() {
    
    
        if ((end-start)<temp){
    
    
            Long sum=0L;
            for (Long i = start;  i<=end ; i++) {
    
    
                sum+=i;
            }

            return sum;
        }
        else {
    
    
            // forkjoin 递归
            // 中间值
            Long middle=(start+end)/2;
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            // 拆分任务，把任务压入线程队列
            task1.fork();
            ForkJoinDemo task2 = new ForkJoinDemo(middle + 1, end);
            // 拆分任务，把任务压入线程队列
            task2.fork();

            return task1.join()+task2.join();

        }
    }
}

public class Test {
    
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
        test2();
    }

    // 普通程序员
    public static void test1(){
    
    
        long sum = 0L;
        long start = System.currentTimeMillis();
        for (long i = 1; i <= 1000000000; i++) {
    
    
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }

    public static void test2() throws ExecutionException, InterruptedException {
    
    
        long start = System.currentTimeMillis();
        /*
        *   ForkJoinPool的invoke、execute、submit
        *   execute(ForkJoinTask) 异步执行tasks，无返回值
        *   submit(ForkJoinTask) 异步执行，且带Task返回值，可通过task.get 实现同步到主线程
        *   invoke(ForkJoinTask) 主线程等待ForkJoinTask执行完毕 个人理解
        * */
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> forkJoinDemo = new ForkJoinDemo(0L, 1000000000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(forkJoinDemo);
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }

    public static void test3(){
    
    
        long start = System.currentTimeMillis();
        // Stream并行流
        LongStream.rangeClosed(0L,1000000000L).parallel().reduce(0,Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+" 时间："+(end-start));
    }
}