1.CPU密集型和IO密集型

在创建线程池的时候，我们已经知道建议通过ThreadPoolExecutor进行参数设置，可以避免OOM，并且自定义嘛（通常就比较人性化的意思，想咋设置就咋设置），但是最大线程数应该怎么设置呢？（太自由了，就会有自由惹的祸。。。）这里设置的策略通常有两种CPU密集型和IO密集型。调优

1.1 CPU密集型

是根据电脑的核数来设置的（跟性能相关），可以根据Runtime.getRuntime().availableProcessors()进行设置本机的核数，将最大线程数设置为本机的核数；

1.2 IO密集型

是根据项目中十分消耗IO的线程进行设置，比如如果本项目又10个十分消耗IO的线程操作，我们一般会将线程池的最大线程数设置为这个数字的两倍，可以充分处理这些操作的情况下还有余力处理其他的线程。

2.函数式接口和断定型接口

2.1 函数式接口

函数式接口是只有一个方法的接口，是用@FunctionalInterface注解修饰的接口，可以简化编程模型，在新版本底层大量应用。

2.2 四大原生函数式接口

2.2.1 Function函数型接口

Function函数型接口的传入参数为T，返回值为参数R

public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

创建的匿名内部类如下代码，可以通过对象名.apply(传入参数)进行调用：

Function function = new Function<String,String>() {
    @Override
    public String apply(String str) {
        return str;
    }
};

因为函数式接口都可以通过lambda表达式进行优化（（参数）->{返回值}），上面代码可以优化为如下形式，变身~

Function function =(str)->{return str;};

继续优化，继续变身~

Function function = str -> str;

2.2.2 Predicate断定型接口

Predicate断定型接口是只有传入参数，只返回一个布尔值

public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

创建的匿名内部类如下代码，可以通过对象名.test(传入参数)进行调用：

Predicate<String> predicate = new Predicate<String>(){
    @Override
    public boolean test(String str) {
        return str.isEmpty();
    }
};

通过lambda表达式进行优化（（参数）->{返回值}），上面代码可以优化为如下形式，变身~

Predicate<String> predicate = (str)->{return str.isEmpty();};

继续优化，继续变身~

Predicate<String> predicate = str -> str.isEmpty();

这样看来参数也有点多余的感觉，省略参数直接使用方法再试试，使用（函数式接口 变量名 = 类实例::方法名）用这样的方式对该方法进行引用再继续优化，再继续变身~

Predicate<String> predicate = String::isEmpty;

2.2.3 Consumer消费者型接口

Consumer消费者型接口只有一个传入参数，没有返回值，消费完了就完了呗~

public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

创建的匿名内部类如下代码，可以通过对象名.accept(传入参数)进行调用：

Consumer<String> consumer = new Consumer<String>() {
    @Override
    public void accept(String str) {
        System.out.println(str);
    }
};

通过lambda表达式进行优化（（参数）->{返回值}），上面代码可以优化为如下形式，变身~

Consumer<String> consumer = (str) ->{System.out.println(str);};

继续优化，继续变身~

Consumer<String> consumer = str ->  System.out.println(str);

再继续优化，再继续变身~

查看println方法的源码得知println是PrintStream类中的一个非静态方法， 因此按照方法引用的逻辑，它可以使用这样的格式：函数式接口 变量名 = 类实例::方法名 用这样的方式对该方法进行引用，其中System.out的作用就是来获取PrintStream类的一个类实例

Consumer<String> consumer = System.out::println;

2.2.4 Supplier供给型接口

Supplier供给型接口是一个没有参数，只有一个返回值T的接口（生产者）；

public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

创建的匿名内部类如下代码，可以通过对象名.get()进行调用：

Supplier<String> supplier = new Supplier<String>() {
    @Override
    public String get() {
        return "我是一个返回值";
    }
};

通过lambda表达式进行优化（（参数）->{返回值}），上面代码可以优化为如下形式，变身~

Supplier<String> supplier = ()->{return "我是一个返回值";};

继续优化，继续变身~

Supplier<String> supplier = ()->"我是一个返回值";