本文共 12574 字，大约阅读时间需要 41 分钟。

上一篇博客：

目录

• 等待唤醒机制
  • 线程间通信
  • 等待唤醒机制
  • 生产者与消费者
• 线程池
  • 线程池思想概述
  • 线程池概念
  • 线程池的使用
• Lambda表达式
  • 函数式编程思想概述
  • 冗余的Runnable代码写法
  • 编程思想转换
  • Lambda更优写法
  • 回顾匿名内部类
  • Lambda标准格式
  • 练习：使用Lambda标准格式（无参无返回值）
  • Lambda参数和返回值
  • 练习：使用Lambda标准格式（有参与有返回值）
  • Lambda省略格式
  • 练习：使用Lambda省略格式
  • Lambda的使用前提

开始

一、等待唤醒机制

1.1线程间通信

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

比如：线程A是产生包子的，线程B是来吃包子的，包子可以理解为同一资源

线程A与线程B的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题

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

多个线程并发执行时，在默认情况下CPU是随机切换线程的，多线程完成一个任务，并且希望他们有规律的执行

那么线程之间需要一些协调通信，以此来帮助我们达到多线程共同操作一份数据

前面的卖电影票的栗子，吃包子的栗子都是线程间通信的栗子

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

多线程处理一个资源，并且任务不同，需要线程通信来帮助解决线程之间对同一个变量的使用、操作

就是避免多个线程对同一共享变量的争夺

也就是我们通过一定的手段来使个个线程能有效利用资源----》等待唤醒机制

1.2等待唤醒机制

什么是等待唤醒机制

多个线程之间协作的一种机制

线程之间有竞争，争夺锁，同时也有协作

就是在一个线程完成了规定的操作之后，就进入等待状态wait(),等待其他线程执行完他们的指定代码，再将其唤醒notify()

在有多个线程进行等待时，如果需要，可以使用notifyAll（）来唤醒所有的等待线程

等待唤醒中的方法

1. wait:线程不在活动不在参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁，WAITING状态，等待其他线程的notify通知，在这个对象等待的线程从wait set中释放出来，重新进入到调度队列中
2. notify:通知一个wait set中的线程重新进入调度队列中
3. notifyAll:释放所通知对象的wait set 上的全部线程

注意

通知一个等待的线程，被通知的线程也不能马上恢复执行，此时不再持有锁，可能需要和其他线程竞争锁之后才能从当初调用wait 方法之后的地方恢复执行

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

1. wait方法和notify方法必须要有同一个锁对象调用
2. wait方法和notify方法是属于Objects类的方法，因为锁对象可以是任意对象，而任意对象所属类都是继承Object类的
3. wait方法和notify方法必须要在同步代码块或者同步函数中使用，因为必须要有锁对象调用这两个方法

1.3生产者与消费者

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

举栗

包子铺线程生产包子，吃货线程消费包子

当包子没有时（包子状态为false），吃货线程等待

包子铺生产包子（包子状态为true），并通知吃货线程（解除吃货的等待状态）

因为已经有包子了，包子铺线程处于等待状态

接下来，吃货线程能否进一步执行取决于锁的获取状态，如果吃货线程获取到锁，那么就执行吃包子动作，包子吃完包子状态为false，并通知包子铺线程解除等待状态，吃货线程继续进入等待状态，包子铺线程能否继续执行，取决于锁的获取情况

总之锁就一个，谁取到谁执行，取不到者等待被唤醒

代码演示

BaoZi 类作为 BaoZiPu类和ChiHuo类的成员变量

BaoZi 类创建的对象bz为锁对象，包子铺类和吃货类必须使用一个锁对象

TestMain中创建吃货对象、包子铺对象，调用开启线程的方法

包子铺线程和吃货线程之间互相通信

package Demo_23;public class BaoZi {       String pier;    String xianer;    boolean flag = false;    //包子资源 是否存在}

package Demo_23;public class BaoZiPu extends Thread{       //包子对象做成员变量    private BaoZi bz;    //构造方法    public BaoZiPu(String name, BaoZi bz) {           super(name);        this.bz = bz;    }    @Override    public void run() {           //包子计数        int count = 0;        while(true){               //包子为锁对象            synchronized (bz){                   if(bz.flag == true){   //有包子，做包子的包子铺线程就进入等待状态                    try{                           bz.wait();                    } catch (InterruptedException e) {                           e.printStackTrace();                    }                }                //没有包子                System.out.println("包子铺开始做包子");                //包子的种类                if(count % 2 == 0){                       bz.pier = "冰皮";                    bz.xianer = "牛肉馅";                } else {                       bz.pier = "金皮";                    bz.xianer = "银馅";                }                //包子计数                count++;                //包子造好了                bz.flag = true;                System.out.println("包子造好了："+bz.pier+bz.xianer);                System.out.println("吃货来吃吧");                //唤醒 吃货等待线程                bz.notify();            }        }    }}package Demo_23;public class ChiHuo extends Thread {       //包子对象做成员变量    private BaoZi bz;    //构造方法    public ChiHuo(String name, BaoZi bz) {           super(name);        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.pier + bz.xianer + "包子");                //吃完包子，包子就没了                bz.flag = false;                //唤醒包子铺线程，                bz.notify();                            }        }    }}

package Demo_23;public class TestMain {       public static void main(String[] args) {           BaoZi bz = new BaoZi();        ChiHuo ch = new ChiHuo("xiaosi吃货",bz);        BaoZiPu bzp = new BaoZiPu("包子铺",bz);        ch.start();        bzp.start();    }}

二、线程池

2.1线程池概述

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

工作原理

任务排队从线程池中取出线程使用，没有抢到线程的任务需等待用完的线程返回到池子中再用

好处

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

2.2线程池的使用

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

真正线程池的接口是java.util.concurrent.ExecutorService

配置一个线程池是比较复杂的，尤其对于线程池的原理不是很清楚的情况，很有可能配置的线程池不是最优的

Excurtors线程工厂提供了一些静态工厂，生成一些常用的线程池，官方建议使用Executor工程类来创建线程池对象

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

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

获取到一个线程池 ExecutorService 对象，使用线程池对象的方法：

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

  Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

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

1. 创建线程池对象
2. 创建Runnable接口的子类对象（task）
3. 提交Runnable接口子类对象（task）
4. 关闭线程池（一般不做）

举栗

package Demo_23;public class MyRUnnable implements Runnable {       @Override    public void run() {           System.out.println("我需要一辆车");        try{               Thread.sleep(2000);        } catch (InterruptedException e) {               e.printStackTrace();        }        System.out.println("车来了 "+ Thread.currentThread().getName());        System.out.println("等我开完后，把车送回去~~");    }}package Demo_23;import Demo_23.MyRUnnable;import java.util.concurrent.Executor;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class TestMain_MyRunnable {       public static void main(String[] args) {           //创建包含两个线程的线程池        ExecutorService es = Executors.newFixedThreadPool(2);        MyRUnnable mr = new MyRUnnable();        //Thread t = new Thread(mr);        //t.start();        es.submit(mr);        es.submit(mr);        es.submit(mr);    }}

三、Lambda表达式

3.1函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是"拿什么东西做什么事情"

相对而言，面向对象过分强调"必须通过对象的形式做事"

而函数式思想则是 尽量忽略面向对象的复杂语法—》强调做什么，而不是以什么形式做

• 面向对象的思想—》找一个对象，使用对象的方法完成事情
• 函数式编程思想—》只要能获取结果，谁去做，怎么做都不重要，重视的是结果，不重视过程

3.2冗余的Runnable代码写法

传统写法

当需要启动一个线程去完成任务，通常会通过java.lang.Runnable接口来定义任务内容，并使用java.lang.Thread类来传入MyRunnable对象，启动线程

package Demo_23;public class Runnable_01 {       public static void main(String[] args) {           Runnable r = new Runnable() {               @Override            public void run() {                   System.out.println("多线程任务1");            }        };        new Thread(r).start();        //或者可以        new Thread(new Runnable() {               @Override            public void run() {                   System.out.println("匿名内部类实现多线程");            }        }).start();    }}

一切皆对象，我们不得不创建对象来开启线程

代码分析

对于Runnable的匿名内部类用法

• Thread类需要Runnable接口作为参数，其中的抽象run方法用来指定线程任务内容的核心
• 不得不创建MyRunnable对象来重写run方法
• 不得不创建Thread对象接受MyRunnable对象参数
• 不得不重新把run方法重写一遍

3.3编程思想转换

我们并不是希望创建对象，只是开启多线程需要创建对象

我们希望：将run（）方法体内的代码传递给Thread类

传递一段代码才是我们的目的

2014年3月Oracle发布的Java 8 (JDK 1.8)中，加入了Lambda表达式 新特性，打开新世界的大门

3.4Lambda更优写法

package Demo_23;public class Lambda_01 {       public static void main(String[] args) {           new Thread( ()->System.out.println("多线程任务开启")).start();    }}

多线程任务被一种更简洁的形式指定，不在有 不得不创建接口对象的束缚、抽象方法覆盖重写的负担

3.5回顾匿名内部类

()->System.out.println("多线程任务开启")

上面简单代码替代使用匿名内部类实现

使用匿名内部类

• 一方面匿名内部类相比在Main外单独创建实现类文件 省去了实现类的定义
• 一方面匿名内部类的语法 确实太复杂了

语义分析

run()方法----》run函数

• 无参数：不需要任何条件就可执行该方案
• 无返回值：该方案不产生任何结果
• 代码块（方法体）：该方案的具体执行步骤

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

• 前面一堆小括号即run方法的参数（无），代表不需要任何条件
• 中间的一个箭头代表将前面的参数传递给后面的代码
• 后面的输出语句即为业务逻辑代码、线程任务代码

3.6Lambda标准格式

省去面向对象的条条框框，格式由3个部分组成
(参数类型 参数名称) -> { 代码语句 }

• 一些参数
• 一个箭头
• 线程任务代码

格式说明：

• 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
• ->是新引入的语法格式，代表指向动作。
• 大括号内的语法与传统方法体要求基本一致。

3.7练习：使用Lambda标准格式（无参无返回值）

package Demo_23;//给定一个厨子`Cook`接口，内含唯一的抽象方法`makeFood`，// 且无参数、无返回值。如下：public interface Lambda_03_Cook {       void makeFood();}package Demo_23;public class Lambda_03 {       public static void main(String[] args) {           //在下面的代码中，请使用Lambda的**标准格式**调用        // `invokeCook`方法，打印输出“吃饭啦！”字样：       invokeCook(() -> {    System.out.println("饭好了！");});       //备注：小括号代表`Cook`接口`makeFood`抽象方法的参数为空        // 大括号代表`makeFood`的方法体。    }    private static void invokeCook(Lambda_03_Cook cook) {           cook.makeFood();    }}

3.8Lambda参数和返回值

• 需求
  使用数组存储多个Person对象
  对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序—》Comparator接口抽象方法
  public abstract int compare(T o1, T o2);

传统写法

package Demo_23;public class Lambda_04_Person {       private String name;    private int age;    public Lambda_04_Person() {       }    public Lambda_04_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 "Lambda_04_Person{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }}package Demo_23;import Demo_17.Person;import java.util.Arrays;import java.util.Comparator;public class Lambda_04_TestMain {       //传统写法    public static void main(String[] args) {           //对象数组        Lambda_04_Person[] array = {                   new Lambda_04_Person("古力娜扎",18),                new Lambda_04_Person("迪丽热巴",17),                new Lambda_04_Person("马尔扎哈",20)        };        //匿名内部类        Comparator<Lambda_04_Person> comp = new Comparator<Lambda_04_Person>() {               @Override            public int compare(Lambda_04_Person o1, Lambda_04_Person o2) {                   //return 0;                return o1.getAge() - o2.getAge();                //前面大于后面年龄规则            }        };        Arrays.sort(array,comp);        for (Lambda_04_Person lambda_04_person : array) {               System.out.println(lambda_04_person);        }    }}

代码分析

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

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

Lambda写法

package Demo_23;import Demo_17.Person;import java.util.Comparator;import java.util.Arrays;public class Lambda_04_LambdaTest{       public static void main(String[] args) {           //对象数组        Lambda_04_Person[] array = {                   new Lambda_04_Person("古力娜扎", 18),                new Lambda_04_Person("迪丽热巴", 17),                new Lambda_04_Person("马尔扎哈", 20)};        Arrays.sort(array,(Lambda_04_Person a,Lambda_04_Person b) -> {               return a.getAge() - b.getAge();        });        for (Lambda_04_Person lambda_04_person : array) {               System.out.println(lambda_04_person);        }    }}

3.9练习：使用Lambda标准格式（有参与有返回值）

package Demo_23;public interface Lambda_02_Calculator {       //给定一个计算器`Calculator`接口，内含抽象方法`calc`    // 可以将两个int数字相加得到和值：    int calc(int a,int b);}package Demo_23;public class Lambda_02 {       public static void main(String[] args) {           invokeCalc(120,130,(int a,int b) -> {   return a+b;} );        //备注：小括号代表`Cook`接口`makeFood`抽象方法的参数为空，        // 大括号代表`makeFood`的方法体。    }    //在下面的代码中，请使用Lambda的**标准格式**调用    // `invokeCalc`方法，完成120和130的相加计    private static void invokeCalc(int a,int b ,Lambda_02_Calculator calculator){           int result = calculator.calc(a,b);        System.out.println("结果是：" + result);//250    }}

3.10Lambda省略格式

可推导即可省略

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

public static void main(String[] args) {     	invokeCalc(120, 130, (a, b) -> a + b);}

省略规则

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

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

3.11练习：使用Lambda省略格式

要求

仍然使用前文含有唯一makeFood抽象方法的厨子Cook接口，在下面的代码中，请使用Lambda的省略格式调用invokeCook方法，打印输出“吃饭啦！”字样：

package Demo_23;public class Lambda_03 {       public static void main(String[] args) {           //在下面的代码中，请使用Lambda的**标准格式**调用        // `invokeCook`方法，打印输出“吃饭啦！”字样：       invokeCook(() -> {    System.out.println("饭好了！");});       //备注：小括号代表`Cook`接口`makeFood`抽象方法的参数为空        // 大括号代表`makeFood`的方法体。        //省略格式        //如果大括号内**有且仅有一个语句**，则无论是否有返回值，        // 都可以省略大括号、return关键字及语句分号        invokeCook(() -> System.out.println("开饭了"));    }    private static void invokeCook(Lambda_03_Cook cook) {           cook.makeFood();    }}

3.12Lambda的使用前提

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

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
   无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2. 使用Lambda必须具有上下文推断。
   也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

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

参考：B站黑马