第一章 等待唤醒机制
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作为该接口的实例