Java Day18
程序员文章站
2022-04-04 08:31:38
...
第一章 等带唤醒机制
1.1 线程间通信
- 概念:多个线程在处理同一个资源,但是处理动作却不相同。
- 为什么要处理线程间通信:多个线程并发执行时,在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望有规律执行,那么多个线程之间需要一些协调通信,以此来达到多线程共同操作一份数据。
- 如何保证线程间通信有效利用资源:多个线程在处理同一个资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变量的使用和操作。就是多个线程在操作同一份数据时,避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段被称为——等待唤醒机制。
1.2 等待唤醒机制
- 什么是等待唤醒机制:这是多个线程间的一种协作机制。就是在一个线程进行规定的操作后,就进入等待状态(wait),等待其他线程执行完他们的指定代码后再将其唤醒(notify);在有多个线程进行等待时,如果需要可以使用notifyAll来唤醒所有的等待线程。
- 等待唤醒的方法:
- wait:线程不再活动,不再参与调度,进入wait set中,因此不会浪费CPU资源,也不会竞争锁了,这是线程状态即WAITING,它还要等着别的线程执行一个特别的动作,也即是“通知”在这个对象上等待的线程从wait set中释放出来,重新进入到调度队列中。
- notify:则选取所通知对象的wait set中的一个线程释放。
- notifyAll:释放所通知对象的wait set上的全部线程。
- 调用wait和notify方法需要注意的细节
- wait方法与notify方法必须要由同一个锁对象调用。因为,对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
- wait方法与notify方法是属于Object类的方法的。因为,锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
- wait方法与notify方法必须要在同步代码块或这同步函数中使用。因为:必须要通过锁对象调用这2个方法。
1.3 生产者与消费者问题
等待唤醒机制其实就是经典的生产者与消费者的问题,代码演示:
定义包子类:
/*
* 资源类:包子类
* 设置包子的属性:
* 皮
* 馅
* 包子的状态:有true,没有false
* */
public class Baozi {
// 皮
String pi;
// 馅
String xian;
// 包子的状态:有true,没有false,设置初始值为false没有包子
boolean flag = false;
}
定义吃货线程类:
/*
* 消费者类:是一个线程类,可以继承Thread
* 设置线程任务(run):吃包子
* 对包子的状态进行判断:
* false:没有包子
* 吃货调用wait方法进入等待状态
* true有包子
* 吃货吃包子
* 吃货吃完包子
* 修改包子的状态为false
* 吃货唤醒包子铺线程,生产包子
* */
public class ChiHuo extends Thread {
private Baozi bz;
// 使用构造方法为包子变量赋值
public ChiHuo(Baozi baozi) {
this.bz = baozi;
}
// 设置线程任务:吃包子
@Override
public void run() {
// 使用死循环让吃货一直吃包子
while (true) {
// 必须同时同步技术保证两个线程只能有一个在执行
synchronized (bz) {
// 对包子状态进行判断
if (bz.flag == false) {
// 吃货调用wait方法进入等待状态
try {
bz.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 被唤醒之后执行的代码
System.out.println("吃货正在吃:" + bz.pi + bz.xian + "的包子。");
// 吃货吃完包子修改包子的状态
bz.flag = false;
// 唤醒包子铺线程
bz.notify();
System.out.println("吃货已经把:" + bz.pi + bz.xian + "的包子,吃完了,包子铺开始生产包子。");
System.out.println("===============================================");
}
}
}
}
定义包子铺线程类:
/*
* 生产者:是一个线程类,可以继承Thread
* 设置线程任务(run):生产包子
* 对包子的状态进行判断:
* true有包子
* 包子铺调用wait方法进入等待状态
* false没有包子
* 包子铺生产包子
* 增加一些趣味性:交替生产两种包子
* 有两种状态
* 包子铺生产好了包子
* 修改包子的状态为true
* 唤醒吃货线程,让吃货线程吃包子
*
* 注意:
* 包子铺线程和包子线程关系-->通信(互斥);
* 必须同时同步技术保证两个线程只能有一个在执行
* 锁对象必须保证唯一,可以使用包子对象作为锁对象
* 包子铺和出货两个类就需要把包子对象作为参数传递进来:
* 需要在成员位置创建一个包子变量
* 使用带参数的构造方法,为这个包子变量赋值
* */
public class BaoZiPu extends Thread {
// 创建一个包子变量
private Baozi bz;
// 使用带参数的构造方法,为这个包子变量赋值
public BaoZiPu(Baozi bz) {
this.bz = bz;
}
// 设置线程任务:生产包子
@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 + "包子");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 生产好包子
// 修改包子的状态为true
bz.flag = true;
bz.notify();
System.out.println("包子铺已经生产好了:" + bz.pi + bz.xian + "包子,吃货可以开吃了。" );
}
}
}
}
定义测试类:
public class Demo01Main {
public static void main(String[] args) {
Baozi baozi = new Baozi();
new BaoZiPu(baozi).start();
new ChiHuo(baozi).start();
}
}
第二章 线程池
2.1 线程池思想概述
- 线程池:其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁的创建线程对象的操作,无需反复创建线程而消耗过多的资源。
- 原理如下:
- 合理使用线程池可以带来三个好处:
- 降低资源消耗,减少了床架和销毁线程的次数,每个工作线程都可以被重复使用,可执行多个任务。
- 提高响应速度,当任务到达时,任务可以不需要等到线程创建就能立即执行。
- 提高线程的可管理性,可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下。
2.2 线程池的使用
java里面线程池的*接口,java.lang.concurrent.Executor,但是严格意义上讲Executor并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是:java.util.concurrent.ExecutorService。
Executor类中提供过了一些静态工厂,生成一些常用的线程池,Executors类中有个创建线程池的方法如下:
- public static ExecutorService newFixedThreadPool(int nThread):返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数值)
- public Future<?> submit(Runnable task):获取线程池中的某一个线程对象,并执行。
使用线程池中线程对象的步骤:
- 创建线程池对象
- 创建Runnable接口子类对象。
- 提交Runnable接口子类对象。
- 关闭线程池(一般不做)
代码演示:
Runnable实现类代码:
public class RunnableImpl implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "创建了一个新的进程执行。");
}
}
定义测试类:
public class Demo01ThreadPool {
public static void main(String[] args) {
//使用线程池的工厂类Executors里边提供的静态方法newFixThreadPool生产一个指定线程数量的线程池
ExecutorService es = Executors.newFixedThreadPool(2);
// 调用ExcutorService中的方法submit,传递线程任务,开启线程,执行run方法
// 线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
es.submit(new RunnableImpl()); // pool-1-thread-2创建了一个新的进程执行。
es.submit(new RunnableImpl()); // pool-1-thread-1创建了一个新的进程执行。
es.submit(new RunnableImpl()); // pool-1-thread-2创建了一个新的进程执行。
// 调用Executor中的方法shutdown销毁线程池(不建议执行)
es.shutdown();
es.submit(new RunnableImpl()); // 抛出异常,线程池都没有了,就不能获取线程了
}
}
第三章 Lambda表达式
3.1 函数式编程思想概述
函数式编程尽量忽略面向对象的复杂语法,强调做什么,而不是以什么形式做。只要能获取到结果,谁去做的,怎么做的都不重要,重视结果,不重视过程。
3.2 Lambda
使用匿名内部类实现Runnable接口,代码演示:
/*
* 使用实现Runnable接口的方式实现多线程程序
*
* */
public class Demo01Runnable {
public static void main(String[] args) {
// 简化代码,使用匿名内部类来实现多线程程序
Runnable run2 = new Runnable() {
@Override
public void run() {
System.out.println("使用匿名内部类创建了一个进程");
}
};
new Thread(run2).start();
// 继续简化代码
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("使用匿名对象+匿名内部类创建了一个进程");
}
}).start();
}
}
匿名内部类的好处和弊端:一方面,匿名内部类可以帮我们省去事项类的定义;另一方面,匿名内部类的语法太复杂了。同样的代码使用lambda就要更加简单,lambda格式如下:
(参数类型 参数名称) -> {代码语句}
格式说明:
- 小括号内的语法与传统参数列表一致:无参数留空,多个参数则用逗号分隔。
- ->是新引入的语法格式,代表指向动作。
- 大括号内的语法与传统方法要求基本一致。
3.3 练习
3.3.1 练习一
定义一个接口:
public interface Cook {
public abstract void makeFood();
}
定义一个测试类:
/*
* 需求:
* 给定一个厨子接口Cook,内含唯一的抽象方法makeFood,且无参数,无返回值。
* 使用lambda的标准格式调用invokeCook方法,打印输出"我吃饭了"字样
*
* */
public class DemoMain {
public static void main(String[] args) {
invokeCook(() -> {
System.out.println("吃饭了");
});
}
private static void invokeCook(Cook cook) {
cook.makeFood();
}
}
3.3.2 Lambda的参数与返回值
需求:使用数组存储刀割Person对象,对数组中的Person对象只用Arrays的sort方法通过年龄进行升序操作。
定义一个Person类:
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", 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;
}
}
定义一个测试类:
/*
* lambda表达式有参数有返回值的练习:
* 需求:
* 使用数组存储刀割Person对象
* 对数组中的Person对爱哪个使用Array的sort方法通过年龄进行升序排序
*
* */
import java.util.Arrays;
import java.util.Comparator;
public class Demo01Arrays {
public static void main(String[] args) {
// 使用数组存储多个Person对象
Person[] arr = {
new Person("aaa",10),
new Person("bbb", 29),
new Person("ccc", 14)
};
// 对数组中的Person对爱哪个使用Array的sort方法通过年龄进行升序排序
// Arrays.sort(arr, new Comparator<Person>() {
// @Override
// public int compare(Person o1, Person o2) {
// return o1.getAge() - o2.getAge();
// }
// });
// 使用lambda表达式
Arrays.sort(arr, (Person o1, Person o2) -> {
return o1.getAge() - o2.getAge();
});
for (Person p : arr) {
System.out.println(p);
}
}
}
3.4 lambda省略格式
- 省略规则:
- 小括号内参数的类型可以省略。
- 如果小括号内有且仅有一个参数,则小括号可以省略。
- 如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号,return关键字及语句分号,要省一起省。
代码演示:
定义一个接口:
public interface Calculator {
int calc(int a, int b);
}
定义一个测试类:
public class DemoInvokeCalc {
public static void main(String[] args) {
// 原格式
invokeCalc(120, 130, (int a, int b) -> {
return a + b;
});
// 省略优化
invokeCalc(120, 250, (a, b) -> a+b);
}
private static void invokeCalc(int a, int b, Calculator calculator) {
int result = calculator.calc(a, b);
System.out.println("结果是:" + result);
}
}
3.5 Lambda使用前提
- 使用Lambda必须具有接口,并且要求接口中有且仅有一个抽象方法,有且仅有一个抽象方法的接口又被称为:函数式接口。
- 使用Lambda必须具有上下文推断,也就是方法的参数或者局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。