多线程，线程通信和线程池
1. 多线程
1.1 线程状态
image.png
1.2 Object类中的方法
wait();
1. 在哪一个线程中执行，哪一个线程就进入休眠状态【调用方法者为锁对象】
2. wait方法可以让当前线程进入休眠状态，同时【打开锁对象】
notify();
1. 唤醒一个线程，和当前调用方法【锁对象】相关线程
2. notify方法在唤醒线程的过程中，可以打开【锁对象】
notifyAll();
1. 唤醒和当前调用方法【锁对象】相关所有线程
2. notifyAll方法在唤醒所有线程的过程中，同时会开启锁对象。
2. 线程通信 生产者消费者案例
2.1 分析问题
image.png
2.2 代码实现
package com.qfedu.a_thread;
class Producer implements Runnable {
Goods goods;
public Producer() {
}
public Producer(Goods goods) {
this.goods = goods;
}
@Override
public void run() {
while (true) {
synchronized (goods) {
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
// 商品需要生产
if (goods.isProduct()) {
if (Math.random() > 0.5) {
goods.setName("吉利星越");
goods.setPrice(10);
} else {
goods.setName("领克05");
goods.setPrice(15);
}
System.out.println("生产者生产:" + goods.getName() + " 价格" + goods.getPrice());
// 修改生产标记
goods.setProduct(false);
// 唤醒消费者
goods.notify();
System.out.println("唤醒消费者");
} else {
// 生产者进入休眠状态
System.out.println("生产者休眠");
try {
goods.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
}
class Customer implements Runnable {
Goods goods;
public Customer() {
}
public Customer(Goods goods) {
this.goods = goods;
}
@Override
public void run() {
while (true) {
synchronized (goods) {
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
// 消费者买买买状态
if (!goods.isProduct()) {
System.out.println("消费者购买:" + goods.getName() + " 价格" + goods.getPrice());
// 修改生产标记
goods.setProduct(true);
// 唤醒生产者
System.out.println("唤醒生产者");
goods.notify();
} else {
// 消费者进入休眠状态
System.out.println("消费者休眠");
try {
goods.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
}
class Goods {
private String name;
private int price;
private boolean product;
public Goods() {
}
public Goods(String name, int price, boolean product) {
this.name = name;
this.price = price;
this.product = product;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public boolean isProduct() {
return product;
}
public void setProduct(boolean product) {
this.product = product;
}
}
public class Demo1 {
public static void main(String[] args) {
Goods goods = new Goods("领克05", 15, true);
Producer producer = new Producer(goods);
Customer customer = new Customer(goods);
System.out.println(producer.goods);
System.out.println(customer.goods);
new Thread(producer).start();
new Thread(customer).start();
}
}
3. 线程池
3.1 线程池需求
目前情况下操作线程对象
1. 继承Thread类，重写run方法，创建对象，start方法启动线程
2. 遵从Runnable接口，实现run方法，创建Thread类对象，start启动线程
以上两种方式，都是在确定run方法之后(What will be run 跑啥)！！！后期线程在运行的过程中，任务是明确的无法替换的！！！
生活中的例子:
吃饭
服务员
在提供服务的过程中，需要监视每一个桌子
如果发现有顾客需要提供服务，立马执行！！！
一个餐厅10张桌子，有5个服务员
5个服务员我们可以看做是5个线程，具体做什么任务，由用户指定。
3.2 线程池工作图例
image.png
3.3 低端版线程池方法和操作
class Executors
public static ExecutorService newFixedThreadPool(int nThreads);
得到一个线程池对象，传入参数为当前线程池中默认存在的线程对象有多少个。
ExecutorService
Future<?> submit(Runnable task);
提交任务给当前线程池，需要的参数是Runnable接口对象。
package com.qfedu.a_thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
* 线程池使用
*/
public class Demo4 {
public static void main(String[] args) {
/*
* 得到了一个线程池，目前线程池中有5个线程对象
*/
ExecutorService threadPool = Executors.newFixedThreadPool(5);
System.out.println(threadPool);
/*
* java.util.concurrent.ThreadPoolExecutor@7852e922
* [Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
* 线程池状态 Running 正在运行
* pool size = 0 当前线程池线程容量
* active threads 目前正在运行线程对象
* queued tasks 排队任务
* completed tasks 完成任务
*/
threadPool.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
System.out.println("线程池对象执行代码中");
}
});
threadPool.submit(() -> {
System.out.println(Thread.currentThread().getName());
System.out.println("线程池对象执行代码中");
});
System.out.println(threadPool);
}
}
4. Lambda表达式【 JDK1.8新特征】
4.1 说重点
接口和实现类
interface A {
void testA();
}
class TypeA implements A {
@Override
public void testA() {
Sout("测试");
}
}
main() {
new TypeA().testA();
}
1. 实现了一个类
2. 完成对应方法
3. 创建实现类对象
4. 调用方法 【核心】
Lambda表达式！！！
C语言 方法指针
PHP JS 匿名方法
Objective-C Block代码块
基本格式:
(参数名字) -> {
和正常完成方法一致！！！
}
4.2 无参数无返回值Lambda
package com.qfedu.b_lambda;
/*
* 函数式接口 有且只允许在接口中有一个未实现方法
*/
@FunctionalInterface
interface A {
void test();
}
public class Demo1 {
public static void main(String[] args) {
// 匿名内部类作为方法的参数
testInterface(new A() {
@Override
public void test() {
System.out.println("匿名内部类 low~~~");
}
});
// 无参数无返回值lambda表达式使用，因为有且只有一句话，大括号可以省略
testInterface(() -> System.out.println("无参数无返回值lambda"));
}
public static void testInterface(A a) {
a.test();
}
}
4.3 有参数无返回值Lambda
package com.qfedu.b_lambda;
import java.util.ArrayList;
import java.util.Comparator;
@FunctionalInterface
interface B {
/*
* 有参数无返回值方法，并且参数数据类型有传入参数类型 本身决定
*/
void test(String str);
}
public class Demo2 {
public static void main(String[] args) {
testInterface("测试", new B() {
@Override
public void test(String str) {
System.out.println(str);
}
});
/*
* lambda表达式参数需要养成习惯 1. 缺省数据类型 2. 脑补数据类型，自定义参数名字
*/
testInterface("abcdefg", (s) -> {
String str = s.toUpperCase();
System.out.println(str);
});
System.out.println();
ArrayList<SinglePerson> list = new ArrayList<SinglePerson>();
list.add(new SinglePerson("小赵", 16, '男'));
list.add(new SinglePerson("小钱", 14, '男'));
list.add(new SinglePerson("小孙", 12, '男'));
list.add(new SinglePerson("小李", 1, '男'));
list.add(new SinglePerson("小周", 0, '男'));
list.add(new SinglePerson("小五", 6, '男'));
list.sort(new Comparator<SinglePerson>() {
@Override
public int compare(SinglePerson o1, SinglePerson o2) {
return o1.getAge() - o2.getAge();
}
});
// Lambda表达式
list.sort((o1, o2) -> o1.getAge() - o2.getAge());
list.sort(Comparator.comparingInt(SinglePerson::getAge));
for (SinglePerson singlePerson : list) {
System.out.println(singlePerson);
}
}
public static void testInterface(String t, B b) {
b.test(t);
}
}
4.4 无参数有返回值Lambda
package com.qfedu.b_lambda;
@FunctionalInterface
interface C<T> {
T get();
}
public class Demo3 {
public static void main(String[] args) {
testInferface(new C<Integer>() {
@Override
public Integer get() {
return 1;
}
});
// 如果return是一句话，可以省略大括号和return关键字
testInferface(() -> {
return 5;
});
testInferface(() -> 5);
/*
* main方法中的局部变量
*/
int[] arr = {1, 3, 5, 7, 19, 2, 4, 6, 8, 10};
testInferface(() -> {
/*
* lambda表达式可以使用当前所处大括号以内的局部变量
*/
int maxIndex = 0;
// 找出数组中最大值
for (int i = 1; i < arr.length; i++) {
if (arr[maxIndex] < arr[i]) {
maxIndex = i;
}
}
return maxIndex;
});
}
private static void testInferface(C c) {
System.out.println(c.get());
}
}
4.5 有参数有返回值Lambda
package com.qfedu.b_lambda;
import java.util.ArrayList;
interface D<T> {
boolean test(T t);
}
public class Demo4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("锅包肉");
list.add("酱肘子");
list.add("回锅肉");
list.add("红烧肉");
list.add("拍黄瓜");
list.add("韭菜炒千张");
list.add("煎焖闷子");
/*
* 1. Lambda表达式
* 2. Stream流式操作
* 3. 方法引用
* 4. 函数式接口
*/
list.stream()
.filter((s) -> s.contains("肉"))
.filter(s -> s.startsWith("锅"))
.forEach(System.out::println);
}
}
