线程池和Lambad表达式

第一章 等待唤醒机制

1.1 线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同

为什么要处理线程间通信：

多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即–等待唤醒机制

1.2 等待唤醒机制

什么是等待唤醒机制

这是多个线程间的一种协作机制。谈到线程会经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制

就是在一个线程进行了规定操作后，就进入等待状态（wait()），等待其他线程执行完他们指定的代码过后再将其唤醒（notify()）；在多个线程进行等待时，如果需要，可以使用notifyAll()来唤醒所有的等待线程

wait/notify就是线程间的一种协作机制

等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题，使用到的3个方法的含义如下：

1、wait：线程不在激活，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁了，这时的线程状态即是WAITTING。它还要等着别的线程执行一个特别的动作，也就是“通知（notify）”在这个对象等待的线程wait set中释放出来，重新进入到调度队列（ready queue）中

2、notify：选取所通知对象的wait set中的一个线程释放

3、notifyAll：释放所通知对象的wait set上的全部线程

总结如下：

​ · 如果能获取锁，线程就从WAITTING状态变成RUNNABLE状态；

​ · 否则，从wait set出来，又进入entry set，线程就从WAITTING状态又变成了BLOCKED状态

调用wait和notify方法需要注意的细节

1、wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程

2、wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意的，而任意对象的所属类型都是继承了Object类的

3、wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法

1.3 生产者与消费者问题

等待唤醒机制其实就是经典的“生产者与消费者”的问题

/**
 * 资源类：包子类
 * 设置包子的属性
 *  皮
 *  陷
 *  包子的状态：有 true    没有  false
*/
public class BaoZi {
    //皮
    String pi;
    //陷
    String xian;
    //包子的状态：有   true，没有 false ，设置初始值为false没有包子
    boolean flag = false;
}

public class BaoZiPu extends Thread {
    //需要在成员位置创建一个包子变量

    priv ;
    //使用带参数构造方法，为这个包子变量赋值

    public BaoZiPu(BaoZi bz) {
        this.bz = bz;
    }
    //设置线程任务(重写run方法)

    @Override
    public void run() {
        //定义一个变量
        int count = 0;

        while (true){
            //必须使用同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                //对包子的状态进行判断
                if (bz.flag==true){
                    //包子铺调用wait方法进入到等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行，包子铺生产包子
                //增加一些趣味性，交替生产两种包子
                if (count%2==0){
                    //生产    薄皮三鲜陷包子
                    bz.pi="薄皮";
                    bz.xian="三鲜陷";
                }else {
                    //生产    冰皮 牛肉大葱陷
                    bz.pi="冰皮";
                    bz.xian="牛肉大葱陷";
                }
                count++;
                System.out.println("包子铺正在生产："+bz.pi+bz.xian+"包子");

                //生产包子需要3秒钟
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好了包子
                //修改包子的状态为true有
                bz.flag = true;

                //唤醒吃货线程，让吃货线程吃包子
                bz.notify();

                System.out.println("包子铺已经生产好了："+bz.pi+bz.xian+"包子，吃货可以开始干了");

            }
        }
    }
}

public class ChiHuo extends Thread {
    private BaoZi bz;

    public ChiHuo(BaoZi bz){
        this.bz=bz;
    }

    @Override
    public void run() {
        while (true){
            synchronized (bz){
                if (bz.flag==false){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //线程被唤醒之后执行的代码，吃包子
                System.out.println("正在吃："+bz.pi+bz.xian+"包子");

                //吃完后修改包子的状态  false
                bz.flag = false;

                //吃完后唤醒包子铺继续生产包子
                bz.notify();

                System.out.println("已经把"+bz.pi+bz.xian+"包子吃完了，包子铺开始生产包子");

                System.out.println("================");
            }
        }

    }
}

/**
 * 测试类：
 * 包含main方法，程序执行的入口，启动程序
 * 创建包子对象
 * 创建包子铺线程，开启生产包子
 * 创建吃货线程，开启吃包子
*/
public class Demo {
    public static void main(String[] args) {
        //1、创建包子对象
        BaoZi bz = new BaoZi();
        //2、创建包子铺线程，开启生产包子
        new BaoZiPu(bz).start();
        //3、创建吃货线程，开启吃包子
        new ChiHuo(bz).start();

    }
}

第二章 线程池

2.1 线程池思想概述

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

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

那么有没有一种办法使得线程可以复用，执行完一个任务并不被销毁，而是可以继续执行其他任务？在Java中可以通过线程池来达到这样的效果。

2.2 线程池概念

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

线程池：容器–>集合（Arraylist,HashSet,LinkedList,HashMap）

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

1、降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务

2、提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行

3、提高线程的可管理性。可以根据系统的管理能力，调整线程池中工作线程的数目，防止因为消耗过多的内存，而把服务器累趴下（每个线程需要大约1MB内存，线程开的越多，消耗的内存也越大，最后死机）

2.3 线程池的使用

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

要配置一个线程池是比较复杂的，尤其是对线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.current.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

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

· public static ExecutorService newFixedThreadPool(int nThreads):返回线程池对象（创建的是有界线程池，也就是线程池的线程个数可以指定最大数量）

参数：

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

返回值：

​ ExecutorService接口，返回的是ExecutorService接口实现类的对象，我们可以使用ExecutorService接口接收（面向接口变成）

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

使用线程池中线程对象的步骤：

1、使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池

2、创建一个类，实现Runnable接口，重写run方法，设置线程任务

3、调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法

4、调用ExecutorService中的shutdown销毁线程池（不建议执行）

代码演示：

public class Demo01ThreadPool {
    public static void main(String[] args) {
        //返回值类型是ExecutorService接口，所以用ExecutorService接收，获取的是对象，对象是接口类型
        ExecutorService es = Executors.newFixedThreadPool(2);

        //调用submit传递线程任务（实现类），开启线程执行run方法
        es.submit(new RunbableImpl());
        es.submit(new RunbableImpl());
        //线程池会一直开启，使用完了线程，会自动把线程归还给线程池，线程池可以继续使用
    }
}

第三章 Lambad表达式

3.1 函数编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数思想则尽量忽略面向对象的复杂语法----强调做什么，而不是以什么形式做

面向对象思想：

​ 做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情

函数式编程思想：

​ 只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程

3.2 体验Lambad的更优写法

代码演示：

public class Demo02Lambda {
    public static void main(String[] args) {
        //使用匿名内部类的方式，实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程创建了");
            }
        }).start();

        //使用Lambad表达式，实现多线程
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"线程创建了");
        }
        ).start();
    }
}

3.3 回顾匿名内部类

匿名内部类的好处与弊端

一方面，匿名内部类可以帮我们省去实现类的定义；另一个方面，匿名内部类的语法----确实太复杂

语义分析

public abstract void run();

即制定了一种做事情的方案（其实就是一个函数）：

· 无参数：不需要任何条件即可执行该方案

· 无返回值：该方案不产生任何结果

· 代码块（方法体）：该方法的具体执行步骤

同样的语义体现在Lambad语法中，更加简单：

()->System.out.println("多线程任务执行！！")

· 前面的一对小括号即run方法的参数（无），代表不需要任何条件；

· 中间的箭头代表将前面的参数传递给后面的代码；

· 后面的输出语句即业务逻辑代码

3.4 Lambad标准格式

Lambad省去面向对象的条条框框，格式由3个部分组成：

· 一些参数

· 一个箭头

· 一段代码

Lambad表达式的标准格式：

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

格式说明：

· （）小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔

· ->是新引入的语法格式，代表指向动作，传递的意思，把参数传递给方法体{}

· {}大括号内的语法与传统方法体要求基本一致，重写接口的抽象方法的方法体

3.5 练习：使用Lambad标准格式（无参无返回）

/**
 * 给定一个厨子接口，内含唯一的抽象方法makeFood,且无参数无返回值。
 * 使用Lambad的标准格式调用invokeCook方法，打印输出“吃饭了”字样
*/
public class Demo01Cook {
    public static void main(String[] args) {
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });

        //使用Lambad表达式，简化匿名内部类的书写
        invokeCook(()->{
            System.out.println("吃饭了");
        });

    }
    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood

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

3.6 练习：使用Lambad标准格式（有参有返回）

/**
 * Lambad表达式有参数有返回值的练习
 * 需求：
 * 使用数组存储多个Person对象
 * 对数组中的Person对象使用Arrays中的sort方法通过年龄进行升序排序
*/
public class Demo01Array {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person [] arr ={
                new Person("张三",20),
                new Person("李四",21),
                new Person("王五",18),
        };

        //对数组中的Person对象使用Arrays的sort方法，通过年龄进行升序（前边-后边）排序
//        Arrays.sort(arr, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });

        //使用Lambad表达式，简化匿名内部类

        Arrays.sort(arr,(Person o1,Person o2)->{
            return o1.getAge()-o2.getAge();
        });
        //遍历数组
        for (Person p:arr){
            System.out.println(p);
        }
    }
}

/**
 * Lambad表达式有参数有返回值的练习
 * 需求：
 *      给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到价值
 *      使用Lambad标准格式调用invokeCalc方法，完成120和130的相加计算
*/
public class Demo01Calculator {
    public static void main(String[] args) {
        invokeCalc(120, 130, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });


        //使用Lambad表达式
        invokeCalc(120,130,(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);
    }
}

3.7 Lambad省略格式

可推导即可省略

Lambad强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。例如上述还可以使用Lambad的省略写法：

public static void main(String[] args){

​ invokeCalc(120,130,(a+b) -> a+b);

}

省略规则

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

1、（）小括号内参数的类型可以省略

2、如果小括号内有且仅有一个参，则小括号可以省略

3、如果大括号内有且仅有一个语句，无论是否有返回值，都可以省略大括号，return关键字及语句分号。注意：要省略{}，return，分号必须一起省略

3.8 Lambad的使用前提

Lambad的语法非常简单，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

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

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

2、使用Lambad必须具有上下文推断

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