等待唤醒机制
线程间通信
概念:多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。比如:线程A用来生成包子的,线程B用来吃包子的,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生产,一个是消费,那么线程A与线程B之间就存在线程通信问题。
为什么要处理线程间通信:
多个线程并发执行时, 在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信,以此来帮我们达到多线程共同操作一份数据。
如何保证线程间通信有效利用资源:
多个线程在处理同一个资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时, 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
等待唤醒机制
什么是等待唤醒机制
- 这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争(race),比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。就好比在公司里你和你的同事们,你们可能存在在晋升时的竞争,但更多时候你们更多是一起合作以完成某些任务。
- 就是在一个线程进行了规定操作后,就进入等待状态(wait()), 等待其他线程执行完他们的指定代码过后 再将其唤醒(notify());在有多个线程进行等待时, 如果需要,可以使用 notifyAll()来唤醒所有的等待线程。
- wait/notify 就是线程间的一种协作机制
等待唤醒中的方法
等待唤醒机制就是用于解决线程间通信的问题的,使用到的3个方法的含义如下:
- wait:线程不再活动,不再参与调度,进入 wait set 中,因此不会浪费 CPU 资源,也不会去竞争锁了,这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作,也即是“通知(notify)”在这个对象上等待的线程从wait set 中释放出来,重新进入到调度队列(ready queue)中
- notify:则选取所通知对象的 wait set 中的一个线程释放;例如,餐馆有空位置后,等候就餐最久的顾客最先入座。
- notifyAll:则释放所通知对象的 wait set 上的全部线程。
注意:
- 哪怕只通知了一个等待的线程,被通知线程也不能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以她需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下:
- 如果能获取锁,线程就从 WAITING 状态变成 RUNNABLE 状态;
- 否则,从 wait set 出来,又进入 entry set,线程就从 WAITING 状态又变成 BLOCKED 状态
调用wait和notify方法需要注意的细节
- wait方法与notify方法必须要由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
- wait方法与notify方法是属于Object类的方法的。因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
- wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为:必须要通过锁对象调用这2个方法。
生产者与消费者问题
等待唤醒机制其实就是经典的“生产者与消费者”的问题。
就拿生产包子消费包子来说等待唤醒机制如何有效利用资源:
代码演示:
包子资源类:
package demo01; public class BaoZi { String pier; String xianer; //包子资源 是否存在 包子资源状态 boolean flag = false; }
吃货线程类:
package demo01; 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 demo01; 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 demo01; 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(); } } } }
执行效果:
线程池
由来
我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题:如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用,就是执行完一个任务,并不被销毁,而是可以继续执行其他的任务?在Java中可以通过线程池来达到这样的效果。
线程池概念
线程池:其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。
合理利用线程池能够带来三个好处:
- 降低资源消耗。减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
- 提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)。
线程池的使用
Java里面线程池的顶级接口是 java.util.concurrent.Executor ,但是严格意义上讲 Executor 并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很有可能配置的线程池不是较优的,因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂,生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。
Executors类中有个创建线程池的方法如下:
- public static ExecutorService newFixedThreadPool(int nThreads) :返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
获取到了一个线程池ExecutorService 对象,那么怎么使用呢,在这里定义了一个使用线程池对象的方法如下:
- public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象,并执行
Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用。
使用线程池中线程对象的步骤:
- 创建线程池对象。
- 创建Runnable接口子类对象。
- 提交Runnable接口子类对象。(take task)
- 关闭线程池(一般不做)。
Runnable实现类代码:
package demo02; /* 2.创建一个类,实现Runnable接口,重写run方法,设置线程任务 */ public class RunnableImpl implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName() + "创建了一个新的线程执行"); } }
测试类
package demo02; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /* 线程池:JDK1.5之后提供的 java.util.concurrent.Executors:线程池的工厂类,用来生成线程池 Executors类中的静态方法: static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池 参数: int nThreads:创建线程池中包含的线程数量 返回值: ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程) java.util.concurrent.ExecutorService:线程池接口 用来从线程池中获取线程,调用start方法,执行线程任务 submit(Runnable task) 提交一个 Runnable 任务用于执行 关闭/销毁线程池的方法 void shutdown() 线程池的使用步骤: 1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池 2.创建一个类,实现Runnable接口,重写run方法,设置线程任务 3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法 4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行) */ 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-1创建了一个新的线程执行 //线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用 es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行 es.submit(new RunnableImpl());//pool-1-thread-2创建了一个新的线程执行 //4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行) es.shutdown(); es.submit(new RunnableImpl());//抛异常,线程池都没有了,就不能获取线程了 } }
Lambda表达式
函数式编程思想概述
在数学中,函数就是有输入量、输出量的一套计算方案,也就是“拿什么东西做什么事情”。相对而言,面向对象过分强调“必须通过对象的形式来做事情”,而函数式思想则尽量忽略面向对象的复杂语法——强调做什么,而不是以什么形式做。
面向对象的思想:
- 做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
函数式编程思想:
- 只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程
编程思想转换
我们真的希望创建一个匿名内部类对象吗?不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是:将 run 方法体内的代码传递给 Thread 类知晓。传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那,有没有更加简单的办法?如果我们将关注点从“怎么做”回归到“做什么”的本质上,就会发现只要能够更好地达到目的,过程与形式其实并不重要。2014年3月Oracle所发布的Java 8(JDK 1.8)中,加入了Lambda表达式的重量级新特性,为我们打开了新世界的大门。
需求
如果我们要实现一个多线程程序,传统的做法是需要创建一个 Thread 类的对象并调用 start 方法。而为了指定线程执行的内容,需要调用Thread 类的构造方法:
- public Thread(Runnable target)
为了获取 Runnable 接口的实现对象,可以为该接口定义一个实现类 RunnableImpl :
package demo03; public class RunnableImpl implements Runnable { @Override public void run() { System.out.println("多线程任务执行!"); } }
然后创建该实现类的对象作为 Thread 类的构造参数:
package demo03; public class Demo03ThreadInitParam { public static void main(String[] args) { Runnable task = new RunnableImpl(); new Thread(task).start(); } }
使用匿名内部类
这个 RunnableImpl 类只是为了实现 Runnable 接口而存在的,而且仅被使用了唯一一次,所以使用匿名内部类的语法即可省去该类的单独定义,即匿名内部类:
package demo03; public class Demo04ThreadNameless { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { System.out.println("多线程任务执行!"); } }).start(); } }
匿名内部类的好处与弊端
- 一方面,匿名内部类可以帮我们省去实现类的定义;另一方面,匿名内部类的语法——确实太复杂了!
语义分析
仔细分析该代码中的语义, Runnable 接口只有一个 run 方法的定义:
- public abstract void run();
即制定了一种做事情的方案(其实就是一个函数):
- 无参数:不需要任何条件即可执行该方案。
- 无返回值:该方案不产生任何结果。
- 代码块(方法体):该方案的具体执行步骤。
同样的语义体现在 Lambda 语法中,要更加简单:
() ‐> System.out.println("多线程任务执行!")
- 前面的一对小括号即 run 方法的参数(无),代表不需要任何条件;
- 中间的一个箭头代表将前面的参数传递给后面的代码;
- 后面的输出语句即业务逻辑代码。
Lambda的使用前提
Lambda的语法非常简洁,完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意:
- 使用Lambda必须具有接口,且要求接口中有且仅有一个抽象方法。无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口,只有当接口中的抽象方法存在且唯一时,才可以使用Lambda。
- 使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。备注:有且仅有一个抽象方法的接口,称为“函数式接口”。
Lambda标准格式
Lambda省去面向对象的条条框框,格式由3个部分组成:
- 一些参数
- 一个箭头
- 一段代码
Lambda表达式的标准格式为:
格式说明:
- 小括号内的语法与传统方法参数列表一致:无参数则留空;多个参数则用逗号分隔。
- -> 是新引入的语法格式,代表指向动作。
- 大括号内的语法与传统方法体要求基本一致。
Lambda省略格式
省略规则
在Lambda标准格式的基础上,使用省略写法的规则为:
- 小括号内参数的类型可以省略;
- 如果小括号内有且仅有一个参,则小括号可以省略;
- 如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号、return关键字及语句分号。
练习
题目
给定一个厨子 Cook 接口,内含唯一的抽象方法 makeFood ,且无参数、无返回值。如下:
package demo04; public interface Cook { void makeFood(); }
在下面的代码中,请使用Lambda的标准格式调用 invokeCook 方法,打印输出“吃饭啦!”字样:
package demo04; /* 需求: 给定一个厨子Cook接口,内含唯一的抽象方法makeFood,且无参数、无返回值。 使用Lambda的标准格式调用invokeCook方法,打印输出“吃饭啦!”字样 */ 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("吃饭了"); }); //优化省略Lambda invokeCook(()-> System.out.println("吃饭了")); } //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood public static void invokeCook(Cook cook){ cook.makeFood(); } }
题目
给定一个计算器 Calculator 接口,内含抽象方法 calc 可以将两个int数字相加得到和值:
package demo04; public interface Calculator { int calc(int a, int b); }
在下面的代码中,请使用Lambda的标准格式调用 invokeCalc 方法,完成120和130的相加计算:
package demo04; /* Lambda表达式有参数有返回值的练习 需求: 给定一个计算器Calculator接口,内含抽象方法calc可以将两个int数字相加得到和值 使用Lambda的标准格式调用invokeCalc方法,完成120和130的相加计算 */ public class Demo01Calculator { public static void main(String[] args) { //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类 invokeCalc(10, 20, new Calculator() { @Override public int calc(int a, int b) { return a + b; } }); //使用Lambda表达式简化匿名内部类的书写 invokeCalc(120, 130, (int a, int b) -> { return a + b; }); //优化省略Lambda invokeCalc(120, 130, (a, b) -> a + b); } /* 定义一个方法 参数传递两个int类型的整数 参数传递Calculator接口 方法内部调用Calculator中的方法calc计算两个整数的和 */ public static void invokeCalc(int a, int b, Calculator c) { int sum = c.calc(a, b); System.out.println(sum); } }