java进阶 07

线程间通信

1.概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。比如线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个 是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
2.为什么要处理线程间通信：我们希望要多个线程有规律的共同完成一件任务, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。
3.如何保证线程间通信有效利用资源：我们需要通过一定的手段使各个线程能有效 的利用资源。而这种手段即—— 等待唤醒机制。

等待唤醒机制

1.等待唤醒机制是多个线程间的一种协作机制，就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。
2.wait/notify 就是线程间的一种协作机制。
3.等待唤醒中的方法：
（1) wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中.
(2) notify：选取所通知对象的 wait set 中的一个线程释放***；例如，餐馆有空位置后，等候就餐最久的顾客最先入座.
(3)notifyAll：释放所通知对象的 wait set 上的全部线程。
注:
（1）通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以需要*再次尝试去获取锁***（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。
（2）如果能获取锁，线程就从WAITING 状态变成 RUNNABLE 状态。
（3）否则，从 wait set 出来，又进入 entry set，线程就从WAITING 状态又变成 BLOCKED状态。
（4） wait方法与notify方法必须要由同一个锁对象调用***。
（5） wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继 承了Object类的。
（6）wait方法与notify方法必须要在同步代码块或者是同步函数中使用。

生产者与消费者问题

1.等待唤醒机制其实就是经典的“生产者与消费者”的问题。
2.举例：

包子铺线程生产包子，吃货线程消费包子。当包子没有时（包子状态为false），吃货线程等待，包子铺线程生产包子 （即包子状态为true），并通知吃货线程（解除吃货的等待状态）,因为已经有包子了，那么包子铺线程进入等待状态。 接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完（包 子状态为false），并通知包子铺线程（解除包子铺的等待状态）,吃货线程进入等待。包子铺线程能否进一步执行则取 决于锁的获取情况。

代码举例：
包子资源类：

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

吃货线程类：

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();
}
}
}
}

包子铺线程类：

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();
}
}
}
}

测试类：

public class Demo {
public static void main(String[] args) {
//等待唤醒案例
BaoZi bz = new BaoZi();
ChiHuo ch = new ChiHuo("吃货",bz);
BaoZiPu bzp = new BaoZiPu("包子铺",bz);
ch.start();
bzp.start();
}
}

执行效果：
包子铺开始做包子
包子造好了：冰皮五仁
吃货来吃吧
吃货正在吃冰皮五仁包子
包子铺开始做包子 包子造好了：薄皮牛肉大葱
吃货来吃吧
吃货正在吃薄皮牛肉大葱包子
包子铺开始做包子
包子造好了：冰皮五仁
吃货来吃吧
吃货正在吃冰皮五仁包子

线程池

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

2.合理利用线程池好处：
（1）降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
（2） 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
（3）提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存。

线程池的使用

1.Java里面线程池的顶级接口是 java.util.concurrent.Executor 。
但是严格意义上讲 Executor 并不是一个线程 池，而只是一个执行线程的工具。
真正的线程池接口是 java.util.concurrent.ExecutorService 。
2.配置一个线程池是比较复杂的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。
3.Executors类中有个创建线程池的方法如下：public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是***有界线程池***,也就是池中的线程个数可以指定最大数量)
4.使用线程池ExecutorService 对象：public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行。
5.使用线程池中线程对象的步骤：
（1）创建线程池对象。
（2）创建Runnable接口子类对象。(task)
（3）提交Runnable接口子类对象。(take task)
（4）关闭线程池(一般不做)。
代码示例：
Runnable实现类代码：

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("教我游泳,交完后，教练回到了游泳池");
}
}

线程池测试类：

public class ThreadPoolDemo {
public static void main(String[] args) {
// 创建线程池对象
ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
// 创建Runnable实例对象
MyRunnable r = new MyRunnable();
//自己创建线程对象的方式
// Thread t = new Thread(r);
// t.start(); ‐‐‐> 调用MyRunnable中的run()
// 从线程池中获取线程对象,然后调用MyRunnable中的run()
service.submit(r);
// 再获取个线程对象，调用MyRunnable中的run()
service.submit(r);
service.submit(r);
// 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
// 将使用完的线程又归还到了线程池中
// 关闭线程池
//service.shutdown();
}
}

Lambda表达式

函数式编程思想概述

1.面向对象的思想: 做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
2.函数式编程思想: 只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程。

繁琐的Runnable代码

1.当需要启动一个线程去完成任务时，通常会通过 java.lang.Runnable 接口来定义任务内容，并使用 java.lang.Thread 类来启动该线程。代码如下：

public class Demo01Runnable {
public static void main(String[] args) {
// 匿名内部类
Runnable task = new Runnable() {
@Override
public void run() { // 覆盖重写抽象方法
System.out.println("多线程任务执行！");
}
};
new Thread(task).start(); // 启动线程
}
}

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

编程思想转换

1.做什么，而不是怎么做。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将 run 方法体内的代码传递给 Thread 类知晓。
2.生活举例：从北京到上海时，可以选择高铁、汽车、骑行或是徒步。我们的真正目的是到达上海，而如何才能到达上海的形式并不重要，所以我们一直在探索有没有比高铁更好的方式——搭乘飞机。

体验Lambda的更优写法

1.上述 Runnable 接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效：

public class Demo02LambdaRunnable {
public static void main(String[] args) {
new Thread(() ‐> System.out.println("多线程任务执行！")).start(); // 启动线程
}
}

回顾

1.使用实现类
（1）.要启动一个线程，需要创建一个Thread 类的对象并调用 start 方法。而为了指定线程执行的内容，需要调用 Thread 类的构造方法： public Thread(Runnable target)
（2）.为了获取 Runnable 接口的实现对象，可以为该接口定义一个实现类 RunnableImpl ：

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

（3）然后创建该实现类的对象作为 Thread 类的构造参数：

public class Demo03ThreadInitParam {
public static void main(String[] args) {
Runnable task = new RunnableImpl();
new Thread(task).start();
}
}

2.使用匿名内部类
（1）这个 RunnableImpl 类只是为了实现 Runnable 接口而存在的，而且仅被使用了唯一一次，所以使用匿名内部类的 语法即可省去该类的单独定义：

public class Demo04ThreadNameless {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程任务执行！");
}
}).start();
}
}

3.匿名内部类可以帮我们省去实现类的定义，但是匿名内部类的语法——确实太复杂了
4. Runnable 接口只有一个 run 方法的定义：public abstract void run();其实就是制定了一种做事情的方案（其就是一个函数）：
无参数：不需要任何条件即可执行该方案。
无返回值：该方案不产生任何结果。
代码块（方法体）：该方案的具体执行步骤。
5.同样的语义体现在 Lambda 语法中，要更加简单：() ‐> System.out.println("多线程任务执行！"):
（1）前面的一对小括号即 run 方法的参数（无），代表不需要任何条件；
（2）中间的一个箭头代表将前面的参数传递给后面的代码；
（3）后面的输出语句即业务逻辑代码。

Lambda标准格式

1.3个部分：一些参数， 一个箭头， 一段代码。
2.标准格式：(参数类型 参数名称) ‐> { 代码语句 }
3.格式说明：
（1）小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
（2）-> 是新引入的语法格式，代表指向动作。
（3）大括号内的语法与传统方法体要求基本一致。

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

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

public interface Cook {
void makeFood();
}

使用Lambda的标准格式调用 invokeCook 方法，打印输出“吃饭啦！”字样：

public class Demo05InvokeCook {
public static void main(String[] args) {
// TODO 请在此使用Lambda【标准格式】调用invokeCook方法
invokeCook(() ‐> {
System.out.println("吃饭啦！");
});
}
private static void invokeCook(Cook cook) {
cook.makeFood();
}
}

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

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

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

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

使用Lambda的标准格式调用 invokeCalc 方法，完成120和130的相加计算：

public class Demo08InvokeCalc {
public static void main(String[] args) {
// TODO 请在此使用Lambda【标准格式】调用invokeCalc方法来计算120+130的结果ß
invokeCalc(120, 130, (int a, int b) ‐> { return a + b; });
}
private static void invokeCalc(int a, int b, Calculator calculator) {
int result = calculator.calc(a, b);
System.out.println("结果是：" + result);
}
}

Lambda省略格式

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

练习：使用Lambda省略格式

使用Lambda的省略格式调用 invokeCook 方法，打印输出“吃饭啦！”字样：

```java
public class Demo09InvokeCook {
public static void main(String[] args) {
// TODO 请在此使用Lambda【省略格式】调用invokeCook方法
invokeCook(() ‐> System.out.println("吃饭啦！")); 
}
private static void invokeCook(Cook cook) {
cook.makeFood();
}
}

Lambda的使用前提

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