线程池理解 与 stream流的测试

1.线程池

package com.tigeriot.reportconfiguration.api.cloudplatform.reportconfiguration.datasetproperties.realtime.heatstation;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Excuete {
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ThreadPoolExecutor executorService = new ThreadPoolExecutor(
                2,
                6,
                10000,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3)
        );

        ArrayList<Future<Integer>> futures = new ArrayList<>();
        for (int i = 0; i < 8; i++) {

            int finalI = i;

            Callable<Integer> callable = new Callable<>() {
                @Override
                public Integer call() throws Exception {
                    TimeUnit.SECONDS.sleep(1L);
                    System.out.println(finalI);
                    return finalI;
                }
            };

            //拒绝策略是往外抛的,影响主线程,但不会影响其他的线程执行,最大就是五个而不是加起来7个
            Future<Integer> submit = executorService.submit(callable);

            futures.add(submit);
        }
//        executorService.shutdownNow();//这个是直接将任务取消，不会执行
        executorService.shutdownNow();

        //优先使用 核心线程去执行任务
        //这个不会取消已经提交的任务,以及队列
        // ,会释放多余的线程对象,当阻塞队列里面存在任务的时候，线程池会先释放空闲的线程，
        // 保留正在运行的线程，队列也是，然后，一个任务执行完毕，队列就会弹出队首，进入一个空闲线程执行，
        // 直到队列里的任务执行完，然后一个线程执行完，就直接释放这个线程，然后就可以给JVM做垃圾回收了。
        for (Future<Integer> future : futures) {
            //全部取消了
//            Integer integer = future.get();
//            System.out.println(integer);
        }
        System.out.println("执行");

        executorService.shutdown();

    }
}

2.stream流的测试

package com.tigeriot.reportconfiguration.api.cloudplatform.reportconfiguration.datasetproperties.realtime.heatstation;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.stream.Collectors;

public class ListTest {
    public static void main(String[] args) {

        ArrayList<Integer> integers = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            integers.add(i);
        }
//
//        Integer reduce = integers.parallelStream().reduce(0, new BiFunction<Integer, Integer, Integer>() {
//            @Override
//            public Integer apply(Integer integer, Integer integer2) {
//                System.out.println("b i1="+integer);
//                System.out.println("b i2="+integer2);
//                return integer + integer2;
//            }
//        }, new BinaryOperator<Integer>() {
//            @Override
//            public Integer apply(Integer integer, Integer integer2) {
//                System.out.println("执行了吗");
//                System.out.println(" i1="+integer);
//                System.out.println(" i2="+integer2);
//                return integer+integer2;
//            }
//        });
//
//        Integer reduce = integers.parallelStream().reduce(0, new BinaryOperator<Integer>() {
//            @Override
//            public Integer apply(Integer integer, Integer integer2) {
//                System.out.println("执行了吗");
//                System.out.println(" i1="+integer);
//                System.out.println(" i2="+integer2);
//                return integer+integer2;
//            }
//        });
//        System.out.println(reduce);

        //从第一个元素判断如果满足，则删除，知道遇到不满足，就停止，剩下元素则保留
//        List<Integer> collect = integers.stream().dropWhile(a -> a==0).collect(Collectors.toList());
//        System.out.println(collect);

        //所有不满足条件返回true,满足一个，则返回false
//        integers.stream().noneMatch()

        //takeWhile() 方法接受一个谓词（Predicate），并返回一个新的流，其中包含原始流中从开头开始满足给定谓词的所有元素。一旦遇到第一个不满足条件的元素，takeWhile() 就会立即停止处理，并返回由满足条件的元素组成的新流。
        System.out.println(integers.stream().takeWhile(a -> a < 5).collect(Collectors.toList()));
    }
}