来聊聊CAS

什么是CAS

CAS全称Compare-And-Swap，是一种无锁编程算法，即比较当前的值与旧值是否相等若相等则进行修改操作(乐观锁机制)，该类常用于多线程共享变量的修改操作。而其底层实现也是基于硬件平台的汇编指令，JVM只是封装其调用仅此而已。

CAS基础使用示例

如下所示，可以看出使用封装CAS操作的AtomicInteger操作多线程共享变量无需我们手动加锁，因为避免过多人为操作这就大大减少了多线程操作下的失误。

使用原子类操作共享数据

public class CasTest {private AtomicInteger count = new AtomicInteger();public void increment() {count.incrementAndGet();}// 使用 AtomicInteger 后，不需要加锁，也可以实现线程安全public int getCount() {return count.get();}public static void main(String[] args) {}
}

使用sync锁操作数据

public class Test {private int i=0;public synchronized int add(){return i++;}
}

CAS与传统synchronized区别

CAS为什么比synchronized快(重点)

CAS工作原理是基于乐观锁且操作是原子性的，与synchronized的悲观锁(底层需要调用操作系统的mutex锁)相比，效率也会相对高一些。

CAS是不是操作系统执行的？(重点)

不是，CAS是主要是通过处理器的指令来保证原子性的。

CAS存在那些问题?

但即便如此CAS仍然存在两个问题：

  1. 可能存在长时间CAS：如下代码所示，这就是AtomicInteger底层的UNSAFE类如何进行CAS的具体代码 ，可以看出这个CAS操作需要拿到volatile变量后在进行循环CAS才有可能成功这就很可能存在自旋循环，从而给CPU带来很大的执行开销。
 public final int getAndSetInt(Object var1, long var2, int var4) {int var5;//声明一个var5，只do {//通过getIntVolatile获取当前原子数的值var5 = this.getIntVolatile(var1, var2);//只有传入var1和现在获得的var5 一样，才说明值没被修改过，我们才能将值设置为var4} while(!this.compareAndSwapInt(var1, var2, var5, var4));return var5;}

  1. CAS只能对一个变量进行原子操作：为了解决这个问题，JDK 1.5之后通过AtomicReference使得变量可以封装成一个对象进行操作

  2. ABA问题：总所周知CAS就是比对当前值与旧值是否相等，在进行修改操作，假设我现在有一个变量值为A，我改为B，再还原为A，这样操作变量值是没变的？那么CAS也会成功不就不合理吗？这就好比一个银行储户想查询概念转账记录，如果转账一次记为1，如果按照ABA问题的逻辑，那么这个银行账户转账记录次数有可能会缺少。为了解决这个问题JDK 1.5提供了AtomicStampedReference，通过比对版本号在进行CAS操作，那么上述操作就会变为1A->2B->3A,由于版本追加，那么我们就能捕捉到当前变量的变化了。

从源码角度了解java如何封装汇编的UNSAFE

代码也很简单，就是拿到具有可见性的volatile变量i，然后判断i和当前对象paramObject对应的i值是否一致，若一致则说明没被人该过，进而进行修改操作，反之自旋循环获取在进行CAS。

public final int getAndAddInt(Object paramObject, long paramLong, int paramInt){int i;doi = getIntVolatile(paramObject, paramLong);while (!compareAndSwapInt(paramObject, paramLong, i, i + paramInt));return i;}public final long getAndAddLong(Object paramObject, long paramLong1, long paramLong2){long l;dol = getLongVolatile(paramObject, paramLong1);while (!compareAndSwapLong(paramObject, paramLong1, l, l + paramLong2));return l;}public final int getAndSetInt(Object paramObject, long paramLong, int paramInt){int i;doi = getIntVolatile(paramObject, paramLong);while (!compareAndSwapInt(paramObject, paramLong, i, paramInt));return i;}public final long getAndSetLong(Object paramObject, long paramLong1, long paramLong2){long l;dol = getLongVolatile(paramObject, paramLong1);while (!compareAndSwapLong(paramObject, paramLong1, l, paramLong2));return l;}public final Object getAndSetObject(Object paramObject1, long paramLong, Object paramObject2){Object localObject;dolocalObject = getObjectVolatile(paramObject1, paramLong);while (!compareAndSwapObject(paramObject1, paramLong, localObject, paramObject2));return localObject;}

手写Unsafe实现20个线程500次CAS自增

代码逻辑和注释如下，读者可自行debug查看逻辑

public class CasCountInc {private static Logger logger = LoggerFactory.getLogger(CasCountInc.class);// 获取Unsafe对象private static Unsafe unsafe = getUnsafe();// 线程池数目private static final int THREAD_COUNT = 20;// 每个线程运行自增次数private static final int EVERY_THREAD_ADD_COUNT = 500;// 自增的count的值，volatile保证可见性private volatile int count = 0;// count字段的偏移量private static long countOffSet;private static Unsafe getUnsafe() {Unsafe unsafe = null;try {Field field = Unsafe.class.getDeclaredField("theUnsafe");field.setAccessible(true);unsafe = (Unsafe) field.get(null);} catch (Exception e) {logger.info("获取unsafe失败，失败原因:[{}]", e.getMessage(), e);}return unsafe;}static {try {countOffSet = unsafe.objectFieldOffset(CasCountInc.class.getDeclaredField("count"));} catch (NoSuchFieldException e) {logger.error("获取count的偏移量报错，错误原因:[{}]", e.getMessage(), e);}}public void inc() {int oldCount = 0;//基于cas完成自增do {oldCount = count;} while (!unsafe.compareAndSwapInt(this, countOffSet, oldCount, oldCount + 1));}public static void main(String[] args) throws InterruptedException {CasCountInc casCountInc = new CasCountInc();CountDownLatch countDownLatch = new CountDownLatch(THREAD_COUNT);IntStream.range(0, THREAD_COUNT).forEach(i -> {new Thread(() -> {IntStream.range(0, EVERY_THREAD_ADD_COUNT).forEach((j) -> {casCountInc.inc();});countDownLatch.countDown();}).start();});countDownLatch.await();logger.info("count最终结果为 [{}]", casCountInc.count);}
}

CAS 平时怎么用的，会有什么问题，为什么快，如果我用 for 循环代替 CAS 执行效率是一样的吗？(重点)

CAS 平时怎么用的:我们希望从一个视频中完成人像比对的功能，通过图像识别技术完成视频逐帧切割，只要有一帧的图片被识别分数达到90以上即可算完成。任务是串行的，如果是个大视频则执行时间会非常漫长。

经过对需求复盘，整体来说这个功能就是多任务只要有一个任务完成就算完成的需求。对此我们写了一个Callable的任务，这个任务中的多线程共享两个变量atomicInteger 、countDownLatch，都是由外部调度的，只要一个任务分数达到90则CAS自增，countDown倒计时门闩。

public class Task implements Callable<Integer> {private static Logger logger = LoggerFactory.getLogger(Task.class);private AtomicInteger atomicInteger ;private CountDownLatch countDownLatch;public Task(AtomicInteger atomicInteger, CountDownLatch countDownLatch) {this.atomicInteger = atomicInteger;this.countDownLatch = countDownLatch;}@Overridepublic Integer call() throws Exception {int score = (int) (Math.random() * 100);logger.info("当前线程：{}，识别分数:{}", Thread.currentThread().getName(), score);synchronized (this){}if (score > 90 && atomicInteger.getAndIncrement()==0) {logger.info("当前线程：{} countDown",Thread.currentThread().getName());countDownLatch.countDown();logger.info("当前线程：{} 返回比对分数:{}", Thread.currentThread().getName(), score);return score;}return -1;}
}

执行代码

public class Main {private static Logger logger = LoggerFactory.getLogger(Main.class);public static void main(String[] args) throws InterruptedException {ExecutorService threadPool = Executors.newFixedThreadPool(100);CountDownLatch countDownLatch=new CountDownLatch(1);for (int i = 0; i < 100; i++) {Future<Integer> task = threadPool.submit(new Task(countDownLatch));}logger.info("阻塞中");countDownLatch.await();logger.info("阻塞结束");threadPool.shutdown();while (!threadPool.isTerminated()){}}
}

存在问题:CAS是基于乐观锁机制，所以数据同步失败就会原地自旋，在高并发场景下开销很大，所以线程数很大的情况下不建议使用原子类。

存在问题: 如果并发量大的话，自旋的线程多了就会导致性能瓶颈。
for 循环代替 CAS执行效率是否一样:大概率是CAS快，原因如下:

  1. CAS是native方法更接近底层
  2. for循环为了保证线程安全可能会用到sync锁或者Lock无论那种都需要上锁和释放的逻辑，相比CAS乐观锁来说开销很大。

AtomicInteger以及相关原子类

原子类更新基本类型

AtomicBoolean: 原子更新布尔类型。
AtomicInteger: 原子更新整型。
AtomicLong: 原子更新长整型。

原子类更新数组类型

AtomicIntegerArray: 原子更新整型数组里的元素。
AtomicLongArray: 原子更新长整型数组里的元素。
AtomicReferenceArray: 原子更新引用类型数组里的元素。

基本使用示例

import java.util.concurrent.atomic.AtomicIntegerArray;public class AtomicIntegerArrayDemo {public static void main(String[] args) throws InterruptedException {AtomicIntegerArray array = new AtomicIntegerArray(new int[] { 0, 0 });System.out.println(array);
//        索引1位置+2System.out.println(array.getAndAdd(1, 2));System.out.println(array);}
}

原子类更新引用类型

AtomicReference: 原子更新引用类型。AtomicStampedReference: 原子更新引用类型, 内部使用Pair来存储元素值及其版本号。AtomicMarkableReferce: 原子更新带有标记位的引用类型。

原子类操作引用类型使用示例

import java.util.concurrent.atomic.AtomicReference;public class AtomicReferenceTest {public static void main(String[] args){// 创建两个Person对象，它们的id分别是101和102。Person p1 = new Person(101);Person p2 = new Person(102);// 新建AtomicReference对象，初始化它的值为p1对象AtomicReference ar = new AtomicReference(p1);// 通过CAS设置ar。如果ar的值为p1的话，则将其设置为p2。ar.compareAndSet(p1, p2);Person p3 = (Person)ar.get();System.out.println("p3 is "+p3);System.out.println("p3.equals(p1)="+p3.equals(p1));System.out.println("p3.equals(p2)="+p3.equals(p2));}
}class Person {volatile long id;public Person(long id) {this.id = id;}public String toString() {return "id:"+id;}
}

原子类更新字段类型

方法简介

AtomicIntegerFieldUpdater: 原子更新整型的字段的更新器。
AtomicLongFieldUpdater: 原子更新长整型字段的更新器。
AtomicStampedFieldUpdater: 原子更新带有版本号的引用类型。
AtomicReferenceFieldUpdater: 上面已经说过此处不在赘述。

原子类更新字段使用示例

如下所示，我们创建一个基础类DataDemo，通过原子类CAS操作字段值进行自增操作。

public class TestAtomicIntegerFieldUpdater {private static Logger logger = LoggerFactory.getLogger(TestAtomicIntegerFieldUpdater.class);public static void main(String[] args) {TestAtomicIntegerFieldUpdater tIA = new TestAtomicIntegerFieldUpdater();tIA.doIt();}/*** 返回需要更新的整型字段更新器** @param fieldName* @return*/public AtomicIntegerFieldUpdater<DataDemo> updater(String fieldName) {return AtomicIntegerFieldUpdater.newUpdater(DataDemo.class, fieldName);}public void doIt() {DataDemo data = new DataDemo();// 修改公共变量，返回更新前的旧值 0AtomicIntegerFieldUpdater<DataDemo> updater = updater("publicVar");int oldVal = updater.getAndIncrement(data);logger.info("publicVar 更新前的值[{}] 更新后的值 [{}]", oldVal, data.publicVar);// 更新保护级别的变量AtomicIntegerFieldUpdater<DataDemo> protectedVarUpdater = updater("protectedVar");int oldProtectedVar = protectedVarUpdater.getAndAdd(data, 2);logger.info("protectedVar 更新前的值[{}] 更新后的值 [{}]", oldProtectedVar, data.protectedVar);// logger.info("privateVar = "+updater("privateVar").getAndAdd(data,2)); 私有变量会报错/** 下面报异常：must be integer* */
//        logger.info("integerVar = "+updater("integerVar").getAndIncrement(data));//logger.info("longVar = "+updater("longVar").getAndIncrement(data));}class DataDemo {// 公共且可见的publicVarpublic volatile int publicVar = 0;// 保护级别的protectedVarprotected volatile int protectedVar = 4;// 私有变量private volatile int privateVar = 5;// final 不可变量public final int finalVar = 11;public volatile Integer integerVar = 19;public volatile Long longVar = 18L;}}

通过上述代码我们可以总结出CAS字段必须符合以下要求：

1. 变量必须使用volatile保证可见性
2. 必须是当前对象可以访问到的类型才可进行操作‘
3. 只能是实例变量而不是类变量，即不可以有static修饰符
4. 包装类也不行

CAS的ABA问题

CAS更新前会检查值有没有变化，如果没有变化则认为没人修改过，在进行更新操作。这种情况下，若我们A值修改为B，B再还原为A。这种修改再还原的操作，CAS是无法感知是否变化的，这就是所谓的ABA问题。

AtomicStampedReference源码详解

源码如下所示，可以看到AtomicStampedReference解决ABA问题的方式是基于当前修改操作的时间戳和元引用值是否一致，若一直则进行数据更新

public class AtomicStampedReference<V> {private static class Pair<T> {final T reference;  //维护对象引用final int stamp;  //用于标志版本private Pair(T reference, int stamp) {this.reference = reference;this.stamp = stamp;}static <T> Pair<T> of(T reference, int stamp) {return new Pair<T>(reference, stamp);}}private volatile Pair<V> pair;..../*** expectedReference ：更新之前的原始引用值* newReference : 新值* expectedStamp : 预期时间戳* newStamp : 更新后的时间戳*/public boolean compareAndSet(V   expectedReference,V   newReference,int expectedStamp,int newStamp) {// 获取当前的(元素值，版本号)对Pair<V> current = pair;return// 引用没变expectedReference == current.reference &&// 版本号没变expectedStamp == current.stamp &&//可以看到这个括号里面用了一个短路运算如果当前版本与新值一样就说更新过，就不往下走CAS代码了((newReference == current.reference &&newStamp == current.stamp) ||// 构造新的Pair对象并CAS更新casPair(current, Pair.of(newReference, newStamp)));}private boolean casPair(Pair<V> cmp, Pair<V> val) {// 调用Unsafe的compareAndSwapObject()方法CAS更新pair的引用为新引用return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);}

AtomicStampedReference解决ABA问题示例

代码示例，我们下面就用other代码模拟干扰现场，如果other现场先进行CAS更新再还原操作，那么main线程的版本号就会过时，CAS就会操作失败

/*** ABA问题代码示例*/
public class AtomicStampedReferenceTest {private static AtomicStampedReference<Integer> atomicStampedRef =new AtomicStampedReference<>(1, 0);public static void main(String[] args) {Thread main = new Thread(() -> {System.out.println("操作线程" + Thread.currentThread() + ",初始值 a = " + atomicStampedRef.getReference());int stamp = atomicStampedRef.getStamp(); //获取当前标识别try {Thread.sleep(1000); //等待1秒 ，以便让干扰线程执行} catch (InterruptedException e) {e.printStackTrace();}boolean isCASSuccess = atomicStampedRef.compareAndSet(1, 2, stamp, stamp + 1);  //此时expectedReference未发生改变，但是stamp已经被修改了,所以CAS失败System.out.println("操作线程" + Thread.currentThread() + ",CAS操作结果: " + isCASSuccess);}, "主操作线程");Thread other = new Thread(() -> {Thread.yield(); // 确保thread-main 优先执行atomicStampedRef.compareAndSet(1, 2, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);System.out.println("操作线程" + Thread.currentThread() + ",【increment】 ,值 = " + atomicStampedRef.getReference());atomicStampedRef.compareAndSet(2, 1, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);System.out.println("操作线程" + Thread.currentThread() + ",【decrement】 ,值 = " + atomicStampedRef.getReference());}, "干扰线程");main.start();other.start();}}

AtomicMarkableReference解决对象ABA问题

AtomicMarkableReference，它不是维护一个版本号，而是维护一个boolean类型的标记，标记对象是否有修改，从而解决ABA问题。

public boolean weakCompareAndSet(V       expectedReference,V       newReference,boolean expectedMark,boolean newMark) {return compareAndSet(expectedReference, newReference,expectedMark, newMark);}

AtomicInteger自增到10000后如何归零

AtomicInteger atomicInteger=new AtomicInteger(10000);
atomicInteger.compareAndSet(10000, 0);

参考文献

JUC原子类: CAS, Unsafe和原子类详解

深入理解高并发编程

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

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

相关文章

探秘npm：解锁前端生态的魔法工具

探秘npm：解锁前端生态的魔法工具

在当今的软件开发世界中&#xff0c;前端技术以其快速发展和不断创新的特点吸引了无数开发者的关注。然而&#xff0c;随着前端项目越来越庞大和复杂&#xff0c;如何高效地管理和共享代码成为了一个紧迫的问题。在这个领域中&#xff0c;npm&#xff08;Node Package Manager&…
阅读更多...
【Spark精讲】Spark与MapReduce对比

【Spark精讲】Spark与MapReduce对比

目录 对比总结 MapReduce流程 ​编辑 MapTask流程 ReduceTask流程 MapReduce原理 阶段划分 Map shuffle Partition Collector Sort Spill Merge Reduce shuffle Copy Merge Sort 对比总结 Map端读取文件&#xff1a;都是需要通过split概念来进行逻辑切片&…
阅读更多...
【嵌入式面试】嵌入式经典面试题汇总（C语言）

【嵌入式面试】嵌入式经典面试题汇总（C语言）

一、预处理器 1、用预处理指令#define 声明一个常数&#xff0c;用以表明1年中有多少秒&#xff08;忽略闰年问题&#xff09; #define SECONDS_PER_YEAR (365*24*60*60)UL在这个例子中&#xff0c;SECONDS_PER_YEAR是一个宏常量&#xff0c;它的值被计算为365乘以24乘以60乘以…
阅读更多...
CVE-2023-50164 Apache Struts2漏洞复现

CVE-2023-50164 Apache Struts2漏洞复现

CVE-2023-50164 简介&#xff1a; 从本质上讲&#xff0c;该漏洞允许攻击者利用 Apache Struts 文件上传系统中的缺陷。它允许他们操纵文件上传参数并执行路径遍历。这种利用可能会导致在服务器上执行任意代码&#xff0c;从而导致各种后果&#xff0c;例如未经授权的数据访问…
阅读更多...
DS冲刺整理做题定理（四）查找与排序

DS冲刺整理做题定理（四）查找与排序

最后一期更新&#xff0c;考试之前应该不会再出该专题了&#xff0c;之后有时间会出一些有关链表的代码题&#xff0c;其他章节只挑选重点的总结~ 一.查找 1.顺序查找 又被称为线性查找&#xff0c;对顺序表和链表都使用~基本思想是从某一端开始&#xff0c;逐个检查关键字是否…
阅读更多...
GZ015 机器人系统集成应用技术样题1-学生赛

GZ015 机器人系统集成应用技术样题1-学生赛

2023年全国职业院校技能大赛 高职组“机器人系统集成应用技术”赛项 竞赛任务书&#xff08;学生赛&#xff09; 样题1 选手须知&#xff1a; 本任务书共 25页&#xff0c;如出现任务书缺页、字迹不清等问题&#xff0c;请及时向裁判示意&#xff0c;并进行任务书的更换。参赛队…
阅读更多...
分布式微服务架构日志调用链路跟踪-traceId

分布式微服务架构日志调用链路跟踪-traceId

分布式微服务架构日志调用链路跟踪-traceId 在ELK日志集成平台里(日志的写入,收集,跟踪,搜索,分析) 背景知识 在xxx(博主之前的公司),每个前端请求里面,都会在request的header区携带一个traceId 随机数值,用来跟踪在后端的调用链路栈打印.通过ES收集的日志数据,在ELK日志集成…
阅读更多...
idea__SpringBoot微服务12——整合Mybatis框架（新依赖）（新注解）

idea__SpringBoot微服务12——整合Mybatis框架（新依赖）（新注解）

整合Mybatis框架 完整项目地址&#xff1a;一、创建一个新的项目&#xff0c;导入mybatis依赖&#xff0c;lombok依赖。二、idea内置数据库管理工具连接数据库。三、编写实体类。四、编写Mapper接口。&#xff08;新注解&#xff09;五、编写Mapper.XML。六、编写数据库连接文件…
阅读更多...
OpenCV中的格式转换

OpenCV中的格式转换

目录 1. 前言2. 采集到播放数据流的走向3. OpenCV中的格式转换3.1 RGB3.2 YUV3.2.1 YUV420{P}3.2.2 YUV420SP 4 简单应用5. 关联文章 1. 前言 实际音视频开发过程芯片是做了硬件加速的&#xff0c;主要涉及到视频编解码。二次开发过程中需要对SDK做一定的封装使用才行。 写这…
阅读更多...
JMeter安装RabbitMQ测试插件

JMeter安装RabbitMQ测试插件

整体流程如下&#xff1a;先下载AMQP插件源码&#xff0c;可以通过antivy在本地编译成jar包&#xff0c;再将jar包导入JMeter目录下&#xff0c;重启JMeter生效。 Apache Ant 是一个基于 Java 的构建工具。Ant 可用于自动化构建和部署 Java 应用程序&#xff0c;使开发人员更轻…
阅读更多...
【算法】动态规划（dp问题），持续更新

【算法】动态规划（dp问题），持续更新

文章目录 0. 动态规划&#x1f3af;五个思考步骤 和 注意事项&#x1f3af;技巧优化思路 1. 子数组系列1.1 乘积为正数的最长子数组长度1.2 等差数列划分1.3 最长湍流子数组1.4 单词拆分1.5 环绕字符串中的子字符串 0. 动态规划 介绍本篇之前&#xff0c;我想先用人话叙述一般…
阅读更多...
MYSQl基础操作命令合集与详解

MYSQl基础操作命令合集与详解

MySQL入门 先来个总结 SQL语言分类 DDL&#xff08;Data Definition Language&#xff09; - 数据定义语言: 用于定义和管理数据库结构&#xff0c;包括创建、修改和删除数据库对象。 示例&#xff1a;CREATE, ALTER, DROP等语句。 DML&#xff08;Data Manipulation Lan…
阅读更多...
常见箱包五金ERP有哪些?箱包五金ERP哪个好用

常见箱包五金ERP有哪些?箱包五金ERP哪个好用

不同的箱包五金有不同的营销渠道和经营模式&#xff0c;而每一个营销渠道的商品信息维护流程和方式也不尽相同。另外&#xff0c;箱包五金价格制定、品质检验、产品种类、物料编码、批号追踪等环节的管理也比较繁琐。 近些年数字科技也被广泛的应用于箱包五金领域&#xff0c;…
阅读更多...
Module ‘app‘: platform ‘android-33‘ not found.

Module ‘app‘: platform ‘android-33‘ not found.

目录 一、报错信息 二、解决方法 一、报错信息 Module app: platform android-33 not found. 检查你的应用程序的build.gradle文件中的targetSdkVersion和compileSdkVersion是否正确设置为已安装的Android SDK版本。 确保你的Android Studio已正确安装并配置了所需的Android …
阅读更多...
spring-cloud-starter-gateway-mvc的网关实现

spring-cloud-starter-gateway-mvc的网关实现

一 概括 最近&#xff0c;我也一直在使用SpringCloudGateway开发我们自己的网关产品。根据我对这份正式文件的理解&#xff0c;内容如下&#xff1a; SpringCloudGateway的默认底层依赖项是SpringWebflux。我们知道Spring Webflux是异步和响应式编程&#xff0c;并且编程范式…
阅读更多...
TCP为什么可靠之“拥塞控制”

TCP为什么可靠之“拥塞控制”

拥塞控制是对网络层面的控制&#xff0c;主要是为了避免发送方发送过多的数据导致网络阻塞&#xff0c;以及出现网络阻塞时能够调整数据发送速率&#xff0c;达到对网络阻塞的一个控制。 拥塞窗口 拥塞窗口cwnd&#xff0c;是发送方维护的一个状态变量&#xff0c;会根据网络…
阅读更多...
Windows 11上边两个空格导致我多熬了1个多小时

Windows 11上边两个空格导致我多熬了1个多小时

将图中的文件路径复制&#xff0c;然后到文件管理器里边去搜索。 发现找不到&#xff0c;可是明明就在这里啊。 我百思不得其解&#xff0c;还以为是IDEA出了问题&#xff0c;我只能是重新启动项目&#xff0c;结果还是告诉我找不到文件。 要是同一个目录下已经有一个名为a…
阅读更多...
什么是CORS？如何在PHP中处理CORS问题？

什么是CORS？如何在PHP中处理CORS问题？

CORS&#xff08;Cross-Origin Resource Sharing&#xff09;是一种机制&#xff0c;它使用额外的 HTTP 头来告诉浏览器是否允许在 Web 页面上访问来自不同域的资源。在默认情况下&#xff0c;浏览器限制跨域请求&#xff0c;以防止潜在的安全风险。CORS 允许服务器指定哪些源&…
阅读更多...
【设计模式--行为型--中介者模式】

【设计模式--行为型--中介者模式】

设计模式--行为型--中介者模式 中介者模式定义结构案例实现优缺点使用场景 中介者模式 定义 又叫调停模式&#xff0c;定义一个中介角色来封装一系列对象之间的交互&#xff0c;使原有对象之间的耦合松散&#xff0c;且可以独立的改变它们之间的交互。 结构 抽象中介者角色…
阅读更多...
React中简单实现路由守卫（主要演示其原理）

React中简单实现路由守卫（主要演示其原理）

路由守卫在后台管理系统两种经典的跳转情况&#xff1a; 如果访问的是登录页面&#xff0c; 并且有token&#xff0c; 跳转到首页 如果访问的不是登录页面&#xff0c;并且没有token&#xff0c; 跳转到登录页 其余的都可以正常放行 下面简单实现React路由守卫功能&…
阅读更多...
最新文章

Copyright @ 2022~2023