菜鸡学习day18_线程池&Lambda表达式

菜鸡学习day18

package day18;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
等待唤醒机制
线程间通信
多个线程处理同一个资源

线程池
Executors线程池的工厂类
静态方法
static ExecutorService newFixedThreadPool(int nThread)创建固定线程数的线程池
返回值是ExecutorService接口的实现类对象
ExecutorService接口用来从线程池中获取线程，调用start方法执行线程任务

线程池使用步骤
1.使用FixedThreadPool方法创建线程池
2.创建一个类，实现ExecutorService接口，重写run方法
3.调用ExecutorService中的方法submit，传递线程任务，开启线程，执行run
4.调用ExecutorService中的方法shutdown销毁线程池（X）

Lambda表达式
函数式编程思想
强调做什么，重视的是结果而非过程
（参数）->{run代码}
参数+箭头+{run代码}

Lambda表达式省略格式
可推导可省略（凡是可根据上下文推导的内容，都可以省略）
1.参数列表的数据类型
2.参数列表的单个参数，的类型和（）
3.代码如果只有一行，无论是否有返回值，都可以省略{}，return，分号
        （必须一起省略）
 */

public class D1801 {
    public static void main(String[] args) {
        //xxx();
        //xianChengChi01();
        //lianXi01();
        //lianXi02();
        lianXi03();
    }

    private static void xxx(){
        ZiYuan baozi = new ZiYuan();
        new Shengchan(baozi).start();
        new Xiaofei(baozi).start();
    }

    private static void xianChengChi01(){
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        executorService.submit(new RunnableImpl());
        executorService.submit(new RunnableImpl());
        executorService.submit(new RunnableImpl());

    }

    private static void lianXi01(){//无参无返回
        /*Cook cook = new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了！");
            }
        };
        */
        //lambda表达式重写
        invokeCook(()->{
            System.out.println("吃饭了！");
        });
    }

    private static void invokeCook(Cook cook){
        cook.makeFood();
    }

    private static void lianXi02(){
        Person person1 = new Person("小明",20);
        Person person2 = new Person("小红",12);
        Person person3 = new Person("小周",17);

        Person[] array = {person1,person2,person3};

        Arrays.sort(array,(Person o1,Person o2)->{
            return o1.getAge() - o2.getAge();
        });
        System.out.println(Arrays.toString(array));
    }

    private static void lianXi03(){
        invokeCalc(1,2,(int a,int b)->{
            return a + b;
        });
    }

    private static void invokeCalc(int a,int b,Calculator c){
        int sum = c.calc(a,b);
        System.out.println(sum);
    }
}

package day18;

public interface Calculator {
    public abstract int calc(int a,int b);
}

package day18;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package day18;

public interface Cook {
    public abstract void makeFood();
}

package day18;

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println("执行线程任务" + Thread.currentThread().getName());
    }
}