18.3 线程池的引入、概念与newFixedThreadPool、sumbit、shutdown方法、Lambda表达式

目录

线程池

线程池引入

线程池概念

线程池使用

列：线程池练习

Lambda表达式

Lambda标准格式

列：使用匿名类实现开启线程

列：Lambda无参数无返回值表达式练习

列：Lambda无参无返回值练习

列：Lambda有参有返回值表达式练习

列：计算两数相加

---

线程池

线程池引入

并发的线程多，所以线程频繁创建和销毁，这样大大降低系统的效率，所以可以使用线程池实现这种效果

线程池概念

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源

合理利用线程池能够带来三个好处：

• 1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
• 2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
• 3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

线程池使用

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。

Executors类中有个创建线程池的方法

public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线 程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象

public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行

列：线程池练习

public class RunnableImpl implements Runnable{
    int num=0;
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"\t线程----执行了"+num);
            num++;
        }
    }
}

public class Demo01ThreadPool {
    public static void main(String[] args) throws InterruptedException {
        //1 使用线程池的工厂类Executors里面提供的newFixedThreadPool()静态方法生产一个指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);//创建线程池对象线程池中最多有个三个线程
        executorService.submit(new RunnableImpl());//2 开启线程池
        executorService.submit(new RunnableImpl());
//        executorService.submit(new RunnableImpl());

        //3 等待5秒
        Thread.sleep(5000);
        //4 销毁线程池；
        executorService.shutdown();//关闭线程池
    }
}

结果：

 

Lambda表达式

面向对象的思想:做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.

函数式编程思想:只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程

 

Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成： 一些参数 、一个箭头、 一段代码

Lambda表达式的标准格式为

(参数类型 参数名称) ‐> { 代码语句 }

 Lambda表达式实现前提

       1. 使用 Lambda 必须具有接口，且要求 接口中有且仅有一个抽象方法 。

无论是 JDK 内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一

时，才可以使用 Lambda 。

       2. 使用 Lambda 必须具有 上下文推断 。

也就是方法的参数或局部变量类型必须为 Lambda 对应的接口类型，才能使用 Lambda 作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

列：使用匿名类实现开启线程

 

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

public class Demo01Runnable {
    public static void main(String[] args) {
        // 1使用线程的实现类开启线程
        RunnableImpl runnable = new RunnableImpl();
        Thread thread = new Thread(runnable,"线程a");
        thread.start();

        //2 匿名内部类
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "\t线程正在执行");
            }
        };
        Thread thread1 = new Thread(r,"线程b");
        thread1.start();

        //3
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "\t线程正在执行");
            }
        },"线程c").start();

    }
}

列：Lambda无参数无返回值表达式练习

public class Demo02Lambda {
    public static void main(String[] args) {
        //1 使用匿名内部类开启线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "\t线程正在执行");
            }
        }).start();

        //2 使用Lambda表达式,实现多线程
        new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "\t线程正在执行");
            }
        ).start();

        //3 优化省略Lambda
        new Thread(()-> System.out.println(Thread.currentThread().getName() + "\t线程正在执行")).start();
        new Thread(()-> System.out.println(Thread.currentThread().getName() + "\t线程正在执行"),"线程aaa").start();

    }
}

列：Lambda无参无返回值练习

创建接口

public interface Cook {
    void makeFood();
}

public class Demo01Cook {
    public static void main(String[] args) {
        //1 匿名类实现方法
        myMethod(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("厨子喜欢做早餐");
            }
        });

        //2 Lambda实现
        myMethod(() -> {
            System.out.println("厨子喜欢做午餐");
        });

        //3 Lambda优化省略
        myMethod(()-> System.out.println("厨子喜欢做晚餐"));
    }

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

列：Lambda有参有返回值表达式练习

创建Person类的JavaBean

public class Demo01Arrays {
    public static void main(String[] args) {
        //1 使用数组存储多个Person对象
        Person[] p = new Person[]{
                new Person("老赵", 16),
                new Person("老钱", 14),
                new Person("老孙", 18)
        };

        //2 对数组排序
        Arrays.sort(p, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        myPrintArr(p);
        //3 使用Lambda排序
        Arrays.sort(p, (o1, o2) -> {
            return o1.getAge() - o2.getAge();
        });
        myPrintArr(p);
        //4 使用优化的Lambda排序
        Arrays.sort(p, (a, b) -> a.getAge() - b.getAge());
        myPrintArr(p);
    }
//排序
    private static void myPrintArr(Person[] p) {
        for (Person person : p) {
            System.out.println(person);
        }
        System.out.println("-------------------");
    }
}

列：计算两数相加

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

public class Demo01Calculator {
    public static void main(String[] args) {
//      new Calculator() {
//          @Override
//          public int calc(int a, int b) {
//              return a+b;
//          }
//      };

        myMethod(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a + b;
            }
        });

        myMethod(10, 20, (a, b) -> a + b);
        myMethod(10, 20, (x, y) -> x + y);
    }

    public static void myMethod(int a, int b, Calculator c) {
        System.out.println(c.calc(a, b));
    }
}