线程池与Lambda表达式

一、线程池

概述：

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？------线程池

线程池概念

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

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

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

线程池的使用

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

线程池JDK1.5之后提供的

java.util.concurrent. Executors：线程池的工厂类，用来生成线程池

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

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

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

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

Executors类的静态方法：

static ExecutorService  newFixedThreadPool(int nThreads)：创建一个可重用固定线程数的线程池

参数：int nThreads：创建线程池中包含的线程数量

返回值：ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收

java.util.concurrent.ExecutorService：线程池接口

用来从线程池中获取线程，调用start方法，执行线程任务
submit(Runnable task)：提交一个Runnable任务用于执行
关闭/销毁线程池的方法：void shuntdown() （不常用）
 

线程池的使用步骤：

1、使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2、创建一个类，实现Runnable接口，重写run方法，设置线程任务
3、调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
4、调用ExecutorService中的方法shuntdown销毁线程池（不建议执行）

package com.itheima_01;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo01ThreadPool {
    public static void main(String[] args) {
        //1使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);

        //3调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
        es.submit(new RunnableImpl());//pool-1-thread-2haha
        es.submit(new RunnableImpl());//pool-1-thread-1haha
        es.submit(new RunnableImpl());//pool-1-thread-2haha


    }
}

package com.itheima_01;

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"haha");
    }
}

二、Lambda表达式

2.1函数式编程思想

面向对象的编程思想：找一个能解决这个事情的对象，调用对象的方法，完成事情。

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

2.2冗余的Runnable代码

package com.itheima.Lambda;
/*用Lambda简化之前的实现Runnable接口的方式来创建线程的代码*/
public class Demo01Lambda {
    public static void main(String[] args) {
        /*new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "创建了一个新线程");
            }
        }).start();*/
        new Thread(()-> {
                System.out.println(Thread.currentThread().getName() + "创建了一个新线程");
            }
        ).start();

    }
}

代码分析

对于Runnable的匿名内部类用法，可以分析出几点内容：

• Thread类需要Runnable接口作为参数，其中的抽象run方法是用来指定线程任务内容的核心；
• 为了指定run的方法体，不得不需要Runnable接口的实现类；
• 为了省去定义一个RunnableImpl实现类的麻烦，不得不使用匿名内部类；
• 必须覆盖重写抽象run方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
• 而实际上，似乎只有方法体才是关键所在。

2.3Lambda标准格式

由三部分组成：
		1、一些参数		2、一个箭头		3、一段代码

格式：

(参数列表) - > {一些重写方法的代码}

解释说明格式：

():接口中抽象方法的参数列表，没有参数就空着；有参数就写出参数，多个参数使用逗号分隔
->:传递的意思，把参数传递给方法体{}
{}:重写接口的抽象方法的方法体

2.4Lambda表达式的无参数无返回值练习

题目

给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。如下：

package com.itheima.demo04.Lambda;

public class Demo01Cook {
    public static void main(String[] args) {
        //传统方法
        //调用invokeCook方法，参数是Cook接口，传递Cook接口的匿名内部类
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("该吃饭了");
            }
        });

        //使用Lambda表达式,
        //注意有没有参数看的是要重写的方法里的有没有参数
        invokeCook(()->{
            System.out.println("该吃饭了11");
        });

    }
    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

package com.itheima.demo04.Lambda;

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

备注：小括号代表Cook接口makeFood抽象方法的参数为空，大括号代表makeFood的方法体。

2.5Lambda表达式的有参数无返回值练习

需求:
    使用数组存储多个Person对象
    对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

代码演示：

package com.itheima.demo05.Lambda;

import java.util.Arrays;
import java.util.Comparator;

public class Demo01Person {
    public static void main(String[] args) {
        //使用数组存储多个person对象
        Person[] arr={
                new Person("昊昊",10),
                new Person("浩浩",20),
                new Person("豪豪",8)

        };
        //传统方法
        //对数组中的Person对象使用Arrays的sort方法通过年龄进行升序
        /*Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });*/
        //使用Lambda表达式
        Arrays.sort(arr,(Person o1, Person o2)->{
            return o1.getAge()-o2.getAge();
        });

        //对数组遍历输出
        for (Person person : arr) {
            System.out.println(person);
        }

    }
}

代码分析

下面我们来搞清楚上述代码真正要做什么事情。

• 为了排序，Arrays.sort方法需要排序规则，即Comparator接口的实例，抽象方法compare是关键；
• 为了指定compare的方法体，不得不需要Comparator接口的实现类；
• 为了省去定义一个ComparatorImpl实现类的麻烦，不得不使用匿名内部类；
• 必须覆盖重写抽象compare方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
• 实际上，只有参数和方法体才是关键。

知识点：创建对象数组：

对象名[] 数组名称={new 对象名（），new 对象名（），new 对象名（），	}

当需要对一个对象数组进行排序时，Arrays.sort方法需要一个Comparator接口实例来指定排序的规则.

排序：
使用Comparator

Comparator<Person> comp = new Comparator<Person>({
				@Override
				public int compare(Person o1, Person o2) {
				return o1.getAge() ‐ o2.getAge();
			}
		};
升序是参数1-参数2，降序是参数2-参数1.
记得使用Arrays.sort(array, comp);进行排序，然后遍历数组即可

2.6Lambda表达式的有参数有返回值练习

题目

给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值：

package com.itheima.demo04.Lambda;

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

package com.itheima.demo04.Lambda;

public class Demo02InvokeCal {
    public static void main(String[] args) {
        //传统方法
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });
        //Lambda
        invokeCalc(10,30,(int a,int b)->{
            return a+b;
        });

    }
    public static void invokeCalc(int a,int b,Calculator calculator){
        int result = calculator.calc(a, b);
        System.out.println("result:"+result);
    }
}

备注：小括号代表Calculator接口calc抽象方法的参数，大括号代表calc的方法体。

2.7Lambda表达式的省略

Lambda表达式是可推导的，可以省略。凡是可以根据上下文推导出来的内容，都可以省略书写，可推导即可省略

可以省略的内容：

1、(参数列表)：括号中参数列表的数据类型，可以省略不写
2、(参数列表)：括号中的参数如果只有一个，那么类型和()都可以省略
3、{一些代码}：如果{}中的代码只有一行，无论是否有返回值，都可以省略{}、return、分号
注意：要省略{}、return、分号必须一起省略

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

2.8练习：使用Lambda省略格式

上述代码的优化：

//未优化的lambda表达式
new Thread(()-> {
                System.out.println(Thread.currentThread().getName() + "创建了一个新线程");
            }
        ).start();
 //优化Lambda表达式，省略大括号和分号（因为没有参数所以不考虑参数）
  new Thread(()->System.out.println(Thread.currentThread().getName() + "创建了一个新线程")).start();

//未优化的lambda表达式
        Arrays.sort(arr,(Person o1, Person o2)->{
            return o1.getAge()-o2.getAge();
        });

        //优化Lambda表达式，只有一行语句，省略参数数据类型，大括号和return及分号
        Arrays.sort(arr,( o1, o2)->o1.getAge()-o2.getAge());

//未优化的lambda表达式
        invokeCalc(10,30,(int a,int b)->{
            return a+b;
        });

   //优化Lambda表达式，只有一行语句，省略参数数据类型，大括号和return及分号
        invokeCalc(10,30,( a, b)->a+b);

//未优化的lambda表达式
        //注意有没有参数看的是要重写的方法里的有没有参数
        invokeCook(()->{
            System.out.println("该吃饭了11");
        });

        //优化Lambda表达式，省略大括号和分号（因为没有参数所以不考虑参数）
        invokeCook(()-> System.out.println("该吃饭了11"));