【JavaEE多线程】线程安全、锁机制及线程间通信

目录

    • 线程安全
      • 线程安全问题的原因
    • synchronized 关键字-监视器锁monitor lock
      • synchronized的特性
        • 互斥
        • 刷新内存
        • 可重入
      • synchronized使用范例
    • volatile
      • volatile能保证内存可见性
      • volatile不保证原子性
      • synchronized 也能保证内存可见性
    • wait 和 notify
      • wait()方法
      • notify()方法
      • notifyAll()方法

线程安全

如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

线程安全问题的原因

  1. [根本原因]多个线程之间的调度顺序是“随机”的，操作系统使用“抢占式”执行的策略来调度线程

  2. 多个线程同时修改同一个遍历，容易产生线程安全问题

    • 3个条件
    1. 多个
    2. 修改
    3. 同一个

  3. 进行的修改，不是“原子的”，如果修改操作能按照原子的形式完成，就不会有线程安全问题（原子，即不可再分）

  4. 内存可见性，引起的线程安全问题

  5. 指令重排序，引起的线程安全问题

  • 以上五个原因，只有第3个原因能想办法修正
  • 通过“加锁”的方式，把一组操作给打包成一个“原子”的操作。此处的原子，就是通过锁，进行“互斥”，我这个线程工作的时候，其他线程无法工作

  1. 原子性：

    什么是原子性

    我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。

    那我们应该如何解决这个问题呢？是不是只要给房间加一把锁，A 进去就把门锁上，其他人是不是就进不来了。这样就保证了这段代码的原子性了。

    有时也把这个现象叫做同步互斥，表示操作是互相排斥的。

    如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的。

  2. 可见性： 一个线程对共享变量值的修改，能够及时地被其他线程看到

  3. 代码顺序性：

    什么是代码重排序

    一段代码是这样的：

    1. 去前台取下 U 盘
    2. 去教室写 10 分钟作业
    3. 去前台取下快递

​ 如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑一次前台。这种叫做指令重排序

编译器对于指令重排序的前提是 “保持逻辑不发生变化”. 这一点在单线程环境下比较容易判断, 但是在多线程环境下就没那么容易了, 多线程的代码执行复杂程度更高, 编译器很难在编译阶段对代码的执行效果进行预测, 因此激进的重排序很容易导致优化后的逻辑和之前不等价.

synchronized 关键字-监视器锁monitor lock

代码中的锁就是让多个线程，同一时刻，只有一个线程能使用这个变量

synchronized的特性

互斥

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待.

  • 进入 synchronized 修饰的代码块, 相当于 加锁
  • 退出 synchronized 修饰的代码块, 相当于 解锁
//进入就针对当前对象“加锁”
synchronized public void increase(){count++;
}
//出来就针对当前对象“解锁”

synchronized关键字最主要有以下3种应用方式：

  • 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁

  • 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁

  • 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁。（这里可以给实例对象的名称Test test=new Test()的test，也可以给this对象代表当前实例，也可以给当前类的class对象作为锁）

  • 思考：通过加锁操作之后把并发执行=>串行执行了，此时多线程还有存在的意义吗？

  • 答：因为两个线程，可能有一部分代码是串行执行的，有一部分是并发执行的=>这仍然比纯粹的串行执行效率要高！

理解 “阻塞等待”.

针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒一个新的线程, 再来获取到这个锁.

注意:

  • 上一个线程解锁之后, 下一个线程并不是立即就能获取到锁. 而是要靠操作系统来 “唤醒”. 这也就是操作系统线程调度的一部分工作.

  • 假设有 A B C 三个线程, 线程 A 先获取到锁, 然后 B 尝试获取锁, 然后 C 再尝试获取锁, 此时 B 和 C 都在阻塞队列中排队等待. 但是当 A 释放锁之后, 虽然 B 比 C 先来的, 但是 B 不一定就能获取到锁, 而是和 C 重新竞争, 并不遵守先来后到的规则

synchronized用的锁是存在Java对象里的。

synchronized进行加锁解锁，其实是以“对象”为维度进行展开的。

加锁目的是为了互斥使用资源。（互斥的修改变量）

使用synchronized的时候，其实是指定了某个具体的对象进行加锁，当synchronized直接修饰方法时，此时就相当于是针对this加锁（修饰方法相当于这段代码的简化写法）[不存在所谓的“同步方法”的概念]

class Counter{public int count=0;public void increace(){synchronized (this){//this就是下面调用的countercount++;}}public void increace2(){count++;}public synchronized static void func(){synchronized (Counter.class){}}
}
public class Demo {public static void main(String[] args) throws InterruptedException {Counter counter=new Counter();Thread t1=new Thread(()->{for (int i = 0; i < 50000; i++) {counter.increace();//这里t1的counter和下面t2的counter进行锁竞争/锁冲突}});Thread t2=new Thread(()->{for (int i = 0; i < 50000; i++) {counter.increace();//这里t2的counter和上面t1的counter进行锁竞争/锁冲突}});t1.start();t2.start();t1.join();t2.join();System.out.println(counter.count);}
}

如果是两个线程针对同一个对象进行加锁，就会出现锁竞争/锁冲突（一个线程能加锁成功，另一个线程阻塞等待）

如果是两个线程针对不同对象进行加锁，就不会出现锁竞争/锁冲突，也就不存在阻塞等待的操作了

因此具体针对哪个对象加锁不重要，重要的是两个线程，是不是针对同一个对象加锁

  • 思考：如果接下来的代码里，一个线程加锁了，一个线程没加锁，此时是否还会存在线程安全问题
  • 答：单方面加锁等于没加锁，必须得多个线程都对同一个对象加锁，才有意义

synchronized的底层是使用操作系统的mutex lock实现的.

synchronized有且只有一条规则：

当两个线程针对同一个对象加锁的时候，就会出现锁竞争/锁冲突。一个线程能先拿到锁，另一个线程就会阻塞等待（BLOCKED）。直到第一个线程释放了锁之后，第二个线程才可能获取到锁，才能继续往下执行。

刷新内存

synchronized 的工作过程:

  1. 获得互斥锁

  2. 从主内存拷贝变量的最新副本到工作的内存

  3. 执行代码

  4. 将更改后的共享变量的值刷新到主内存

  5. 释放互斥锁

可重入

synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题

理解 "把自己锁死"

一个线程没有释放锁, 然后又尝试再次加锁.

// 第一次加锁, 加锁成功
lock();
// 第二次加锁, 锁已经被占用, 阻塞等待. 
lock();

按照之前对于锁的设定, 第二次加锁的时候, 就会阻塞等待. 直到第一次的锁被释放, 才能获取到第二个锁. 但是释放第一个锁也是由该线程来完成, 结果这个线程已经躺平了, 啥都不想干了, 也就无法进行解锁操作. 这时候就会 死锁.

这样的锁称为 不可重入锁.

Java 中的 synchronized 是 可重入锁, 因此没有上面的问题

代码示例

在下面的代码中,

  • increase 和 increase2 两个方法都加了 synchronized, 此处的 synchronized 都是针对 this 当前对象加锁的.
  • 在调用 increase2 的时候, 先加了一次锁, 执行到 increase 的时候, 又加了一次锁. (上个锁还没释放, 相当于连续加两次锁)

这个代码是完全没问题的. 因为 synchronized 是可重入锁.

static class Counter {public int count = 0;synchronized void increase() {count++;}synchronized void increase2() {increase();}
}

在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息.

  • 如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取到锁, 并让计数器自增.

  • 解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)

synchronized使用范例

synchronized 本质上要修改指定对象的 “对象头”. 从使用角度来看, synchronized 也势必要搭配一个具体的对象来使用.

  1. 直接修饰普通方法:锁的 SynchronizedDemo 对象
public class SynchronizedDemo {public synchronized void methond() {}
}
  1. 修饰静态方法: 锁的 SynchronizedDemo 类的对象
public class SynchronizedDemo {public synchronized static void method() {}
}
  1. 修饰代码块: 明确指定锁哪个对象.

锁当前对象

public class SynchronizedDemo {public void method() {synchronized (this) {//Test test=new Test()的test也行}}
}

锁类对象

public class SynchronizedDemo {public void method() {synchronized (SynchronizedDemo.class) {}}
}

volatile

volatile能保证内存可见性

volatile 修饰的变量, 能够保证 “内存可见性”.

在这里插入图片描述

代码在写入 volatile 修饰的变量的时候,

  • 改变线程工作内存中volatile变量副本的值
  • 将改变后的副本的值从工作内存刷新到主内存

代码在读取 volatile 修饰的变量的时候,

  • 从主内存中读取volatile变量的最新值到线程的工作内存中

  • 从工作内存中读取volatile变量的副本

代码示例

在这个代码中

  • 创建两个线程 t1 和 t2
  • t1 中包含一个循环, 这个循环以 flag == 0 为循环条件.
  • t2 中从键盘读入一个整数, 并把这个整数赋值给 flag.
  • 预期当用户输入非 0 的值的时候, t1 线程结束.
static class Counter {public int flag = 0;
}
public static void main(String[] args) {Counter counter = new Counter();Thread t1 = new Thread(() -> {while (counter.flag == 0) {// do nothing}System.out.println("循环结束!");});Thread t2 = new Thread(() -> {Scanner scanner = new Scanner(System.in);System.out.println("输入一个整数:");counter.flag = scanner.nextInt();});t1.start();t2.start();
}
// 执行效果
// 当用户输入非0值时, t1 线程循环不会结束. (这显然是一个 bug)
// 注意：这里直接在控制台是看不出的

t1 读的是自己工作内存中的内容.

当 t2 对 flag 变量进行修改, 此时 t1 感知不到 flag 的变化.

如果给 flag 加上 volatile

static class Counter {public volatile int flag = 0;
}
// 执行效果
// 当用户输入非0值时, t1 线程循环能够立即结束.
// 注意：这里直接在控制台同样是看不出的

volatile不保证原子性

volatile 和 synchronized 有着本质的区别. synchronized 能够保证原子性, volatile 保证的是内存可见性.

synchronized 也能保证内存可见性

synchronized 既能保证原子性, 也能保证内存可见性.

内存可见性问题：

  1. 编译器优化
  2. 内存模型
  3. 多线程
  • volatile保证的是内存可见性，不是原子性

内存可见性和加锁描述了线程安全问题的典型情况和处理方式

wait 和 notify

由于线程之间是抢占式执行的, 因此线程之间执行的先后顺序难以预知.

但是实际开发中有时候我们希望合理的协调多个线程之间的执行先后顺序.

完成这个协调工作, 主要涉及到三个方法 ：

  • wait() / wait(long timeout): 让当前线程进入等待状态.
  • notify() / notifyAll(): 唤醒在当前对象上等待的线程.

注意: wait, notify, notifyAll 都是 Object 类的方法.

wait（等待）和notify（通知）就是一个用来协调线程顺序的重要工具

这两个方法都是Object提供的方法，随便找个对象都可以调用

当wait引起线程阻塞之后，可以使用interrupt方法把线程唤醒，打断当前线程的阻塞状态

wait()方法

wait在执行的时候，会做三件事：

  1. 解锁。object.wait，就会尝试针对object对象解锁
  2. 阻塞等待
  3. 当被其他线程唤醒之后，就会尝试重新加锁，加锁成功，wait执行完毕，继续往下执行其他逻辑。

wait要解锁前提是先能加上锁

  • 核心解决思路：先加锁，在synchronized里头再wait，这样子的wait就会一直阻塞到其他线程进行notify了

注意事项：

  1. 要想让notify能够顺利唤醒wait，就需要确保wait和notify都是使用同一个对象调用的。
  2. wait和notify都需要放到synchronized之内的。虽然notify不涉及“解锁操作”，但是Java也强制要求notify要放到synchronized中。（系统的原生api中就没有这个要求）
  3. 如果进行notify的时候，另一个线程并没有处于wait状态，此时，notify相当于“空打一炮”，不会有任何副作用

代码示例: 观察wait()方法使用

public static void main(String[] args) throws InterruptedException {Object object = new Object();synchronized (object) {System.out.println("等待中");object.wait();System.out.println("等待结束");}
}

这样在执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()

线程可能有多个，比如可以有n个线程进行wait一个线程负责notify，notify操作只会唤醒一个线程。具体是唤醒了哪个线程？是随机的！

wait和sleep的区别：

  • sleep有个明确的时间，到达时间自然就会被唤醒，也能提前唤醒，使用interrupt
  • wait默认是个死等，一直等到其他线程notify，wait也能被interrupt提前唤醒

notify()方法

notify 方法是唤醒等待的线程.

  • 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。
  • 如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 “先来后到”)
  • 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

代码示例: 使用notify()方法唤醒线程

  • 创建 WaitTask 类, 对应一个线程, run 内部循环调用 wait.
  • 创建 NotifyTask 类, 对应另一个线程, 在 run 内部调用一次 notify
  • 注意：WaitTask 和 NotifyTask 内部持有同一个 Object locker. WaitTask 和 NotifyTask 要想配合就需要搭配同一个 Object.
static class WaitTask implements Runnable {private Object locker;public WaitTask(Object locker) {this.locker = locker;}@Overridepublic void run() {synchronized (locker) {while (true) {try {System.out.println("wait 开始");locker.wait();System.out.println("wait 结束");} catch (InterruptedException e) {e.printStackTrace();}}}}
}
static class NotifyTask implements Runnable {private Object locker;public NotifyTask(Object locker) {this.locker = locker;}@Overridepublic void run() {synchronized (locker) {System.out.println("notify 开始");locker.notify();System.out.println("notify 结束");}}
}
public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(new WaitTask(locker));Thread t2 = new Thread(new NotifyTask(locker));t1.start();Thread.sleep(1000);t2.start();
}

notifyAll()方法

notify方法只是唤醒某一个等待线程. 使用notifyAll方法可以一次唤醒所有的等待线程.

如果就想唤醒某个指定的线程，就可以让不同的线程使用不同的对象来进行 wait，想唤醒谁，就可以使用对应的对象来notify

范例：修改 NotifyTask 中的 run 方法, 把 notify 替换成 notifyAll

public void run() {synchronized (locker) {System.out.println("notify 开始");locker.notifyAll();System.out.println("notify 结束");}
}

**注意：**虽然是同时唤醒 3 个线程, 但是这 3 个线程需要竞争锁. 所以并不是同时执行, 而仍然是有先有后的执行.

wait和sleep的区别（面试题）：

  1. sleep有个明确的时间，到达时间自然就会被唤醒，也能提前唤醒，使用interrupt
  2. wait默认是个死等，一直等到其他线程notify，wait也能被interrupt提前唤醒
  3. wait 需要搭配 synchronized 使用，sleep 不需要.
  4. wait 是 Object 的方法 sleep 是 Thread 的静态方法.

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

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

相关文章

开发语言漫谈-JavaScript

开发语言漫谈-JavaScript

JavaScript、Java名字很相近&#xff0c;但它们没有任何亲缘关系&#xff0c;是由不同公司开发的编程语言。Java由Sun公司&#xff08;后被Oracle收购&#xff09;开发&#xff0c;JavaScript最初是由Netscape公司开发的&#xff08;当年浏览器的霸主&#xff09;。JavaScrip…
阅读更多...
PostgreSQL恢复系列:pg_filedump恢复字典构造---惜分飞

PostgreSQL恢复系列:pg_filedump恢复字典构造---惜分飞

pg_filedump是在pg数据库极端情况下直接解析数据库文件的利器,但是由于是开源软件,本身难以实现批量处理,通过对底层基表分析,可以实现批量处理功能分析PostgreSQL库中数据库信息 --数据库查询结果 postgres# select oid,datname,datdba,dattablespace from pg_database; oid…
阅读更多...
leetcode--3 无重复最长字串

leetcode--3 无重复最长字串

题目描述 给定一个字符串 s &#xff0c;请你找出其中不含有重复字符的 最长 子串 的长度。 示例 1: 输入: s "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是 "abc"&#xff0c;所以其长度为 3。示例 2: 输入: s "bbbbb" 输出: 1 …
阅读更多...
PyTorch torch.nn.functional.one_hot用法解析

PyTorch torch.nn.functional.one_hot用法解析

1.用法 在PyTorch中&#xff0c;我们可以使用torch.nn.functional.one_hot函数来实现One-Hot编码。下面是一个简单的例子&#xff1a; import torch import torch.nn.functional as F # 假设我们有一个包含类别标签的张量 labels torch.tensor([0, 2, 1, 0, 2]) # 使用torch…
阅读更多...
深度学习概念

深度学习概念

AIGC数据生产&#xff1a; AIGC在生成小图片时效果更佳(因为小图信息量更少&#xff0c;相同算力下效果更好)&#xff1b;所以适合构造一些交通场景。比如护栏损坏&#xff1a;只mask原图的部分区域(图中白色区域)&#xff0c;即可引导模型在mask处生成损坏的护栏。 基于此方…
阅读更多...
【LeetCode热题100】【动态规划】完全平方数

【LeetCode热题100】【动态规划】完全平方数

题目链接&#xff1a;279. 完全平方数 - 力扣&#xff08;LeetCode&#xff09; 完全平方数是可以表示成某个整数的平方的数&#xff0c;要找和为n的完全平方数的最少数目 满足要求的完全平方数最小是1&#xff0c;最大不会超过n的平方根 所以题目变成要从1&#xff0c;2&am…
阅读更多...
【LeetCode热题100】【动态规划】最长递增子序列

【LeetCode热题100】【动态规划】最长递增子序列

题目链接&#xff1a;300. 最长递增子序列 - 力扣&#xff08;LeetCode&#xff09; 让dp[i]是以nums[i]为结尾的子序列的最长递增长度&#xff0c;遍历nums[i]之前的元素&#xff0c;如果有比nums[i]小的&#xff0c;说明递增子序列可以延申 class Solution { public:int le…
阅读更多...
拖拽式工作流有哪几个优势？

拖拽式工作流有哪几个优势？

在信息技术迅猛发展的今天&#xff0c;如何助力中小型企业在数字化转型的过程中平稳过渡&#xff1f;又是如何让中小型企业摆脱数据孤岛、成本投入高等各种瓶颈和难题&#xff1f;低代码技术平台是近些年较为理想的平台产品&#xff0c;其中拖拽式工作流优势特点突出&#xff0…
阅读更多...
地埋电缆故障检测方法有哪些？地埋电缆故障检测费用是多少？

地埋电缆故障检测方法有哪些？地埋电缆故障检测费用是多少？

地埋电缆故障检测方法主要涵盖脉冲反射法、桥接法、高压闪络法和声波定位法等多种方法。选择适当的方法取决于故障类型、电缆类型和实际现场条件。至于地埋电缆故障检测费用则受到多个因素的影响&#xff0c;包括故障类型、检测方法的复杂性、检测设备的先进程度以及所处地区的…
阅读更多...
从零开始搭建社交圈子系统：充实人脉的最佳路径

从零开始搭建社交圈子系统：充实人脉的最佳路径

线上交友圈&#xff1a;拓展社交网络的新时代 线上交友圈是社交网络的新引擎&#xff0c;提供了更广泛的社交机会&#xff0c;注重共同兴趣的连接&#xff0c;强调多样性的社交形式&#xff0c;更真实地展示自己&#xff0c;让朋友更全面地了解我们的生活状态。虽然虚拟交往存在…
阅读更多...
SD-WAN解决电商企业海外业务网络难题

SD-WAN解决电商企业海外业务网络难题

全球化背景下&#xff0c;众多国内企业都涉及到海外贸易业务&#xff0c;尤其是出海电商得到蓬勃发展。企业做出海电商&#xff0c;需要访问国外网页、社交平台&#xff0c;如亚马逊、TikTok、Facebook、YouTube等与客户沟通互动&#xff0c;SD-WAN的发展正好为解决国际网络访问…
阅读更多...
时序分析相关考题汇总

时序分析相关考题汇总

时序分析例题_如下一个分频电路,触发器建立时间tsu 2ns,保持时间thold 2ns,逻辑延时tq -CSDN博客 IC/FPGA笔试/面试题分析&#xff08;七&#xff09;建立时间和保持时间类型考题汇总分析_建立时间 保持时间 笔试题-CSDN博客
阅读更多...
Qt（十二）Graphics View 绘图架构（三）

Qt（十二）Graphics View 绘图架构（三）

文章目录 一、QGraphicsView相关整理二、QGraphicsView架构下实时鼠标绘制图形2.1 鼠标拖拽绘图说明2.2 记录图形第一个绘制点2.3 实时获取鼠标最新位置并绘图2.4 释放绘制点&#xff0c;绘制最终图形 三、QGraphicsView 在鼠标点击处进行放大缩小 一、QGraphicsView相关整理 …
阅读更多...
14 Php学习：表单

14 Php学习：表单

表单 PHP 表单是用于收集用户输入的工具&#xff0c;通常用于网站开发。PHP 可以与 HTML 表单一起使用&#xff0c;用于处理用户提交的数据。通过 PHP 表单&#xff0c;您可以创建各种类型的表单&#xff0c;包括文本输入框、复选框、下拉菜单等&#xff0c;以便用户可以填写和…
阅读更多...
孩子不爱学习的解决办法？最佳回答

孩子不爱学习的解决办法？最佳回答

孩子说不想上学了&#xff0c;想必这句话很多父母都不陌生&#xff0c;从自家孩子嘴里听到过。孩子十三岁了&#xff0c;正是叛逆的时候&#xff0c;很多孩子会在这个时候出现不爱读书的情况&#xff0c;面对这样的情况&#xff0c;家长要保持冷静&#xff0c;采取合理的解决办…
阅读更多...
主存储器与CPU之间的连接（会画图）

主存储器与CPU之间的连接（会画图）

位扩展 字扩展 由于只有A13&#xff0c; A14 连到了译码器上&#xff0c;以、因此该译码器是一个 2/4 译码器&#xff0c;对应的选片有四种。选中第一个选片&#xff0c;就是把译码器“0口置0&#xff0c; 1~3口置1”&#xff0c;因为CS有非号&#xff0c;因此&#xff0c;低电…
阅读更多...
数据结构——线索树

数据结构——线索树

核心思路就是要先将空指针转为线索 也就是多出来的n1个指针&#xff0c;然后再将这些指针连成一个链表&#xff0c;遍历就可以达到O(n&#xff09;的速度打出 以下代码为中序遍历 前序和后续随缘更新 #include <iostream> #include <stdlib.h> using namespace s…
阅读更多...
【C++】string的使用

【C++】string的使用

目录 1、为什么学习string类&#xff1f; 2、标准库中的string类 2.1 string类 2.2 string类的常见接口声明 2.2.1 string类的常见构造 ​编辑 2.2.2 string类对象的访问及遍历操作 2.2.3 string类对象的容量操作 2.2.4 string类对象的修改操作 ​编辑 1、为什么学习s…
阅读更多...
npm install CERT_HAS_EXPIRED解决方法

npm install CERT_HAS_EXPIRED解决方法

目录 一、问题描述二、问题原因三、解决方法 一、问题描述 执行命令 npm install 报错&#xff1a; npm WARN registry Unexpected warning for https://registry.npm.taobao.org/: Miscellaneous Warning CERT_HAS_EXPIRED: request to https://registry.npm.taobao.org/js-…
阅读更多...
excel中vlookup查找值必须在table_array的第一列，有其他办法吗有XLOOKUP

excel中vlookup查找值必须在table_array的第一列，有其他办法吗有XLOOKUP

vlookup查找值必须在table_array的第一列&#xff0c;有其他办法吗&#xff1f;有XLOOKUP。 vlookup 查找如下&#xff0c;查找值必须在table_array的第一列 如果下面&#xff0c;编码和名称交换位置&#xff0c;就不能使用vlookup查找了。 XLOOKUP 查找如下
阅读更多...
最新文章

Copyright @ 2022~2023