多线程技术（0807）
多线程学习
一、线程与进程
-
进程 :
- 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
-
线程
-
是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少 有一个线程
-
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线
-
线程调度
分时调度
- 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
-
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)， Java使用的为 抢占式调度。
-
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻， 只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时 刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使 用率更高。
二、同步与异步
-
**同步:**排队执行 , 效率低但是安全.
-
**异步:**同时执行 , 效率高但是数据不安全
三、并发与并行
-
并发：指两个或多个事件在同一个时间段内发生。
-
并行：指两个或多个事件在同一时刻发生（同时发生）
四、多线程技术的实现
1、Thread实现
- 多线程方法
- 需要创建一个对象，然后调用start()方法启动一个线程
public class MyThread extends Thread{
/**
* run方法就是线程需要执行的任务方法
*/
@Override
public void run() {
/*
这里的代码。就是一条新的执行路径
这个执行方法的处理方式，不是调用run方法，而是通过Thread对象的strart()来启动任务
*/
for (int i = 0; i < 10; i++) {
System.out.println("锄禾日当午" + i);
}
}
}
- 主函数
public class Demo {
/**
* 多线程技术
* @param args
*/
public static void main(String[] args) {
//Thread
MyThread myThread = new MyThread();
myThread.start();//启动线程
for (int i = 0; i < 10; i++) {
System.out.println("汗滴禾下土" + i);
}
}
- 程序执行图：
- 子线程的方法在子线程中执行
- 每个线程都有一份自己的栈空间，共用一份堆内存
- 匿名内部类实现（方法只可调用一次）
public class Demo02 {
public static void main(String[] args) {
new Thread(){//匿名内部类实现
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Hello" + i);
}
}
}.start();
for (int i = 0; i < 5; i++) {
System.out.println("World!" + i);
}
}
}
2、Runnable实现
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("想陈俊华的第 " + i + " 遍");
}
}
}
public class Demo {
/**
* 多线程技术
* 实现Runnable 与 继承 Thread相比有以下优势：
* 1、 通过创建任务， 然后给线程分配的分配的方式来实现多线程， 更合适多个线程同时执行相同的任务情况
* 2、 可以避免单继承所带来的局限（extends只能实现单继承）
* 3、 任务与线程本身是分离的， 提高了程序的的健壮性
* 4、 后续学习的线程池技术，接受Runnable 类型的任务， 不接受Thread类型的线程
* @param args
*/
public static void main(String[] args) {
//Runnable
MyRunnable myRunnable = new MyRunnable(); //步骤1： 创建一个对象
Thread thread = new Thread(myRunnable);//步骤2： 创建一个线程，并为其分配有个任务
thread.start();//步骤3： 启动任务
//主函数的线程
for (int i = 0; i < 5; i++) {
System.out.println("重要的事情说了 " + i + " 遍");
}
}
}
3、获取和设置线程名称
Thread.currentThread().getName();//获取名称
Thread t = new Thread();
t.setName();
t.start();
//=====================
new Thread(new MyRunnable(), "名称").start();
4、 线程的休眠sleep
for (int i = 0; i < 5; i++) {
System.out.println("重要的事情说了 " + i + " 遍");
Thread.sleep(1000);//每个1000毫秒，也就是1秒，休眠一次
}
5、线程阻塞
- 消耗时间的操作，比如文件的读取，等着读取文件的内容
6、线程的中断
-
一个线程是一个独立的执行路径，它是否应该结束，应该有其自身决定
-
中断方法：
- 早期使用 — stop()方法
- 现在使用设置中断标记 t1.interrupt(); ，发现中断标记的时候，可以结束这个线程
public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new MyRunnable()); t1.start(); for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName()+ " :" + i);//获取线程名称 System.out.println(i); try { Thread.sleep(1000);//线程休眠 } catch (InterruptedException e) { e.printStackTrace(); } } //给线程t1添加中断标记 t1.interrupt(); } static class MyRunnable implements Runnable { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName()+ ":" + i); try { Thread.sleep(1000); } catch (InterruptedException e) { // e.printStackTrace(); System.out.println("发现了中断标记, return结束线程，让他自杀"); return ;//发现中断标记后，结束该线程 } } } } }
7、守护线程
-
线程： 线程分为 守护线程 和 用户线程
-
用户线程： 当一个进程不包含任何一个存活的用户线程时，进程结束，我们主动创建的线程是用户线程
-
守护线程： 守护用户线程， 当最后一个用户线程结束的时候，所有守护线程自动死亡
-
-
守护线程的设置方法：
setDaemon();
代码案例：
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new MyRunnable());
t1.setDaemon(true);//将线程t1设置为守护线程，当main这个线程结束时，t1这个守护线程自动结束
t1.start();
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+ " :" + i);
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
8、线程安全问题
1、线程不安全问题的示例
public class Demo {
public static void main(String[] args) throws InterruptedException {
MyRunnable myRunnable = new MyRunnable();
new Thread(myRunnable).start();
new Thread(myRunnable).start();
new Thread(myRunnable).start();
}
static class MyRunnable implements Runnable {
private int count = 10;
@Override
public void run() {
while(count > 0 ) {
System.out.println("进程" + Thread.currentThread().getName() +"卖票中");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println("卖出票数：" + (10 - count) + "余票" + count );
}
}
}
}
- 按照上面的程序，当count= 0 的时候，就不应该执行了，但我们看到，结果却出现了负数，这就是线程的不安全问题
- 三个线程 A B C 同时就绪， A执行完后count = 0， 但此时B C 依旧会执行，所以出现了-1 , -2 的情况
- 也就是执行的时候被其他线程干涉了
2、线程不安全问题的解决
本质： 让线程排队执行
1、同步代码块
synchronized(锁对象) {
}
static class MyRunnable implements Runnable {
private int count = 10;
Object o = new Object();
//注意，这个对象一定是所有进程共同的， 不可以放在run()方法里面，不然就是每个进程一个对象，也解决不了线程安全问题
@Override
public void run() {
while(true ) {
//Object o = new Object(); 不可以放在这里
synchronized (o) {//加锁
if (count > 0) {
System.out.println("进程" + Thread.currentThread().getName() + "卖票中");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println("卖出票数：" + (10 - count) + " 余票" + count);
}
}
}
}
}
2、同步方法（加上synchronized修饰的方法）
public class Demo {
/**
* 多线程技术
* 实现Runnable 与 继承 Thread相比有以下优势：
* 1、 通过创建任务， 然后给线程分配的分配的方式来实现多线程， 更合适多个线程同时执行相同的任务情况
* 2、 可以避免单继承所带来的局限（extends只能实现单继承）
* 3、 任务与线程本身是分离的， 提高了程序的的健壮性
* 4、 后续学习的线程池技术，接受Runnable 类型的任务， 不接受Thread类型的线程
* @param args
*/
public static void main(String[] args) throws InterruptedException {
MyRunnable myRunnable = new MyRunnable();
new Thread(myRunnable).start();//注意这里三个同时卖10张票，对象要是同一个
new Thread(myRunnable).start();
new Thread(myRunnable).start();
/*
这样子是三个线程同时卖10张票，自己卖自己的票，他们的锁对象不一样
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();
*/
}
static class MyRunnable implements Runnable {
private int count = 10;
Object o = new Object();
@Override
public void run() {
while(true ) {
boolean flag = sale();
if (!flag) break;
}
}
/*同步方法，方法前面加synchronized修饰符
锁对象：
1.如果不是static修饰的方法，那就是当前的this对象
2.static修饰的方法，那就是 MyRunnable.class()
*/
public synchronized boolean sale() {
if (count > 0) {
System.out.println("进程" + Thread.currentThread().getName() + "卖票中");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println("卖出票数：" + (10 - count) + " 余票" + count);
return true;
}
return false;
}
}
}
3、显示锁
锁：显示锁和隐式锁
-
隐式锁： 同步方法和同步代码块
-
显示锁 Lock 子类–> ReentrantLock
Lock l = new ReentrantLock(); l.lock(); .....需要加锁的代码块 l.unlock();
4、公平锁与不公平锁
- 公平锁： 加锁之后，其他线程全部排队，解锁后，谁先排的队，谁就先执行
- 不公平锁： 加锁之后，其他线程全部排队，解锁后，互相竞争抢夺，谁抢到谁就先开始（同步代码块、同步方法都是不公平的）
实现公平锁：
Lock l = new ReentrantLock(true);//传入参数true修改为公平锁
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RaQRJK8N-1628417546488)(C:\Users\戴子儒\AppData\Roaming\Typora\typora-user-images\image-20210808112819015.png)]
5、线程死锁
例子描述： 警察与罪犯两个线程交互，警察说话，希望的到罪犯回应，罪犯说话希望得到警察回应；
package duoxiancheng.day0808;
public class Demo1 {
public static void main(String[] args) {
Culprit c = new Culprit();
Police p = new Police();
new MyThread(c, p).start();//启动子线程，警察说话，罪犯回应
c.say(p);//罪犯说话，警察回应
}
static class MyThread extends Thread {
private Culprit c;
private Police p;
public MyThread(Culprit c, Police p) {
this.c = c;
this.p = p;
}
@Override
public void run() {
p.say(c);
}
}
static class Culprit {
public synchronized void say(Police p) {//设置为同步方法
System.out.println("罪犯：你放了我，我放了人质");
p.respond();//罪犯说完话，警察回应
}
public synchronized void respond() {
System.out.println("罪犯： 我放了人质，警察放了我");
}
}
static class Police {
public synchronized void say(Culprit c) {
System.out.println("警察： 你放了人质，我放了你");
c.respond();//警察说完话，罪犯回应
}
public synchronized void respond() {
System.out.println("警察： 解救了人质，但罪犯被放走了");
}
}
}
- 发生死锁的情况：
警察说话之后，调用罪犯对象的回应，但是警察说完话后，还没调用罪犯的回应方法respond, 罪犯又在调用c.say§,也就是此时罪犯说话了，说话后也希望得到警察的回应，也就是调用p.respond(), 但是两者的say()方法，没有执行respond,对方已经调用say()了，这样子就形成了进程的死锁
- 没有发生死锁的情况：
- 解决方法： 在任何一个可能产生锁的方法里面，不要调用其他方法
6、多线程通讯问题
1.生产者与消费者问题
例子： 一个厨师，一个服务员， 一个盘子， 厨师做饭的时候，必须要有干净的盘子，此时服务员休眠（wait()), 厨师做完饭后唤醒服务员，服务员将菜端给顾客，厨师休眠，等到顾客吃完，服务员洗干净盘子，唤醒厨师，厨师做菜
代码实现：
package duoxiancheng.day0808;
import javax.swing.plaf.TableHeaderUI;
public class CookAndWaiter {
public static void main(String[] args) {
Food food = new Food();
new Cook(food).start();
new Waiter(food).start();
}
//厨师线程---->生产者
static class Cook extends Thread {
private Food f;
public Cook(Food f) {
this.f = f;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0) {//生成50份煎饼果子he 50份老干妈小米粥
f.setNameAndSetTaste("辣子鸡丁","香辣味");
} else {
f.setNameAndSetTaste("焦糖鸭脖", "焦糖味");
}
}
}
}
//服务员线程----->消费者
static class Waiter extends Thread {
private Food f;
public Waiter(Food f) {
this.f = f;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
f.get();
}
}
}
//食物
static class Food {
private String name;
private String taste;
public void setNameAndSetTaste(String name, String taste) {
this.name = name;
//这两段代码中间的执行间隙有可能时间片丢失
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.taste = taste;
}
public void get() {
System.out.println("服务员端走的菜的名称是：" + name + ", 味道： "+ taste);
}
}
}
运行结果： 我们可以发现，程序中我们设置为味道发生的错误
出错原因：
解决：
private boolean flag = true; //true表示可以生产
this.notifyAll();//唤醒在当前this下睡着的所有线程，
this.wait();//d当前对象线程休眠
//食物
static class Food {
private String name;
private String taste;
//true表示可以生产
private boolean flag = true;
public void setNameAndSetTaste(String name, String taste) {
if(flag) {
this.name = name;
//这两段代码中间的执行间隙有可能时间片丢失
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.taste = taste;
flag = false;
this.notifyAll();//唤醒在当前this下睡着的所有线程，即唤醒服务员
try {
this.wait();//厨师线程睡着
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void get() {
if(!flag) {
System.out.println("服务员端走的菜的名称是：" + name + ", 味道： "+ taste);
flag = true;
this.notifyAll();//唤醒厨师
try {
this.wait();//服务员休眠
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
9、线程的6种状态
- 线程状态。线程可以处于以下状态之一：
NEW
尚未启动的线程处于此状态。RUNNABLE
在Java虚拟机中执行的线程处于此状态。BLOCKED
被阻塞等待监视器锁定的线程处于此状态。WAITING
无限期等待另一个线程执行特定操作的线程处于此状态。TIMED_WAITING
正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。TERMINATED
已退出的线程处于此状态。
10、Callable创建线程（带有返回值）
- 带有返回值的线程
package duoxiancheng.day0808;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> callable = new MyCallable();
FutureTask<Integer> futureTask = new FutureTask<>(callable);
new Thread(futureTask).start();
Integer num = futureTask.get();//主线程等待子线程结束返回结果
//futureTask.cancel(true);//取消子线程
System.out.println("返回的值" + num);
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i);
}
}
static class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
// Thread.sleep(3000);
for (int i = 0; i < 10; i++) {
Thread.sleep(100);
System.out.println(i);
}
return 100;
}
}
}
- Runnable 与 Callable
接口定义
//Callable接口
public interface Callable<V> {
V call() throws Exception;
}
//Runnable接口
public interface Runnable {
public abstract void run();
}
- Callable使用步骤
1. 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
@Override
public <T> call() throws Exception {
return T;
}
}
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);
3. 通过Thread,启动线程
new Thread(future).start()
-
Runnable 与 Callable的相同点
- 都是接口
- 都可以编写多线程程序
- 都采用Thread.start()启动线程
-
Runnable 与 Callable的不同点
- Runnable没有返回值；Callable可以返回执行结果
- Callable接口的call()允许抛出异常；Runnable的run()不能抛出
-
Callable获取返回值
- Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执 行，如果不调用不会阻塞。
11、线程池
线程池 Executors
- 相当于一个容器，存储着多个线程
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程
就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容
器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。
线程池的好处
- 降低资源消耗。
- 提高响应速度。
- 提高线程的可管理性。
Java中的四种线程池 . ExecutorService
1、缓存线程池（newCachedThreadPool() ）
package duoxiancheng.day0808;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo3 {
public static void main(String[] args) {
/**
* 缓存线程池.
* (长度无限制)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在,则创建线程 并放入线程池, 然后使用
*/
ExecutorService service = Executors.newCachedThreadPool();
//向线程池中 加入(执行) 新的任务
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
System.out.println("三个线程执行完毕后，存在与缓存线程池中--------------------------");
try {
Thread.sleep(1000);
System.out.println("休眠了，前面的三个线程已经完成------");
} catch (InterruptedException e) {
e.printStackTrace();
}
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
}
}
上面的程序中，到35行，前面的3个线程全部执行完毕，存在于缓存池中，所以休眠后我们的43行的线程不是创建一个新的线程，而是调用了缓存池中的线程
2、定长线程池（newFixedThreadPool(2)）
/**
* 定长线程池.
* (长度是指定的数值)
* 执行流程:
3. 单线程线程池
4. 周期性任务定长线程池
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
ExecutorService service = Executors.newFixedThreadPool(2);//设置线程池中只有两个线程
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
System.out.println("线程池中的两个线程都处在忙的执行状态");
service.execute(new Runnable() {//这是第三个线程池，需要等待前面的线程结束，空闲了才可以继续调用，而不会产生新的线程
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
3、当线程线程池(newSingleThreadExecutor())
效果与定长线程池 创建时传入数值1 效果一致.
/**
* 单线程线程池.
* 执行流程:
* 1. 判断线程池 的那个线程 是否空闲
* 2. 空闲则使用
* 4. 不空闲,则等待 池中的单个线程空闲后 使用
*/
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+ "这是第三个线程");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+ "这是第三个线程");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+ "这是第三个线程");
}
});
我们会发现，其实这三个线程是同一个线程
4、周期任务定长线程池
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
//定时执行
service.schedule(new Runnable() {
* @Override
* public void run() {
* System.out.println("俩人相视一笑~ 嘿嘿嘿");
* }
* },5,TimeUnit.SECONDS);//延迟5秒后执行
/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
//定时执行
/**
* 定时执行
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位
* service.schedule(new Runnable() {
* @Override
* public void run() {
* System.out.println("俩人相视一笑~ 嘿嘿嘿");
* }
* },5,TimeUnit.SECONDS);
*/
/*
*/
//周期执行
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,2,TimeUnit.SECONDS);//延长5秒执行，执行后，每隔2秒执行一次
}
五、Lambda表达式
- 比如我们执行的东西很少时，开启一个线程， Runnable代码就会显得比较冗余，如下：
public static void main(String[] args) {
//冗余的Runnable代码
MyRunnable m = new MyRunnable();
Thread thread = new Thread(m);
thread.start();
}
static class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("锄禾日当午");
}
}
- 于是我们会像下面一样修改。使用匿名内部
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("锄禾日当午");
}
});
thread.start();
}
- 上面的修改代码简洁了很多，但并不是我们的Lambda表达式
Thread t = new Thread(() -> {
System.out.println("锄禾日当午");
System.out.println("汗滴禾下土");
});
t.start();
- 自定义类型的Lambda表达式
- 匿名内部类形式
public class LambdaDemo {
public static void main(String[] args) {
print(new MyMath() {
@Override
public int sum(int x, int y) {
return x + y;
}
}, 100, 200);
}
public static void print(MyMath m, int x, int y) {
int num = m.sum(x, y);
System.out.println(num);
}
static interface MyMath {
int sum(int x, int y);
}
}
- Lambda表达式形式
public class LambdaDemo {
public static void main(String[] args) {
print((int x, int y) -> {//传入参数x, y
return x + y;
}, 100, 200);
}
public static void print(MyMath m, int x, int y) {
int num = m.sum(x, y);
System.out.println(num);
}
static interface MyMath {
int sum(int x, int y);
}
}
写于2021-08-08
41万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
