多线程,了解-概念-实现方式-常见方法-安全问题-死锁-生产者消费者

news/2024/3/29 18:43:59/文章来源:https://blog.csdn.net/weixin_46589095/article/details/128106157

了解

简单了解多线程

是指从软件或者硬件上实现多个线程并发执行的技术。 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程,提升性能。

简单了解多线程

                                               

 简单了解多线程

                                                  

 简单了解多线程

                                                  

 简单了解多线程

                                                  

概念

 线程相关的概念

                 并行:在同一时刻,有多个指令在多个CPU上同时执行。

                 并发:在同一时刻,有多个指令在单个CPU上交替执行。

并发和并行

                  并行:在同一时刻,有多个指令在多个CPU上同时执行。

 

 并发和并行

                 并发:在同一时刻,有多个指令在单个CPU上交替执行。

  并发和并行

                  并发:在同一时刻,有多个指令在单个CPU上交替执行。

 

 并发和并行

                  并发:在同一时刻,有多个指令在单个CPU上交替执行。

 

进程和线程

      进程:是正在运行的软件        

独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位。

动态性:进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的。

并发性:任何进程都可以同其他进程一起并发执行

 进程和线程

 线程:是进程中的单个顺序控制流,是一条执行路径。

                                            

                                           

                                           

                                          

                                           

  

进程和线程

      线程:是进程中的单个顺序控制流,是一条执行路径。  

单线程:一个进程如果只有一条执行路径,则称为单线程程序

多线程:一个进程如果有多条执行路径,则称为多线程程序

 小结

      并发和并行

并行:在同一时刻,有多个指令在多个CPU上同时执行。

并发:在同一时刻,有多个指令在单个CPU上交替执行。

       进程和线程

进程:就是操作系统中正在运行的一个应用程序。

线程:就是应用程序中做的事情。比如:360软件中的杀毒,扫描木马,清理垃圾。

实现方式

多线程的实现方式

多线程的实现方案

继承Thread类的方式进行实现

实现Runnable接口的方式进行实现

利用Callable和Future接口方式实现

package com.itheima.threaddemo1;public class MyThread extends Thread{@Overridepublic void run() {//代码就是线程在开启之后执行的代码for (int i = 0; i < 100; i++) {System.out.println("线程开启了" + i);}}
}package com.itheima.threaddemo1;public class Demo {public static void main(String[] args) {//创建一个线程对象MyThread t1 = new MyThread();//创建一个线程对象MyThread t2 = new MyThread();//t1.run();//表示的仅仅是创建对象,用对象去调用方法,并没有开启线程.//t2.run();//开启一条线程t1.start();//开启第二条线程t2.start();}
}
线程开启了90
线程开启了99
线程开启了91
线程开启了92
线程开启了93
线程开启了94
线程开启了95
线程开启了96
线程开启了97
线程开启了98
线程开启了99Process finished with exit code 0

 

方案1:继承Thread类

定义一个类MyThread继承Thread类

在MyThread类中重写run()方法

创建MyThread类的对象

启动线程(如上)

两个小问题:

为什么要重写run()方法?

         因为run()是用来封装被线程执行的代码

run()方法和start()方法的区别?

         run():封装线程执行的代码,直接调用,相当于普通方法的调用,并没有开启线程。          start():启动线程;然后由JVM调用此线程的run()方法

多线程的实现方式

方式2:实现Runnable接口

定义一个类MyRunnable实现Runnable接口

在MyRunnable类中重写run()方法

创建MyRunnable类的对象

创建Thread类的对象,把MyRunnable对象作为构造方法的参数 启动线程

package com.itheima.threaddemo2;public class MyRunnable implements Runnable{@Overridepublic void run() {//线程启动后执行的代码for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + "第二种方式实现多线程" + i);}}
}

 测试类:

package com.itheima.threaddemo2;public class Demo {public static void main(String[] args) {//创建了一个参数的对象MyRunnable mr = new MyRunnable();//创建了一个线程对象,并把参数传递给这个线程.//在线程启动之后,执行的就是参数里面的run方法Thread t1 = new Thread(mr);//开启线程t1.start();MyRunnable mr2 = new MyRunnable();Thread t2 = new Thread(mr2);t2.start();}
}
Thread-0第二种方式实现多线程96
Thread-1第二种方式实现多线程96
Thread-0第二种方式实现多线程97
Thread-1第二种方式实现多线程97
Thread-0第二种方式实现多线程98
Thread-1第二种方式实现多线程98
Thread-0第二种方式实现多线程99
Thread-1第二种方式实现多线程99Process finished with exit code 0

方式3:Callable和Future

定义一个类MyCallable实现Callable接口

在MyCallable类中重写call()方法 创建MyCallable类的对象

创建Future的实现类FutureTask对象,把MyCallable对象作为构造方法的参数

创建Thread类的对象,把FutureTask对象作为构造方法的参数

启动线程

再调用get方法,就可以获取线程结束之后的结果。

package com.itheima.threaddemo3;import java.util.concurrent.Callable;public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {for (int i = 0; i < 100; i++) {System.out.println("跟女孩表白" + i);}//返回值就表示线程运行完毕之后的结果return "答应";}
}

 测试类:

package com.itheima.threaddemo3;import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class Demo {public static void main(String[] args) throws ExecutionException, InterruptedException {//线程开启之后需要执行里面的call方法MyCallable mc = new MyCallable();//Thread t1 = new Thread(mc);//可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象FutureTask<String> ft = new FutureTask<>(mc);//创建线程对象Thread t1 = new Thread(ft);String s = ft.get();//开启线程t1.start();//String s = ft.get();System.out.println(s);}
}

 正确的代码:

  public static void main(String[] args) throws ExecutionException, InterruptedException {//String s = ft.get();//开启线程t1.start();String s = ft.get();System.out.println(s);}

 三种方式的对比

优点

缺点

实现Runnable、

Callable接口

扩展性强,实现该接口的同时还可以继承其他的类。

编程相对复杂,不能直接使用Thread类中的方法

继承Thread类

编程比较简单,可以直接使用Thread类中的方法

可以扩展性较差,

不能再继承其他的类

常见方法

线程类的常见方法

获取和设置线程名称

获取线程的名字

  • String getName​():返回此线程的名称

Thread类中设置线程的名字

  • void setName​(String name):将此线程的名称更改为等于参数 name
  • 通过构造方法也可以设置线程名称
package com.itheima.threaddemo4;public class MyThread extends Thread {public MyThread() {}public MyThread(String name) {super(name);}@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + "@@@" + i);}}
}

 测试类:

package com.itheima.threaddemo4;public class Demo {//1,线程是有默认名字的,格式:Thread-编号public static void main(String[] args) {MyThread t1 = new MyThread("小蔡");MyThread t2 = new MyThread("小强");//t1.setName("小蔡");//t2.setName("小强");t1.start();t2.start();}
}
小强@@@97
小蔡@@@98
小强@@@98
小蔡@@@99
小强@@@99Process finished with exit code 0

获得当前线程的对象

  • public static Thread currentThread():返回对当前正在执行的线程对象的引用
package com.itheima.threaddemo5;public class Demo {public static void main(String[] args) {String name = Thread.currentThread().getName();System.out.println(name);}
}

线程休眠

  • public static void sleep(long time):让线程休眠指定的时间,单位为毫秒。
package com.itheima.threaddemo6;public class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 0; i < 100; i++) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "---" + i);}}
}

测试类:(获取线程,休眠,获取名称)

package com.itheima.threaddemo6;public class Demo {public static void main(String[] args) throws InterruptedException {/*System.out.println("睡觉前");Thread.sleep(3000);System.out.println("睡醒了");*/MyRunnable mr = new MyRunnable();Thread t1 = new Thread(mr);Thread t2 = new Thread(mr);t1.start();t2.start();}
}
Thread-0---97
Thread-1---98
Thread-0---98
Thread-0---99
Thread-1---99Process finished with exit code 0

线程调度

多线程的并发运行:    

计算机中的CPU,在任意时刻只能执行一条机器指令。每个线程只有获得CPU的使用权才能执行代码。      

 各个线程轮流获得CPU的使用权,分别执行各自的任务。

线程有两种调度模型

  • 分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程      

        获取的 CPU 时间片相对多一些

 Java使用的是抢占式调度模型

                                CPU

 线程的优先级

        public final void setPriority(int newPriority)    设置线程的优先级

        public final int getPriority()                              获取线程的优先级

package com.itheima.threaddemo7;import java.util.concurrent.Callable;public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + "---" + i);}return "线程执行完毕了";}
}
import java.util.concurrent.FutureTask;public class Demo {public static void main(String[] args) {//优先级: 1 - 10 默认值:5MyCallable mc = new MyCallable();FutureTask<String> ft = new FutureTask<>(mc);Thread t1 = new Thread(ft);t1.setName("飞机");t1.setPriority(10);//System.out.println(t1.getPriority());//5t1.start();MyCallable mc2 = new MyCallable();FutureTask<String> ft2 = new FutureTask<>(mc2);Thread t2 = new Thread(ft2);t2.setName("坦克");t2.setPriority(1);//System.out.println(t2.getPriority());//5t2.start();}
}

 后台线程/守护线程

public final void setDaemon(boolean on):设置为守护线程

package com.itheima.threaddemo8;public class MyThread1 extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + "---" + i);}}
}
package com.itheima.threaddemo8;public class MyThread2 extends Thread {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + "---" + i);}}
}
package com.itheima.threaddemo8;public class Demo {public static void main(String[] args) {MyThread1 t1 = new MyThread1();MyThread2 t2 = new MyThread2();t1.setName("女神");t2.setName("备胎");//把第二个线程设置为守护线程//当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.t2.setDaemon(true);t1.start();t2.start();}
}
女神---8
备胎---8
女神---9
备胎---9
备胎---10
备胎---11
备胎---12
备胎---13
Process finished with exit code 0

 线程生命周期

安全问题

线程的安全问题

 需求:某电影院目前正在上映国产大片,共有100张票,而它有3个窗口卖票,请设计一个程序模拟该电影院卖票

思路:

①定义一个类Ticket实现Runnable接口,里面定义一个成员变量:private int ticketCount = 100;

② 在Ticket类中重写run()方法实现卖票,代码步骤如下

      A:判断票数大于0,就卖票,并告知是哪个窗口卖的

      B:票数要减1

      C:卖光之后,线程停止

③ 定义一个测试类TicketDemo,里面有main方法,代码步骤如下

    A:创建Ticket类的对象

    B:创建三个Thread类的对象,把Ticket对象作为构造方法的参数,并给出对应的窗口名称

    C:启动线程

package com.itheima.threaddemo9;public class Ticket implements Runnable {//票的数量private int ticket = 100;private Object obj = new Object();@Overridepublic void run() {while(true){synchronized (obj){//多个线程必须使用同一把锁.if(ticket <= 0){//卖完了break;}else{try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}ticket--;System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");}}}}
}
package com.itheima.threaddemo9;public class Demo {public static void main(String[] args) {/*Ticket ticket1 = new Ticket();Ticket ticket2 = new Ticket();Ticket ticket3 = new Ticket();Thread t1 = new Thread(ticket1);Thread t2 = new Thread(ticket2);Thread t3 = new Thread(ticket3);*/Ticket ticket = new Ticket();Thread t1 = new Thread(ticket);Thread t2 = new Thread(ticket);Thread t3 = new Thread(ticket);t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");t1.start();t2.start();t3.start();}
}

 改造:

    @Overridepublic void run() {while (true) {// 当前这个this表示的是Ticket的票对象,我们在测试类中创建了几个票对象?// 答: 1个,所以能保证多个线程使用的是同一个锁对象synchronized (this){if (ticket <= 0) {//卖完了break;} else {System.out.println(Thread.currentThread().getName() + "正在卖" + ticket + "号票");ticket--;}}}}

卖票案例的思考

刚才讲解了电影院卖票程序,好像没有什么问题。但是在实际生活中,售票时出票也是需要时间的, 所以,在出售一张票的时候,需要一点时间的延迟,接下来我们去修改卖票程序中卖票的动作: 每次出票时间100毫秒,用sleep()方法实现

卖票出现了问题

        相同的票出现了多次

        出现了负数的票

问题原因: 

线程执行的随机性导致的

卖票案例数据安全问题的解决

卖票案例数据安全问题的解决

为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)

        多线程操作共享数据

如何解决多线程安全问题呢?

        基本思想:让程序没有安全问题的环境

怎么实现呢?

         把多条语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可

         Java提供了同步代码块的方式来解决

                                                                            

                                                                  

 

同步代码块

锁多条语句操作共享数据,可以使用同步代码块实现 

格式:        

synchronized(任意对象) {              

  多条语句操作共享数据的代码

 }

 默认情况是打开的,只要有一个线程进去执行代码了,锁就会关闭  

 当线程执行完出来了,锁才会自动打开

同步的好处和弊端 

好处:解决了多线程的数据安全问题

弊端:当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率   

同步方法 

同步方法:就是把synchronized关键字加到方法上

格式:

       修饰符 synchronized 返回值类型 方法名(方法参数) {    }

同步代码块和同步方法的区别:

同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码

同步代码块可以指定锁对象,同步方法不能指定锁对象 

同步方法的锁对象是什么呢?

this 

同步方法

同步静态方法:就是把synchronized关键字加到静态方法上

格式:

  修饰符 static synchronized 返回值类型 方法名(方法参数) {    }

同步静态方法的锁对象是什么呢?

类名.class

Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁, 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法

 void lock():获得锁

void unlock():释放锁

 Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来实例化

ReentrantLock的构造方法

ReentrantLock​():创建一个ReentrantLock的实例

死锁

死锁

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源,导致这些线程处于等待状态,无法前往执行。

 

 

 

 生产者消费者

生产者消费者模式概述

生产者消费者理想情况 

 

生产者等待 

 等待和唤醒的方法

为了体现生产和消费过程中的等待和唤醒,Java就提供了几个方法供我们使用,这几个方法在Object类中 Object类的等待和唤醒方法:

方法名

说明

void wait​()

导致当前线程等待,直到另一个线程调用该对象的 notify()方法或 notifyAll()方法

void notify​()

唤醒正在等待对象监视器的单个线程

void notifyAll​()

唤醒正在等待对象监视器的所有线程 

 阻塞队列实现等待唤醒机制

阻塞队列继承结构

 

 阻塞队列实现等待唤醒机制

BlockingQueue的核心方法:     

                put(anObject):将参数放入队列,如果放不进去会阻塞。     
                take():取出第一个数据,取不到会阻塞。

常见BlockingQueue:     

          ArrayBlockingQueue:底层是数组,有界。     

          LinkedBlockingQueue:底层是链表,无界。但不是真正的无界,最大为int的最大值。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.luyixian.cn/news_show_39037.aspx

如若内容造成侵权/违法违规/事实不符,请联系dt猫网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【车载开发系列】UDS诊断---电控单元复位 ($0x11)

【车载开发系列】UDS诊断—电控单元复位&#xff08;$0x11&#xff09; UDS诊断---电控单元复位&#xff08;$0x11&#xff09;【车载开发系列】UDS诊断---电控单元复位&#xff08;$0x11&#xff09;一.概念定义二.应用场景三.报文格式1&#xff09;请求2&#xff09;肯定响应…

Spark 3.0 - 8.ML Pipeline 之决策树原理与实战

目录 一.引言 二.决策树基础-信息熵 三.决策树的算法基础 - ID3 算法 四.ML 中决策树的构建 1.信息增益计算 2.连续属性划分 五.ML 决策树实战 1.Libsvm 数据与加载 2.StringIndexer 3.VectorIndexer 4.构建决策树与 Pipeline 5.测试与评估 6.获取决策树 六.总结…

基于PHP+MySQL企业网络推广平台系统的设计与实现

企业网络推广平台系统具有很强的信息指导性特征,采用PHP开发企业网络推广平台系统 给web带来了全新的动态效果,具有更加灵活和方便的交互性。在Internet中实现数据检索越来越容易,可以及时、全面地收集、存储大量的企业资源信息以及进行发布、浏览、搜索相关的信息。让企业、个…

C++ Reference: Standard C++ Library reference: Containers: list: list: cend

C官网参考链接&#xff1a;https://cplusplus.com/reference/list/list/cend/ 公有成员函数 <list> std::list::cend const_iterator cend() const noexcept; 返回结束的常量迭代器 返回一个指向容器结束后元素的const_iterator。 const_iterator是指向const内容的迭代…

Spring Boot FailureAnalyzer 应用场景

Spring Boot 自定义FailureAnalyzer 今天在学习Spring Boot 源码的过程中&#xff0c;在spring.factories 文件中无意中发现了FailureAnalyzer 这个接口。由于之前没有接触过&#xff0c;今天来学习一下 FailureAnalyzer 接口的作用。 在学习FailureAnalyzer之前, 我们先看以…

TMA三均线股票期货高频交易策略的R语言实现

趋势交易策略是至今应用最广泛以及最重要的投资策略之一&#xff0c;它的研究手段种类繁多&#xff0c;所运用的分析工具也纷繁复杂&#xff0c;其特长在于捕捉市场运动的大方向。股指期货市场瞬息万变&#xff0c;结合趋势分析方法&#xff0c;量化投资策略能够得到更有效的应…

Discourse 的左侧边栏可以修改吗

在默认的 Discourse 配置中&#xff0c;我们左侧的边栏可以根据自己的要求进行修改吗&#xff1f; 解决办法 针对自己登录的用户&#xff0c;你是可以自己调整左侧边栏的配置。 单击右上角你的个人头像&#xff0c;然后选择属性。 在切换的界面中&#xff0c;选择属性。 在出…

校园论坛(Java)——环境配置篇

校园论坛&#xff08;Java&#xff09;——环境配置篇 文章目录校园论坛&#xff08;Java&#xff09;——环境配置篇1、写在前面2、新建Maven项目2.1 引入相关依赖2.2 配置Tomcat环境3、项目发布测试4、项目代码5、参考资料1、写在前面 Windows版本&#xff1a;Windows10JDK版…

Python数据库编程之关系数据库API规范

Python关系数据库API规范 对于关系数据库的访问&#xff0c;Python社区已经制定出一个标准&#xff0c;称为Python Database API Specification。Mysql&#xff0c;Oracal等特定数据库模块遵从这一规范&#xff0c;而且可以添加更多特性。 高级数据库API定义了一组用于连接数…

YOLO V3 详解

YOLO V3 论文链接&#xff1a;YOLOv3: An Incremental Improvement 主要改进 Anchor: 9个大小的anchor&#xff0c;每个尺度分配3个anchor。Backbone改为Darknet-53, 引入了残差模块。引入了FPN&#xff0c;可以进行多个尺度的训练&#xff0c;同时对于小目标的检测有了一定…

R语言生存分析可视化分析

生存分析指的是一系列用来探究所感兴趣的事件的发生的时间的统计方法。 生存分析被用于各种领域&#xff0c;例如&#xff1a; 癌症研究为患者生存时间分析&#xff0c; “事件历史分析”的社会学 在工程的“故障时间分析”。 在癌症研究中&#xff0c;典型的研究问题如下…

Linux redict 输入输出重定向 详细使用方法 文件描述符

Linux redict 重定向 Linux 重定向 在 Linux 系统中&#xff0c;我们需要输入和输出让系统与外部进行交互&#xff0c;比如在我们使用鼠标、键盘等输入设备时其实就是通过输入的方式让数据进行系统中。而系统输出一般就会打印在显示器上、刻录光盘等等。而我们要讲的重定向也…

(二)DepthAI-python相关接口:OAK Pipeline

消息快播&#xff1a;OpenCV众筹了一款ROS2机器人rae&#xff0c;开源、功能强、上手简单。来瞅瞅~ 编辑&#xff1a;OAK中国 首发&#xff1a;oakchina.cn 喜欢的话&#xff0c;请多多&#x1f44d;⭐️✍ 内容可能会不定期更新&#xff0c;官网内容都是最新的&#xff0c;请查…

Meta-learning

基本理解 meta learning翻译为元学习&#xff0c;也可以被认为为learn to learn 元学习与传统机器学习的不同在哪里&#xff1f; 元学习与传统机器学习&#xff0c; 这里举个通俗的例子&#xff0c;拿来给大家分享&#xff1f; 把训练算法类比成学生在学校学习&#xff0c;传…

【华为上机真题 2022】字符串分隔

&#x1f388; 作者&#xff1a;Linux猿 &#x1f388; 简介&#xff1a;CSDN博客专家&#x1f3c6;&#xff0c;华为云享专家&#x1f3c6;&#xff0c;Linux、C/C、云计算、物联网、面试、刷题、算法尽管咨询我&#xff0c;关注我&#xff0c;有问题私聊&#xff01; &…

[附源码]计算机毕业设计springboot环境保护宣传网站

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…

后端存储实战课总结(上)

创建和更新订单 表设计 最少应该有以下几张表&#xff1a; 订单主表&#xff1a;保存订单基本信息订单商品表&#xff1a;保存订单中的商品信息订单支付表&#xff1a;保存订单支付和退款信息订单优惠表&#xff1a;保存订单的优惠信息 订单主表和字表是一对多关系&#xf…

1.1 统计学习方法的定义与分类

统计学习方法的定义与分类统计学习的概念统计学习的定义统计学习运用到的领域统计学习的步骤统计学习的分类统计学习的概念 统计学习的定义 统计学习 (Statistical Machine Learning) 是关于计算机基于数据构建概率统计模型并运用模型对数据进行预测与分析的一门学科。 以计…

第五站:操作符(终幕)(一些经典的题目)

目录 一、分析下面的代码 二、统计二进制中1的个数 解一&#xff1a;&#xff08;求出每一个二进制位&#xff0c;来统计1的个数&#xff09; 解二&#xff1a;&#xff08;利用左我们移或右移操作符和按位与&#xff09; 解三&#xff1a;&#xff08;效率最高的解法&…