Java多线程探究【一线程简介、实现】

ゞ浴缸里的玫瑰 2024-04-01 13:24 92阅读 0赞

> ## 前言 ##
> 
>  *  本文是学自狂神说java整理的笔记，并非里面的内容都有认真的整理、代码也有认真的练习
>  *  本文仅供学习和交流之用，禁止非商业用途

#### 文章目录 ####

*  前言
 *  一 线程简介
 *  二 线程实现（重点）
 *   *  2.1 线程创建
     *  \*\*\*2.2 方式一：继承Thread类\*\*\*
     *  2.3 run开启线程
     *  2.4 start开启线程
     *  2.5 结论
     *  2.6 网络图片下载案例【Thread】
     *  \*\*\*2.7 方式二：实现Runnable接口【推荐】\*\*\*
     *  2.8 网络图片下载案例【Runnable】
     *  2.9 小结
     *  2.10 初识并发问题
     *   *  2.10.1 案例：抢票
         *  2.10.2 龟兔赛跑【Race】
     *  2.11 方式三：实现Callable接口【拓展、了解】
     *   *  2.11.1 图片下载
     *  2.12 静态代理：Thread
     *   *  2.12.1 结婚案例
         *  2.12.2 提升理解：Thread&Runnable
 *  三 Lambda表达式
 *   *  3.1 前提·热身
     *  3.2 函数式接口
     *  3.3 简化之路——lambda
     *  3.4 无参案例
     *  3.5 有参案例

## 一 线程简介 ##

*  ***程序：指令和数据的有序集合，其本身没有任何运行和含义，是一个静态的概念。***
 *  ***进程(Process)：执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。***
 *  ***线程(THread)：cpu调度和执行的单位。***
 *  ***通常在一个进程中可以包含若干个线程。当然一个进程中至少有一个线程，不然没有存在的意义。***

> ***多线程是模拟出来的，真正的多线程是指有多个cpu***，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

*  ***线程就是独立的执行路径。***
 *  ***在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程。***
 *  ***main()称之为主线程，为系统的入口，用于执行整个程序。***
 *  ***在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。***
 *  ***对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。***
 *  ***线程会带来额外的开销，如cpu调度时间，并发控制开销。***
 *  ***每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。***

## 二 线程实现（重点） ##

### 2.1 线程创建 ###

*  三种创建方式  
    ![在这里插入图片描述][159f4dc5f1414d79b3b545e8de98d947.png]

### ***2.2 方式一：继承Thread类*** ###

![ad6da4fec1484c868c035b10ab6c9655.png][]  
![在这里插入图片描述][dce4563b375b454ca07d5acfdb768e6f.png]

1.  自定义线程类继承Thread类。
2.  重写run0方法，编写线程执行体。
3.  创建线程对象，调用start0方法启动线程。

### 2.3 run开启线程 ###

package 多线程.Day01;
    
    /**
     * @author 缘友一世
     * date 2022/11/1-22:09
     */
    //创建线程方式一：继承Thread类,重写run()方法，调用start开启线程
    public class TestThread1 extends Thread{
        
        @Override
        public void run() {
        
            //run方法线程体
            for (int i=0;i<10;i++) {
        
                System.out.println("我在看代码"+i);
            }
        }
    
        public static void main(String[] args) {
        
            //main线程，主线程
            //创建一个线程对象
            TestThread1 testThread1 = new TestThread1();
            //调用start方法开启线程
            testThread1.run();
            for(int i=0;i<10;i++) {
        
                System.out.println("我在主线程"+i);
            }
        }
    }

![在这里插入图片描述][1ea79f341c054dff9470c36c765b9807.png]

### 2.4 start开启线程 ###

package 多线程.Day01;
    
    /**
     * @author 缘友一世
     * date 2022/11/1-22:09
     */
    //创建线程方式一：继承Thread类,重写run()方法，调用start开启线程
    public class TestThread1 extends Thread{
        
        @Override
        public void run() {
        
            //run方法线程体
            for (int i=0;i<10;i++) {
        
                System.out.println("我在看代码"+i);
            }
        }
    
        public static void main(String[] args) {
        
            //main线程，主线程
            //创建一个线程对象
            TestThread1 testThread1 = new TestThread1();
            //调用start方法开启线程
            testThread1.start();
            for(int i=0;i<10;i++) {
        
                System.out.println("我在主线程"+i);
            }
        }
    }

![在这里插入图片描述][aa681109b6ed43f6ab9585642460cc9a.png]

### 2.5 结论 ###

*  ***线程不一定立即执行，CPU安排调度。***

### 2.6 网络图片下载案例【Thread】 ###

package 多线程.Day01;
    
    import org.apache.commons.io.FileUtils;
    
    import java.io.File;
    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.net.URL;
    
    /**
     * @author 缘友一世
     * date 2022/11/1-22:28
     */
    //练习Thread，实现多线程同步下载图片
    public class TestThread2 extends Thread{
        
    
        private String url;//网络图片地址
        private String name;//保存的文件名
    
        public TestThread2(String url, String name) {
        
            this.url = url;
            this.name = name;
        }
    
        //下载文件的执行体
        @Override
        public void run() {
        
            WebDownloader webDownloader = new WebDownloader();
            try {
        
                webDownloader.downloader(url,name);
                System.out.println("成功下载文件"+name);
            } catch (MalformedURLException e) {
        
                throw new RuntimeException(e);
            }
        }
    
        public static void main(String[] args) {
        
            TestThread2 t1 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10240.jpg");
            TestThread2 t2 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10241.jpg");
            TestThread2 t3 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10242.jpg");
            t1.start();
            t2.start();
            t3.start();
    
        }
    }
    class WebDownloader{
        
        public void downloader(String url,String name) throws MalformedURLException {
        
            try {
        
                FileUtils.copyURLToFile(new URL(url),new File(name));
            } catch (IOException e) {
        
                throw new RuntimeException(e);
            }
        }
    }

![在这里插入图片描述][cab651bfab1d48a49b0500593adf4a29.png]  
![在这里插入图片描述][b05069e264d5467296b26cc52fbc9008.png]

*  start并行执行，它的顺序并不固定。谁先执行完，谁就是第一名。

### ***2.7 方式二：实现Runnable接口【推荐】*** ###

*  定义MyRunnable类实现Runnable接口
 *  实现run0方法，编写线程执行体
 *  创建线程对象，调用start(）方法启动线程

package 多线程.Day01;
    
    /**
     * @author 缘友一世
     * date 2022/11/1-22:53
     */
    //创建线程的方式二：实现runnable接口，重写run方法，执行线程需要放入到runnable接口实现类，调用start方法
    public class TestThread3 implements Runnable{
        
    
        @Override
        public void run() {
        
            //线程体
            for(int i=0;i<10;i++) {
        
                System.out.print("我数数"+i+" ");
            }
        }
    
        public static void main(String[] args) {
        
            //创建runnable接口实现类对象
            TestThread3 testThread3 = new TestThread3();
            //创建线程对象，通过线程对象来开启我们的线程，代理
            // Thread thread = new Thread(testThread3);
            // //启动
            // thread.start();
            new Thread(testThread3).start();
            for(int i=0;i<10;i++) {
        
                System.out.print("我看书"+i+" ");
            }
        }
    }

![在这里插入图片描述][b91bcc1782dc422cac20c2f0346cb41f.png]

*  推荐使用Runnable对象,因为Java单继承的局限性。

### 2.8 网络图片下载案例【Runnable】 ###

package 多线程.Day01;
    
    import org.apache.commons.io.FileUtils;
    
    import java.io.File;
    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.net.URL;
    
    /**
     * @author 缘友一世
     * date 2022/11/1-22:28
     */
    //练习Thread，实现多线程同步下载图片
    public class TestThread4 implements Runnable{
        
    
        private String url;//网络图片地址
        private String name;//保存的文件名
    
        public TestThread4(String url, String name) {
        
            this.url = url;
            this.name = name;
        }
    
        //下载文件的执行体
        @Override
        public void run() {
        
            WebDownloader2 webDownloader = new WebDownloader2();
            try {
        
                webDownloader.downloader(url,name);
                System.out.println("成功下载文件"+name);
            } catch (MalformedURLException e) {
        
                throw new RuntimeException(e);
            }
        }
    
        public static void main(String[] args) {
        
            TestThread2 t1 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10240.jpg");
            TestThread2 t2 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10241.jpg");
            TestThread2 t3 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10242.jpg");
            new Thread(t1).start();
            new Thread(t2).start();
            new Thread(t3).start();
    
        }
    }
    class WebDownloader2{
        
        public void downloader(String url,String name) throws MalformedURLException {
        
            try {
        
                FileUtils.copyURLToFile(new URL(url),new File(name));
            } catch (IOException e) {
        
                throw new RuntimeException(e);
            }
        }
    }

![在这里插入图片描述][e1a5d9155746444280adaca3cff2fd31.png]

### 2.9 小结 ###

*  继承Thread类
    
     *  子类继承Thread类具备多线程能力
     *  启动线程：子类对象.start()
     *  不建议使用：避免OOP【Object Oriented(面向) Programming】单继承局限性.
 *  实现Runnable接口
    
     *  实现接口Runnable具有多线程能力
     *  启动线程：传入目标对象+Thread对象.start()
     *  ***推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。***

//一份资源
    StartThread station=newStartThread();
    //多个代理
    newThread(station，name:小明”).start();
    newThread(station，name:“老师”).start();
    newThread(station，name:小红”).start();

### 2.10 初识并发问题 ###

#### 2.10.1 案例：抢票 ####

package 多线程.Day01;
    
    /**
     * @author 缘友一世
     * date 2022/11/2-9:11
     */
    //多个线程同时操作同一个对象
    //买票问题
    //问题：多个线程操作同一个资源的情况下，线程不安全，数据絮乱
    public class TestThread5 implements Runnable{
        
    
        /**票数*/
        private int ticketNums=10;
        @Override
        public void run() {
        
            while(ticketNums>=0) {
        
                if(ticketNums==0) {
        
                    break;
                }
                try {
        
                    Thread.sleep(200);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
            }
        }
    
        public static void main(String[] args) {
        
            TestThread5 ticket = new TestThread5();
            new Thread(ticket,"小明").start();
            new Thread(ticket,"小亮").start();
            new Thread(ticket,"小光").start();
            new Thread(ticket,"小红").start();
        }
    }

![在这里插入图片描述][a27dd6f2f4d54811bfb865b8315da776.png]

#### 2.10.2 龟兔赛跑【Race】 ####

1.  首先来个赛道距离,然后要离终点越来越近
2.  判断比赛是否结束
3.  打印出胜利老
4.  龟免赛跑开始
5.  故事中是乌龟赢的，兔子需要睡觉，所以我们来模拟免子睡觉
6.  最终，乌龟赢得比赛

package 多线程.Day01;
    
    /**
     * @author 缘友一世
     * date 2022/11/2-9:40
     */
    public class TestThread6 implements Runnable{
        
        /**胜利者*/
        private static String winner;
        @Override
        public void run() {
        
            for(int i=1;i<=100;i++) {
        
                //兔子每20步要休息一下
                if(Thread.currentThread().getName().equals("兔子") && i%20==0) {
        
                    try {
        
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                }
                System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
                //判断比赛是否结束，结束就终止程序
                if(gameOver(i)) {
        
                    break;
                }
            }
        }
        //判断比赛是否结束
        private boolean gameOver(int steps) {
        
            //判断是否有胜利者
            if(winner!=null) {
        //已经存在胜利者了
                return true;
            }{
        
               if(steps>=100) {
        
                   winner=Thread.currentThread().getName();
                   System.out.println("胜利者是"+winner);
                   return true;
               }
            }
            return false;
        }
    
        public static void main(String[] args) {
        
            TestThread6 race = new TestThread6();
            new Thread(race,"乌龟").start();
            new Thread(race,"兔子").start();
        }
    }

![在这里插入图片描述][fd6a3c4d56194ab7995691d255ac5855.png]  
![在这里插入图片描述][3c1115f583fa44969eaab3ecf7cd6953.png]

### 2.11 方式三：实现Callable接口【拓展、了解】 ###

1.  实现callable接口，需要返回值类型
2.  重写call方法，需要抛出异常
3.  创建目标对象
4.  创建执行服务：ExecutorService ser=Executors.newFixedThreadPool(1);
5.  提交执行：Futureresult1=ser.submit(t1);
6.  获取结果：booleanr1=result1.get()
7.  关闭服务：Ser.shutdownNow();

#### 2.11.1 图片下载 ####

package 多线程.Day01;
    
    import org.apache.commons.io.FileUtils;
    
    import java.io.File;
    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.concurrent.*;
    
    /**
     * @author 缘友一世
     * date 2022/11/2-17:11
     */
    //创建线程方式三：实现callable接口
    public class TestCallable implements Callable<Boolean> {
        
        private String url;//网络图片地址
        private String name;//保存的文件名
    
        public TestCallable(String url, String name) {
        
            this.url = url;
            this.name = name;
        }
    
        //下载文件的执行体
        @Override
        public Boolean call() {
        
            WebDownloader webDownloader = new WebDownloader();
            try {
        
                webDownloader.downloader(url,name);
                System.out.println("成功下载文件"+name);
                return true;
            } catch (MalformedURLException e) {
        
                throw new RuntimeException(e);
            }
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            TestCallable t1 = new TestCallable("https://img0.baidu.com/it/u=1348230343,3476037199&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500","sky1.jpg");
            TestCallable t2 = new TestCallable("https://img0.baidu.com/it/u=1348230343,3476037199&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500","sky2.jpg");
            TestCallable t3 = new TestCallable("https://img0.baidu.com/it/u=1348230343,3476037199&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500","sky3.jpg");
            //创建执行服务
            ExecutorService ser = Executors.newFixedThreadPool(3);
            //提交执行
            Future<Boolean> r1 = ser.submit(t1);
            Future<Boolean> r2 = ser.submit(t2);
            Future<Boolean> r3 = ser.submit(t3);
            //获取结果
            Boolean res1 = r1.get();
            Boolean res2 = r2.get();
            Boolean res3 = r3.get();
            //关闭服务
            ser.shutdownNow();
        }
    }
    class WebDownloader3{
        
        public void downloader(String url,String name) throws MalformedURLException {
        
            try {
        
                FileUtils.copyURLToFile(new URL(url),new File(name));
            } catch (IOException e) {
        
                throw new RuntimeException(e);
            }
        }
    }

![在这里插入图片描述][c0aa3cca09e24bec87b0a781f2a8208b.png]

### 2.12 静态代理：Thread ###

![在这里插入图片描述][4968258c8fc9461199d48f7008a7945e.png]

*  你：真实角色
 *  婚庆公司：代理你，帮你处理结婚的事情
 *  结婚：实现结婚接口即可

#### 2.12.1 结婚案例 ####

package 多线程.Day01;
    
    /**
     * @author 缘友一世
     * date 2022/11/2-18:13
     */
    
    //静态代理模式总结
    //真实对象和代理对象都要实现同一个接口
    //该对象要代理真实角色
        //好处
        //代理象可以做很多真实对象做不了的事情
        //真实对象专注做自己的事情。
    public class StaticProxy {
        
        public static void main(String[] args) {
        
            /*
            new Thread(new Runnable() {
                @Override
                public void run() {
    
                }
            }).start();
            */
            new Thread(()-> System.out.println("我爱你")).start();
    
            //WeddingCompany weddingCompany = new WeddingCompany(new You());
            //weddingCompany.HappyMary();
            new WeddingCompany(new You()).HappyMary();
        }
    }
    interface Marry{
        
        void HappyMary();
    }
    //真实角色
    class You implements Marry {
        
        @Override
        public void HappyMary() {
        
            System.out.println("小王子结婚了！");
        }
    }
    //代理角色，帮助结婚
    class WeddingCompany implements Marry{
        
        //真实目标角色
        private Marry target;
    
        public WeddingCompany(Marry target) {
        
            this.target = target;
        }
    
        @Override
        public void HappyMary() {
        
            before();
            this.target.HappyMary();
            after();
        }
        private void before() {
        
            System.out.println("结婚之前的事情处理");
        }
        private void after() {
        
            System.out.println("结婚之后的事情处理");
        }
    }

![在这里插入图片描述][5a5bda6cdff84e0ab1e5dc2ef4d0c62e.png]

#### 2.12.2 提升理解：Thread&Runnable ####

*  两者就是代理的关系，Thread代理Runnable并实现其run方法，然后再本类中使用start方法调用  
    ![在这里插入图片描述][0c4a5a0c4f8e45849951d862289a96f4.png]

## 三 Lambda表达式 ##

### 3.1 前提·热身 ###

![在这里插入图片描述][87e54c66a41d4e96a6f68cb6a319e33e.png]  
![在这里插入图片描述][cbc6467b2f144ba795d62f73955e3d34.png]

>  *  再有些时候，我们遇到某些类只是使用一次，刚开始我们定义在外部【外部类】，然后改进到内部类【匿名内部类】，这样就会造成匿名内部类定义过多。

*  使用lambda表达式的原因
    
     *  避免著名内部类定义过多
     *  可以使代码简洁
     *  去掉了一堆没有意义的代码，只留下核心的逻辑

### 3.2 函数式接口 ###

*  Functional Interface(函数式接口)是学习Java 8 Lamda表达式的关键所在。
 *  函数式接口的定义
    
     *  任何接口如果只包含唯1个抽象方法，那么它就是一个函数式接口。
     *  对于函数式接口，就可以使用Lambda表达式来创建该接口的对象。  
        ![在这里插入图片描述][171764ebc5b642a697fd0e6f77536fd5.png]

### 3.3 简化之路——lambda ###

*  有关于java内部类、静态内部类、局部内部类、匿名内部类的内容请参看详细的介绍[java内部类精讲][java]

### 3.4 无参案例 ###

package 多线程.Lambda;
    
    /**
     * @author 缘友一世
     * date 2022/11/2-19:06
     */
    /*
    推到lambda表达式
     */
    public class TestLambda1 {
        
        //3 静态内部类
        static class Like2 implements ILike {
        
            @Override
            public void Lambda() {
        
                System.out.println("2 静态内部类的lambda");
            }
        }
        public static void main(String[] args) {
        
            ILike like = new Like();
            like.Lambda();
    
            like = new Like2();
            like.Lambda();
    
            //4 局部内部类
            class Like3 implements ILike {
        
                @Override
                public void Lambda() {
        
                    System.out.println("3 局部内部类lambda");
                }
            }
            like=new Like3();
            like.Lambda();
    
            //5 匿名内部类
            like=new ILike() {
        
                @Override
                public void Lambda() {
        
                    System.out.println("4 匿名内部类的lambda");
                }
            };
            like.Lambda();
    
            //6 用lambda简化 舍弃接口和方法
            ILike like2=()->{
        
                System.out.println("5 用lambda简化的lambda");
            };
            like2.Lambda();
        }
    }
    //1 定义一个函数式接口
    interface ILike{
        
        void Lambda();
    }
    //2 实现类
    class Like implements ILike {
        
        @Override
        public void Lambda() {
        
            System.out.println("1 外部实现类的lambda");
        }
    }

![在这里插入图片描述][edaaf627778a438e98ccb75cfc6e2b97.png]

### 3.5 有参案例 ###

package 多线程.Lambda;
    
    /**
     * @author 缘友一世
     * date 2022/11/2-19:52
     */
    //1 定义函数式接口
    interface ILove{
        
        void love(String name1,String name2,String name3);
    }
    public class TestLambda2 {
        
    
        public static void main(String[] args) {
        
            ILove iLove=null;
            //1 匿名内部类
            iLove = new ILove() {
        
                @Override
                public void love(String name1, String name2, String name3) {
        
                    System.out.println("匿名内部类-->" + name1 + "和" + name2 + "爱上了" + name3);
                }
            };
            iLove.love("小黄","小黑","小花");
    
    
            //前提是接口为函数式接口。
            //1 lambda简化
            //Book参数也可以去掉参数类型。 要去掉，必须都去掉
            iLove=(String name1,String name2,String name3) -> {
        
                System.out.println("lambda简化1-->"+name1+"和"+name2+"爱上了"+name3);
            };
            iLove.love("小黄","小黑","小花");
            //2 简化括号
            iLove=(name1,name2,name3)->{
        
                System.out.println("lambda简化2-->"+name1+"和"+name2+"爱上了"+name3);
            };
            iLove.love("小黄","小黑","小花");
            //3 去掉花括号【代码只有一行的情况下】
            iLove=(name1,name2,name3)->System.out.println("lambda简化3-->"+name1+"和"+name2+"爱上了"+name3);
            iLove.love("小黄","小黑","小花");
            //如果有多行，那么就用代码块包裹。
            iLove=(name1,name2,name3)->{
        
                System.out.println("lambda简化4-->"+name1+"和"+name2+"爱上了"+name3);
                System.out.println("lambda简化4-->"+name1+"和"+name2+"抛弃了"+name3);
            };
            iLove.love("小黄","小黑","小花");
    
        }
    }

![在这里插入图片描述][cb5c9602574d41acaafd415b7e781284.png]  
![在这里插入图片描述][5640052dde5b49988b452d7fffc67470.png_pic_center]

[159f4dc5f1414d79b3b545e8de98d947.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/685856efd3244d778ec59a72cb276ae7.png
[ad6da4fec1484c868c035b10ab6c9655.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d9e9aeafbd824ab99a24707738b50ac8.png
[dce4563b375b454ca07d5acfdb768e6f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/1c065fe8690c4b71aa51650a0510537d.png
[1ea79f341c054dff9470c36c765b9807.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/66a779e500704dc2a2a658031299ecd7.png
[aa681109b6ed43f6ab9585642460cc9a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b9e3fb3709cd4a20b619663caabd3cca.png
[cab651bfab1d48a49b0500593adf4a29.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3d40ab779bb443a0a286989a342df100.png
[b05069e264d5467296b26cc52fbc9008.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7b702e618701408f81a2754c7f4c0dfe.png
[b91bcc1782dc422cac20c2f0346cb41f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/54b5b2919a574c00a26827c0ff5fdde1.png
[e1a5d9155746444280adaca3cff2fd31.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/4a5bd2b18a4049d3a183fb15356bb35f.png
[a27dd6f2f4d54811bfb865b8315da776.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6e33b9b6934545b3bd60dfc2e33df56b.png
[fd6a3c4d56194ab7995691d255ac5855.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c29b4c63c2144722a61ce6c6d2006a81.png
[3c1115f583fa44969eaab3ecf7cd6953.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6346be55fba641868208924dd64f95d3.png
[c0aa3cca09e24bec87b0a781f2a8208b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d7cc2ddfd0de45b39dec54c63b3c82dd.png
[4968258c8fc9461199d48f7008a7945e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c0f98cf05215408b99b4d486001fa7bc.png
[5a5bda6cdff84e0ab1e5dc2ef4d0c62e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0f349dc642524c5e9a60f0318ef56b3c.png
[0c4a5a0c4f8e45849951d862289a96f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8e22fd18980b42a3b0457791de76d66d.png
[87e54c66a41d4e96a6f68cb6a319e33e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c435c4cc346b451ca717a412c2891af3.png
[cbc6467b2f144ba795d62f73955e3d34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/656d6ff97fc04ff0988633472b8b0b47.png
[171764ebc5b642a697fd0e6f77536fd5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/65ec80bba16747989977078e3aac2b22.png
[java]: https://blog.csdn.net/yang2330648064/article/details/127213544
[edaaf627778a438e98ccb75cfc6e2b97.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/db480cf861a24b479fb2092c936cdfa6.png
[cb5c9602574d41acaafd415b7e781284.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6ebf6bee94c2434b9c9557c89a6b3fb6.png
[5640052dde5b49988b452d7fffc67470.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/87e5ebe3a16f443d8d043c82db9aa6f4.png