JavaEE多线程(2)

news2024/10/24 20:15:10

在这里插入图片描述

文章目录

  • 1..多线程的安全
    • 1.1出现多线程不安全的原因
    • 1.2解决多线程不安全的⽅法
    • 1.3三种典型死锁场景
    • 1.4如何避免死锁问题
    • 2.线程等待通知机制
    • 2.1等待通知的作用
    • 2.2等待通知的方法——wait
    • 2.3唤醒wait的方法——notify

1…多线程的安全

1.1出现多线程不安全的原因

  1. 线程在系统中是随机调度，抢占式执⾏。
  2. 多个线程同时修改同⼀个变量
  3. 线程对变量的修改操作不是“原⼦”的
  4. 内存可⻅性问题
  5. 指令重排序、
    “原⼦”是什么？
    原⼦是指不可再拆分的最⼩单位，放到代码操作中就是⼀段代码对应⼀个cpu指令就是原⼦的，如果对应到多个cpu指令就不是原⼦的。

1.2解决多线程不安全的⽅法

从原因⼊⼿：

  1. 原因1由于是系统本⾝的原因⼈为⽆法⼲预。
  2. 原因2是⼀个解决多线程不安全的⽅法，但是只是在特定的场景下才可以实现。
  3. 原因3是解决多线程不安全最合适的⽅法，既然修改的这个操作不是⼀个原⼦，那我们只需要将这
    个不是“原⼦”的操作打包成⼀个原⼦的操作即可。
    引申出⼀个新的词“锁”
    我们可以通过锁来将之前不是原⼦操作打包成⼀个原⼦操作
    关于这个锁本⾝就是系统内核中的api，只不过是jvm将这个api封装了，为了让java可以更好的使⽤这
    个锁。
    关于锁主要操作的两个⽅⾯：
    1.加锁
    ⽐如对t1线程进⾏加锁，t2线程也要加锁，那么t2线程就会阻塞等待(互斥锁/竞争锁/锁冲突)
    2.解锁
    t1线程解锁之后，t2线程才可以进⾏加锁
    注意：此处的锁主要针对于锁对象，对于t1和t2线程是指的同⼀个锁对象，不是同⼀个锁对象那就没
    意义了。
    对锁的总结：
    1.两个操作⸺加锁，解锁
    2.锁的特性⸺互斥
    3.只有多个线程竞争同⼀把锁才会互斥，如果多个线程竞争不同的锁则不会产⽣互斥
    java中⽤⼀个关键字来描述锁⸺synchronized
    1.synchronized 怎么读？怎么拼写？
    synchronized
    2.synchronized()括号中写的是锁对象⸺锁对象可以是任意类实列出的对象
    注意：
    锁对象的⽤途只有⼀个，两个线程是否针对⼀个对象加锁
    如果是就会出现锁竞争/锁冲突/互斥，就会引起阻塞等待
    如果不是就不会出现锁竞争/锁冲突/互斥，就不会引起阻塞等待
    和对象具体是什么类型，和它内部有什么属性，有什么⽅法，接下来是否要操作这个对象，统统都没
    有关系
    3.synchronized下⾯跟着{}
    当进⼊到这个代码块就是对上述(锁对象)进⾏了加锁操作
    当出了代码块就是对上述(锁对象)进⾏了解锁操作
    以下代码就是两个线程针对同⼀个对象locker加锁，当t1线程加锁之后，t2想加锁只能阻塞等待，只有
    等到t1线程解锁之后，t2线程才有可能加锁成功
public static int count = 0;
//创建一个对象作为一个锁对象
public static void main(String[] args) throws InterruptedException {
    Object locker = new Object();
    Thread t1 = new Thread(()-> {
        for (int i = 1; i <= 5000; i++) {
            synchronized(locker) {
                count++;
            }
        }
    });
    Thread t2 = new Thread(()-> {
        for (int i = 1; i <=5000 ; i++) {
            synchronized(locker) {
                count++;
            }
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("count = "+ count);
}

以下代码就是两个线程对不同锁对象进行加锁，就不会产生锁冲突/锁竞争/互斥。

public static int count = 0;

public static void main(String[] args) throws InterruptedException {
    Object locker1 = new Object();
    Object locker2 = new Object();
    Thread t1 = new Thread(() -> {
        for (int i = 1; i <=5000 ; i++) {
            synchronized(locker1) {
                count++;
            }
        }
    });
    Thread t2 = new Thread(() -> {
        for (int i = 1; i <=5000 ; i++) {
            synchronized(locker2) {
                count++;
            }
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("count = " + count);
}

当t1线程解锁之后，不一定是t2线程拿到锁，有可能是其他线程拿到锁。
join与锁的区别：
join是一个线程完了，再让第二个线程执行。
锁只是针对加锁的那一块代码，就像上述代码中加锁的count++就会变成串行执行，但剩余的代码还是并发执行。
注意：加锁不是针对线程，而是针对共享资源的访问操作，比如现在我对t1线程中的操作1进行了加锁，但是系统内核将t1线程调度走了，可以让其他线程调度到t1线程的位置继续执行操作1，此时t2线程还是无法加到锁.
另外加锁的方式：
1.写一个方法将加锁的关键字放在方法中：

public static int count = 0;
synchronized public void add() {
    count++;
}
public static void main(String[] args) throws InterruptedException {
    Deom14 deom14 = new Deom14();
    Thread t1 = new Thread(()-> {
        for (int i = 1; i <= 5000; i++) {
            deom14.add();
        }
    });
    Thread t2 = new Thread(()-> {
        for (int i = 1; i <=5000 ; i++) {
            deom14.add();
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("count = "+ count);
}

对于这种方式加锁还有一种写法：

public static int count = 0;

public void add() {
    synchronized (this){
        count++;
    }
}
public static void main(String[] args) throws InterruptedException {
    Deom14 deom14 = new Deom14();
    Thread t1 = new Thread(()-> {
        for (int i = 1; i <= 5000; i++) {
            deom14.add();
        }
    });
    Thread t2 = new Thread(()-> {
        for (int i = 1; i <=5000 ; i++) {
            deom14.add();
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("count = "+ count);
}

利用this，谁调用了这个方法就用这个对象作为锁对象，
2.synchronized对static方法进行加锁，相当于对类的类对象进行加锁

public static int count = 0;
synchronized static void func() {
    count++;
}

public static void main(String[] args) throws InterruptedException {
    Object locker = new Object();
    Thread t1 = new Thread(()-> {
        for (int i = 1; i <= 5000; i++) {
            Deom15.func();
        }
    });
    Thread t2 = new Thread(()-> {
        for (int i = 1; i <=5000 ; i++) {
            Deom15.func();
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("count = "+ count);
}

对于这种写法有个致命的缺点，一旦有多个线程调用func，则这些线程都会触发锁竞争。
4. 原因4引起的线程不安全——编译器优化产生的线程不安全

public static int count;
public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        while(count == 0) {
            //未执行操作
        }
        System.out.println("退出t1线程");
    });

    Thread t2 = new Thread(() -> {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一个数：");
        count = scanner.nextInt();
    });
    t1.start();
    t2.start();
}

在t1线程中while（count == 0）这个操作在指令的角度来分析就两个指令分别为load和cmp指令
load指令将内存中数据读入cpu中寄存器
cmp在cpu寄存器中进行比较
1.内存读取数据的速度远远小于寄存器读取的数据的速度就会造成load指令执行的速度远远慢于cmp指令执行。
2.在t2线程未修改count之前load指令执行的结果是一样的。
由上述两个原因，java编译器为了提高效率就会将load指令这个操作优化，所以当t2线程修改了count的值t1线程也不会感知到。
如果在t1线程的循环体中加一些I/O操作或者阻塞操作，这样java编译器就不会去优化load指令。

public static int count;
public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        while(count == 0) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("退出t1线程");
    });

    Thread t2 = new Thread(() -> {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一个数：");
        count = scanner.nextInt();
    });
    t1.start();
    t2.start();
}

如何解决由编译器优化引起的线程不安全？
1.上述在循环体中加I/O操作或者阻塞操作可以解决
2.用volatile关键字来修饰需要修改的变量——这个关键字只能解决编译器优化带来的内存可见性问题，不能解决原因三带来的问题。
volatile关键字
当为count加上volatile关键字就会告知编译器这个变量不能随便被优化`在这里插入代码片

public volatile static int count;
public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        while(count == 0) {
        }
        System.out.println("退出t1线程");
    });

    Thread t2 = new Thread(() -> {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一个数：");
        count = scanner.nextInt();
    });
    t1.start();
    t2.start();
}
  1. 原因5引起的线程不安全——编译器优化策略导致
    指令重排序旨在编译器在优化的时候将你的代码重新调整执行顺序来提高效率，优化前的逻辑与优化后的逻辑是等价的，在单线程中指令重排序这个优化策略是不会造成线程不安全，但是在多线程中就会导致线程不安全。
    面对指令重排序我们采取用volatile关键字
class SinlgetonLazy1 {
    private static volatile SinlgetonLazy1 instance = null;
    public static SinlgetonLazy1 getInstance() {
        Object locker = new Object();
        if(instance == null) {
            synchronized(locker) {
                if (instance == null ) {
                    instance = new SinlgetonLazy1();
                }
            }
        }
        return instance;
    }
    private SinlgetonLazy1() {

    }
}
public class Deom24 {
    public static void main(String[] args) throws InterruptedException {
        SinlgetonLazy1 s = SinlgetonLazy1.getInstance();
        Thread t1 = new Thread(() -> {
            SinlgetonLazy1 s1 = SinlgetonLazy1.getInstance();
        });
        Thread t2 = new Thread(() -> {
            SinlgetonLazy1 s2 = SinlgetonLazy1.getInstance();
        });
        t1.start();
        t2.start();
    }
}

1.3三种典型死锁场景

场景一：锁是不可重入锁，并且一个线程针对一个锁对象，连续被加锁两次。
采取可重入锁（synchronized）就可以对这个问题迎刃而解了
场景二：两个线程两把锁
现有t1线程t2线程和locker1锁locker2锁， locker2锁要对t1线程中内容加锁，但同时locker2锁对t2线程还未解锁，所以t1线程需要阻塞等待，而现在locker1锁也要对t2线程中的内容加锁，但是locker1对t1线程还未解锁，所以t2线程需要阻塞等待，这样就导致你等我，我等你的死锁现象`

public static void main(String[] args) {
    Object locker1 = new Object();
    Object locker2 = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (locker1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker2) {
                System.out.println("t1线程获取到了两把锁");
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (locker2) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker1) {
                System.out.println("t2线程获取到了两把锁");
            }
        }
    });
    t1.start();
    t2.start();
}

上述代码就是场景二死锁的实现代码
通过jconsole窗口观察：
在这里插入图片描述
此时就是t1线程想要获取到locker2锁，但locker2锁被t2线程给加锁了并且没有解锁，所以此时的t1线程想要获取locker2锁只能阻塞等待。
在这里插入图片描述
此时就是t2线程想要获取到locker1锁，但locker1锁被t1线程给加锁了并且没有解锁，所以此时的t2线程想要获取locker1锁只能阻塞等待。
场景三：N个线程M把锁——哲学家就餐问题
约定每一个哲学家必须先获取编号小的筷子，后获取编号大的筷子，就可以解决哲学家就餐问题。

1.4如何避免死锁问题

出现死锁的四大必要条件，少一个都不会出现死锁。

  1. 锁具有互斥特性（基本特点，一个线程拿到锁之后，其他线程就得阻塞等待）——基本特点
  2. 锁不可抢占（不可被剥夺）——基本特点
  3. 请求和保持（一个线程拿到一把锁之后，不释放这个锁的前提下，再尝试获取其他锁）——代码结构
  4. 循环等待（多个线程获取多个锁的过程中，出现了循环等待，A线程等待B线程，B线程又等待A线程）——代码结构
    要避免死锁，由于第一和第二点是锁的基本特性所以我们无法避免，我们只能从第三点和第四点出发避免死锁。
    针对第三点：我们尽量不要出现嵌套锁。
    针对第四点：我们可以约定加锁的顺序，让所有的线程按照加锁的顺序来获取锁。
    针对上述的代码出现了死锁，我们就可以约定加锁的先后顺序来避免死锁，我们约定locker1先加锁，locker2后加锁。
public static void main(String[] args) {
    Object locker1 = new Object();
    Object locker2 = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (locker1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker2) {
                System.out.println("t1线程获取到了两把锁");
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (locker1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker2) {
                System.out.println("t2线程获取到了两把锁");
            }
        }
    });
    t1.start();
    t2.start();
}

2.线程等待通知机制

2.1等待通知的作用

通过条件，判断当前逻辑是否能够执行，如果不满足条件不能执行，那么就主动进行阻塞(wait)让其他线程来调度cpu的资源，等到条件满足的时候，再让其它线程（阻塞的线程）来唤醒。

2.2等待通知的方法——wait

  1. wait方法是Object类提供，所以任何对象都能调用这个方法
  2. wait方法和sleep一样会被interrupt打断并且自动清空标志位
  3. wait方法不仅仅可一个阻塞等待还可以解锁
  4. wait方法要放在synchronized内部使用
public static void main(String[] args) {
    Object locker = new Object();
    Thread t1 = new Thread(() -> {
        
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
    });

在这里插入图片描述

2.3唤醒wait的方法——notify

  1. notify方法要放在synchronized内部使用
  2. notify方法是Object类提供，所以任何对象都能调用这个方法wait方法是Object类提供，所以任何对象都能调用这个方法
  3. notify是随机唤醒被阻塞的线程
  4. notifyAll()方法可以唤醒所有被阻塞的线程，但这种方法不常用。`
public static void main(String[] args) {
    Object locker = new Object();
    Thread t1 = new Thread(() -> {
        System.out.println("t1线程等待之前");
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        System.out.println("t1线程等待结束");
    });
   Thread t2 = new Thread(() -> {
       System.out.println("t2线程唤醒t1线程之前");
       synchronized (locker) {
           try {
               Thread.sleep(3000);
               locker.notify();
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
       }
       System.out.println("t2线程唤醒结束");
   });
   t1.start();
   t2.start();
}

此时的t1线程的状态转化为：WAITTING——RUNNABLE——BLOCKED

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

前端入门篇（五十二）练习6：transition过渡小动画

前端入门篇（五十二）练习6：transition过渡小动画

所以应该先找到第n个li&#xff0c;找到li再找img&#xff0c;li没有找错&#xff0c;底下又各自只有一个img&#xff0c;解决 ul li:nth-child(1) img { } 描述文字从下往上&#xff1a; 一开始描述也在框框下面&#xff0c;当hover时&#xff0c;translateY(0)&#xff0…
阅读更多...
redis高可用-哨兵机制

redis高可用-哨兵机制

一&#xff1a;背景 上一节我们已经实现了redis的主从同步&#xff0c;从而实现服务的流量分摊和数据高可用&#xff0c;但是出现故障以后&#xff0c;需要人工手动接入&#xff0c;手动切换主从&#xff0c;来实现故障转移。这是比较麻烦的&#xff0c;毕竟人不能实时盯着服务…
阅读更多...
如何用Vue3打造一个令人惊叹的极坐标图

如何用Vue3打造一个令人惊叹的极坐标图

本文由ScriptEcho平台提供技术支持 项目地址&#xff1a;传送门 使用 Vue3-ApexCharts 绘制极地区域图 应用场景 极地区域图常用于展示具有周期性或分类性数据的分布情况&#xff0c;例如不同月份的销售额、不同年龄段的人口分布等。 基本功能 此代码使用 Vue3-ApexChart…
阅读更多...
打字速度对编程的影响大吗？

打字速度对编程的影响大吗？

知道打字速度对编程的影响大吗&#xff1f;实际上&#xff0c;在编程的世界里&#xff0c;关键在于思考&#xff0c;而非打字速度。要明白&#xff0c;编程与日常聊天中的打字有着本质的区别&#xff0c;如果编程仅仅取决于打字速度&#xff0c;那它岂不就等同于打字员的工作了…
阅读更多...
详解 Macvlan 创建不同容器独立跑仿真

详解 Macvlan 创建不同容器独立跑仿真

一、概念介绍 1.1 什么是macvlan macvlan是一种网卡虚拟化技术&#xff0c;能够将一张网卡&#xff08;Network Interface Card, NIC&#xff09;虚拟出多张网卡&#xff0c;这意味着每个虚拟网卡都能拥有独立的MAC地址和IP地址&#xff0c;从而在系统层面表现为完全独立的网络…
阅读更多...
基于欧式距离的匈牙利匹配跟踪器(C++)

基于欧式距离的匈牙利匹配跟踪器(C++)

文章目录 介绍参考repo修改后的效果修改后的代码使用方法介绍 基于欧式距离的匈牙利匹配跟踪器是一种在目标跟踪领域常用的算法。它通常用于解决多目标跟踪中的匹配问题，其中需要将当前帧中的检测目标与上一帧中已知的目标进行匹配。 算法步骤大致如下： 特征提取：对检测到…
阅读更多...
Vue快速上手和Vue指令

Vue快速上手和Vue指令

一、Vue快速上手 1、Vue概念 Vue (读音 /vjuː/&#xff0c;类似于 view) 是一套构建用户界面的渐进式框架 Vue2官网&#xff1a;https://v2.cn.vuejs.org/ 构建用户界面&#xff1a;基于数据渲染出用户可以看到的界面 渐进式&#xff1a; 循序渐进&#xff0c;不一定非得把…
阅读更多...
docker容器网络与宿主机网络冲突的原因与解决方案

docker容器网络与宿主机网络冲突的原因与解决方案

一、故障现象 在用docker-compos.yaml文件或者手动创建docker网络时&#xff0c;可能会出现新建的容器网络与宿主机网络冲突&#xff0c;导致SSH远程连接中断&#xff0c;并无法再用Xshell等远程连接工具连接宿主机。现象如下&#xff1a; [rootcontroller ~]# docker networ…
阅读更多...
LeRobot——Hugging Face打造的机器人领域的Transformer架构

LeRobot——Hugging Face打造的机器人领域的Transformer架构

前言 如友人邓博士所说&#xff0c;“用 Stanford aloha 课题组提供的训练数据&#xff0c;训练他们研发的 Action Chunking Transformer 动作规划模型&#xff0c;训练结果&#xff0c;能用&#xff0c;但是稳定性有待提高 要提高稳定性&#xff0c;看来必须修改 Stanford a…
阅读更多...
web安全渗透测试十大常规项（一）：web渗透测试之PHP反序列化

web安全渗透测试十大常规项（一）：web渗透测试之PHP反序列化

渗透测试之PHP反序列化 1. PHP反序列化1.1 什么是反序列化操作？ - 类型转换1.2 常见PHP魔术方法？- 对象逻辑（见图）1.2.1 construct和destruct1.2.2 construct和sleep1.2.2 construct和wakeup1.2.2 INVOKE1.2.2 toString1.2.2 CALL1.2.2 get()1.2.2 set()1.2.2 isset()1.2.2…
阅读更多...
Js-w3school（2024(1)

Js-w3school（2024(1)

10.访问 HTML 元素 使用“不整洁的” HTML 样式的后果&#xff0c;也许是导致 JavaScript 错误。请在 HTML 中使用相同的命名约定&#xff08;就像 JavaScript 那样&#xff09; 11. 请使用正确的文档类型 请始终在文档的首行声明文档类型&#xff1a; 如果您一贯坚持小写标…
阅读更多...
数据结构之B数

数据结构之B数

目录 1.概述 2.特点 3.诞生 4.优缺点 4.1.优点 4.2.缺点 5.应用场景 6.C语言中的B树实现例子 7.总结 1.概述 B树&#xff08;B-tree&#xff09;是一种自平衡的树数据结构&#xff0c;广泛应用于数据库和文件系统中&#xff0c;以便高效地进行顺序读取、写入以及查找…
阅读更多...
南京邮电大学计算机网络实验一（网络操作系统的安装与配置）

南京邮电大学计算机网络实验一（网络操作系统的安装与配置）

文章目录 一、 实验目的和要求二、 实验环境(实验设备)三、 实验原理和步骤四、 实验小结&#xff08;包括问题和解决方法、心得体会、意见与建议等&#xff09;&#xff08;一&#xff09;问题和解决方法&#xff08;二&#xff09;心得体会&#xff08;三&#xff09;意见与建…
阅读更多...
osgearth提示“simple.earth: file not handled”

osgearth提示“simple.earth: file not handled”

在用vcpkg编译完osg和osgearth后&#xff0c;为了验证osgearth编译是否正确&#xff0c;进行测试&#xff0c;模型加载代码如下&#xff1a; root->addChild(osgDB::readNodeFile("simple.earth")); 此时以为是simple.earth路径的问题&#xff0c;遂改为以下代码…
阅读更多...
AI交互数字人如何赋能数智教育？

AI交互数字人如何赋能数智教育？

随着AI交互数字人技术的飞速发展&#xff0c;教育领域正经历着前所未有的变革。AI交互数字人为教育领域注入了全新活力&#xff0c;重塑着教学模式&#xff0c;为学生带来沉浸式学习体验。 AI交互数字人在教育领域中&#xff0c;可以应用在&#xff1a; 1、个性化学习教学指导…
阅读更多...
不适合编程的人是怎样的？

不适合编程的人是怎样的？

你知道不适合编程的人是怎样的吗&#xff1f;其实&#xff0c;对编程没有兴趣的人往往都不适合从事编程工作。编程并非是一项轻松简单的任务&#xff0c;它需要投入大量的时间和精力。 编程领域有其独特的特点和要求。首先&#xff0c;编程有着相当陡峭的学习曲线。从最基础的语…
阅读更多...
分布式锁三种方案

分布式锁三种方案

基于数据库的分布式锁&#xff08;基于主键id和唯一索引&#xff09; 1基于主键实现分布式锁 2基于唯一索引实现分布式锁 其实原理一致&#xff0c;都是采用一个唯一的标识进行判断是否加锁。 原理&#xff1a;通过主键或者唯一索性两者都是唯一的特性&#xff0c;如果多个…
阅读更多...
二开的精美UI站长源码分享论坛网站源码 可切换皮肤界面

二开的精美UI站长源码分享论坛网站源码 可切换皮肤界面

二开的精美UI站长源码分享论坛网站源码 可切换皮肤界面 二开的精美UI站长源码分享论坛网站源码 可切换皮肤界面
阅读更多...
如何使用React的lazy和Suspense来实现代码分割？

如何使用React的lazy和Suspense来实现代码分割？

在React中&#xff0c;使用React.lazy和Suspense可以方便地实现组件的代码分割。代码分割是一种优化技术&#xff0c;它将代码拆分成多个包&#xff0c;然后按需加载这些包&#xff0c;从而加快应用的初始加载时间。下面是如何使用这两个API的基本步骤&#xff1a; 使用React.l…
阅读更多...
24上软考成绩预计6月底公布？附查分指南

24上软考成绩预计6月底公布？附查分指南

最近&#xff0c;很多小伙伴都在问上半年成绩什么时候出来&#xff1f;每天学习群变成了祈祷群&#xff0c;都在祈祷45,45,45。按照上一次的成绩发布时间&#xff0c;从考试结束到成绩发布&#xff0c;间隔了32天。这次是不是会更快&#xff1f; 一般阅卷只要7-10天&#xff0c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023