等待唤醒机制
1.1线程间通信
概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
等待唤醒机制：需要通过一定的手段使各个线程能有效的利用资源。
1.2等待唤醒机制
等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：
- wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中。
- notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
- notifyAll：则释放所通知对象的 wait set 上的全部线程。
- 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态； 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态
线程池
2.1线程池
线程池: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销毁线程池(不建议执行)
import java.awt.*;
/*
2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
*/
public class RunnableImpl implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"创建了一个新的线程执行");
}
}import java.util.Collection;
import java.util.List;
import java.util.concurrent.*;
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-2创建了一个新的线程执行
//线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
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());//抛异常,线程池都没有了,就不能获取线程了java.util.concurrent.RejectedExecutionException
}
}Lambda表达式
3.1函数式编程思想
- 面向对象的思想：
做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情。 - 函数式编程思想：
只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程。
3.2冗余的Runnable代码
/*
创建Runnable接口的实现类,重写run方法,设置线程任务
*/
public class RunnableImpl implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建成功");
}
}/*
使用实现Runnable接口的方式实现多线程程序
*/
public class Demo01Runnable {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
Runnable run = new RunnableImpl();
//创建Thread类对象，构造方法中传递Runnable接口的实现类
Thread t = new Thread(run);
//调用start方法开启新线程，执行run方法
t.start();
//简化代码,使用匿名内部类，实现多线程程序
Runnable r = new Runnable(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建成功");
}
};
new Thread(r).start();
//简化代码
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建成功");
}
}).start();
}
}3.3编程思想转换
我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将run方法体内的代码传递给Thread类知晓。
传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。
3.4体验Lambda的更优写法
public class Demo02Lambda {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新线程创建成功");
}
}).start();
//使用Lambda表达式,实现多线程
new Thread(()-> {
System.out.println(Thread.currentThread().getName() + "新线程创建成功");
}
).start();
//优化省略Lambda
new Thread(()->System.out.println(Thread.currentThread().getName()+"新线程创建成功")).start();
}
}3.5回顾匿名内部类
使用实现类
要启动一个线程，需要创建一个Thread类的对象并调用start方法。而为了指定线程执行的内容，需要调用Thread类的构造方法：public Thread(Runnable target)
使用匿名内部类
这个RunnableImpl类只是为了实现Runnable接口而存在的，而且仅被使用了唯一一次，所以使用匿名内部类的语法即可省去该类的单独定义。
匿名内部类的好处与弊端
- 匿名内部类可以帮我们省去实现类的定义；
- 匿名内部类的语法——太复杂
语义分析
仔细分析该代码中的语义，Runnable接口只有一个run方法的定义： public abstract void run();
即制定了一种做事情的方案（其实就是一个函数）：
- 无参数：不需要任何条件即可执行该方案。
- 无返回值：该方案不产生任何结果。
- 代码块（方法体）：该方案的具体执行步骤。
（同样的语义体现在Lambda语法中，要更加简单）
3.6Lambda标准格式
Lambda表达式的标准格式:
- 由三部分组成:
a.一些参数
b.一个箭头
c.一段代码 - 格式:
(参数列表) -> {一些重写方法的代码}; - 解释说明格式:
():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
->:传递的意思,把参数传递给方法体{}
{}:重写接口的抽象方法的方法体
3.7 练习：使用Lambda标准格式（无参无返回）
/*
定一个厨子Cook接口，内含唯一的抽象方法makeFood
*/
public interface Cook {
//定义无参数无返回值的方法makeFood
public abstract void makeFood();
}import java.io.PushbackInputStream;
/*
需求:
给定一个厨子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();
}
}3.8 Lambda的参数和返回值
Lambda表达式有参数有返回值的练习
需求:
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
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;
}
}import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
public class Demo01Arrays {
public static void main(String[] args) {
//使用数组存储多个Person对象
Person[] arr ={
new Person("丹丹",26),
new Person("沐沐",15),
new Person("多多",18)
};
//对数组中的Person对象使用Arrays的sort方法通过年龄进行升序（前面—后面）排序
/* Arrays.sort(arr, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return 0;
}
});*/
//使用Lambda表达式，简化匿名内部类
Arrays.sort(arr,(o1,o2)->o1.getAge()-o2.getAge());
//遍历数组
for (Person p : arr) {
System.out.println(p);
}
}
}3.9 Lambda的参数和返回值（自定义）
Lambda表达式有参数有返回值的练习
需求:
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
/*
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
*/
public interface Calculator {
//定义一个计算两个int整数和的方法并返回结果
public abstract int calc(int a,int b);
}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,125,(int a,int b)->{
return a+b;
});
//优化省略Lambda
invokeCalc(120,125,(a,b)->a+b);
}
/*
定义一个方法
参数传递两个int类型的整数
参数传递Calculator接口
方法内部调用Calculator中的方法calc计算两个整数的和
*/
private static void invokeCalc(int a,int b,Calculator c) {
int sum = c.calc(a, b);
System.out.println(sum);
}
}3.10Lambda省略格式
Lambda表达式:是可推导,可以省略
凡是根据上下文推导出来的内容,都可以省略书写
可以省略的内容:
1.(参数列表):括号中参数列表的数据类型,可以省略不写
2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
3.{一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
注意:要省略{},return,分号必须一起省略。
import java.util.ArrayList;
public class Demo01ArrayList {
public static void main(String[] args) {
//JDK1.7版本之前,创建集合对象必须把前后的泛型都写上
ArrayList<String> list01 = new ArrayList<>();
//JDK1.7版本之后,=号后边的泛型可以省略,后边的泛型可以根据前边的泛型推导出来
ArrayList<String> list02 = new ArrayList<>();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
