并发包compareAndSet的疑惑？为什么没有对应的compare,If Not Equals,Then Set的方法呢？...

最新推荐文章于 2025-09-26 16:38:38 发布

最新推荐文章于 2025-09-26 16:38:38 发布 · 336 阅读

本文探讨了并发包中compareAndSet方法的工作原理及其应用场景，并解释了为何没有提供compare,IfNotEquals,ThenSet方法的原因，即这种操作未被CPU直接支持。

public final boolean compareAndSet(boolean expect,boolean update)
如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。

并发包的这个方法，看起来意思是compare，If Equals，Then Set

我有个疑惑，为什么没有对应的compare,If Not Equals,Then Set的方法呢？

比如，以下场景，就无法使用compareAndSet：

if(a != b){
  a = b;
}

if(a != c){
  a = b;
}

因为我觉得，compare，If Equals，Then Set 和 compare,If Not Equals,Then Set 是不能互相实现对方的，所以应该要有另外的方法才完整。

查到了：原来是因为compareAndSet是cpu支持的，没有 compare,If Not Equals,Then Set是因为cpu不支持。

http://tomyz0223.iteye.com/blog/770677

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

iteye_1456

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

Java高频面试基础问题与知识点整理

张彦峰的博客

11-04

171万+

Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。

Nacod服务注册与发现（AP架构）、心跳检查机制

qq_1149513559的博客

04-11

2675

文章目录1. Nacos核心功能点2. 服务注册 1. Nacos核心功能点 Nacos架构图如下：结合以上架构图，Nacos的核心功能点有如下几点：服务注册：Nacos Client会通过发送REST风格请求的方式向Nacos Server注册自己的服务，提供自身的元数据，比如ip地址、端口等信息。Nacos Server接收到注册请求后，就会把这些元数据信息存储在一个双层的内存Map中。服务心跳

参与评论您还未登录，请先登录后发表或查看评论

java compareandset 包_java – compareAndSet不成功操作的内存效果

weixin_28750663的博客

02-16

342

Java通过其原子类公开CAS操作,例如boolean compareAndSet(expected,update)JavaDocs指定了compareAndSet操作的内存效果,如下所示：compareAndSet and all other read-and-update operationssuch as getAndIncrement have the memory effects of ...

解决cas的ABA问题时，compareAndSet执行一直为false

qq_26048293的博客

06-29

723

解决cas的ABA问题时，compareAndSet执行一直为false 每次执行都是false，期望值获取都没问题，但是就是false 后来才发现是因为泛型为Integer的问题， Integer对象值得范围在-128 ~127之间时公用同一块内存空间，所以超过该范围的数如果用‘’去比较即使值一样也是flase，相当于是new了一个Integer，不是一个加载器。 *cas用的应该时来进行比较的，所以才为flase，真是个大坑，找了半天源码都没问题。* public static void main

java compareandset 包_java-如果完全像compareAndSet那样实现weakCompareAndSet会失败吗？

weixin_26803527的博客

02-13

232

(请注意，此问题不是关于CAS的，而是关于“可能偶然失败”的Javadoc)。这两个方法与AtomicInteger类的两种方法之间的Javadoc唯一区别是，weakCompareAndSet包含以下注释：“可能会虚假失败”。现在，除非我的眼睛因某种咒语而被欺骗，否则这两种方法的确看起来完全一样：public final boolean compareAndSet(int expect, int...

AtomicReference compareAndSet 返回false的原因分析

weixin_42554209的博客

11-16

1310

在学习AtomicReference的过程中，在进行小测试的时候，遇到了一个问题，对于超过缓存范围(-128-127)内的Integer数值类型进行修改时修改无效。 demo代码如下： AtomicReference<Integer> ar = new AtomicReference<>(100); new Thread(() -> { String name = Thread.currentThread().getName();

java not equals_JAVA中equals()方法的重要性 | 学步园

weixin_39943220的博客

02-20

812

对于对象比较使用equals()方法的重要性，这里以String类为例进行了比较。/*** 对于对象比较使用equals()方法的重要性，这里以String类为例进行了比较。* @author HAN**/public class TestEqual {public TestEqual(){testMethod();}void testMethod(){String str=new String(...

解密分布式锁：保障系统一致性的关键

c18213590220的博客

12-11

1410

在当今快速发展的分布式系统中，多个节点之间的协调和一致性成为了一个日益重要的挑战。本文将深入探讨分布式锁的原理、实现方式以及在实际应用中的重要性。

黑马八股文(图文+代码)

最新发布

拧之的博客

09-26

1944

本文主要探讨了Spring框架和Redis的相关技术问题。在Spring方面，讨论了单例Bean的线程安全性、AOP实现原理、事务管理机制、循环依赖解决方案以及Spring MVC执行流程等内容。在Redis方面，分析了缓存穿透/击穿/雪崩的解决方案、持久化机制、数据淘汰策略、分布式锁实现以及高可用集群架构等。此外，还涵盖了MySQL索引优化、事务隔离级别、主从同步原理以及分库分表实践。文章最后简要介绍了微服务架构中的服务注册发现、负载均衡、限流策略和分布式事务解决方案。这些技术点对构建高性能、高可用的分布

【线程池】线程池的使用案例

weixin_44823875的博客

03-20

9393

多线程-- 线程池（1）自定义线程池（2）java自带的线程池（1）自定义线程池（1）为什么使用线程池每一个线程的启动和结束都是比较消耗时间和占用资源的。使用线程池的过程中创建固定数量的线程，不用创建多余新的线程，而是循环使用那些已经存在的线程。（2）自定义线程池设计思路 1-准备一个任务容器 2-一次性启动10个消费者线程 3-刚开始任务容器是空的，所以线程都wait在上面 4-直到一个外部线程往这个任务容器中扔了一个“任务”，就会有一个消费者线程被唤醒 5-这个消费者线程取出“任务”，并且执行这

java中not equals_java中equals和等号(==)的区别浅谈

weixin_35890184的博客

02-25

2090

java中的数据类型，可分为两类：1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean 他们之间的比较，应用双等号(==),比较的是他们的值。2.复合数据类型(类)当他们用(==)进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。...

java中not equals,Java基础之String中equals,声明方式,等大总结

weixin_39752434的博客

03-21

1156

无论你是一个编程新手还是老手，提到String你肯定感觉特别熟悉，因为String类我们在学习java基础的时候就已经学过，但是String类型有我们想象的那么简单吗？其实不然，String类型的知识点还是比较多的。今天就和大家来一起讨论一下，关于String的一些容易让人疑惑的地方，废话不多说进入正题。。。如有谬误请批评指正，如果有疑问请留言。我会在第一时间修改或回答通过本篇博客你将学到以下知识...

对compareAndSet方法的一点小见解

星空之下☪

04-29

4489

今天在看《写给大忙人的看的Java SE 8》第6章的时候，在开头看到：public static AtomicLong largest = new AtomicLong(); //在某些线程中 largest.set(Math.max(!largest.get(),observed));//错误--竞争条件上面这段代码是错误的，理由是这个更新过程不是原子性的。不是原子性，也就意味着在多线程并发的...

java not equals_assertEquals和assertNotEquals，谨慎使用 assertNotEquals

weixin_39761822的博客

02-20

1116

在使用 org.testng.Assert 中的assertEquals(long actual, long expected) 和 assertNotEquals(**，**) 的时候注意比较两端数据类型，在 Assert 类中提供的assertEquals 支持：boolean double float int long Map Object byte[] byte ...

java equals 区别_java中equals和 == 的区别

weixin_36393239的博客

02-16

199

摘自：https://blog.csdn.net/weixin_37690143/article/details/797677611、功能不同"=="是判断两个变量或实例是不是指向同一个内存空间。"equals"是判断两个变量或实例所指向的内存空间的值是不是相同。2、定义不同"equals"在JAVA中是一个方法。"=="在JAVA中只是一个运算符合。java中的数据类型，可分为两类：1.基本数据...

java no equals_如何在Java中避免equals方法的隐藏陷阱（一）

weixin_33463850的博客

03-04

611

常见的等价方法陷阱java.lang.Object 类定义了equals这个方法，它的子类可以通过重载来覆盖它。不幸的是，在面向对象中写出正确的equals方法是非常困难的。事实上，在研究了大量的Java代码后，2007 paper的作者得出了如下的一个结论：几乎所有的equals方法的实现都是错误的！这个问题是因为等价是和很多其他的事物相关联。例如其中之一，一个的类型C的错误等价方法可能意味着你...

java not equals_java中equals和==的区别详解

weixin_30368981的博客

02-20

1478

java中的数据类型，可分为两类：1.基本数据类型。byte,short,char,int,long,float,double,boolean这八大原始数据类型他们之间的比较，使用“==”，比较的是他们的值。2.符合数据类型符合数据类型，用“==”比较时候，比较的是它们在内存中的存放地址。java中所以的类都是继承于Object这个基类的，Object中有个equals()方法，这个方法比较也是对...

java之"equals"和"=="的区别

观千剑而后识器，操千曲而后晓声。

10-17

2710

java之String和Integer等包装类的"equals"和"=="的区别

Double.compare 这里的Double是一个对象吗？为什么要用包装类来调用compare方法

08-14

<think>我们有两个问题需要回答： 1. Java中Double.compare方法的作用 2. 为什么使用包装类Double而不是基本类型double 参考引用：引用[1]：Double类是原始类型double的包装类，它包含若干有效处理double值的方法，如将其转换为字符串表示形式，反之亦然。Double类的对象可以包含一个double值。主要有两个构造函数来初始化Double对象 -[^1]。引用[2]：以下是Java中的包装类及其对应的基本数据类型： Byte：byteShort：shortInteger：intLong：longFloat：floatDouble：doubleCharacter：charBoolean：boolean [^2]。引用[3]：Float是float的包装类，需要注意的是Float虽然提供了compare和equals方法，但是需要注意要比较的数是否在精度范围内，否则会发生数值不相等compare却为0或equals为true的情况。另外，应该静止使用浮点数来作为循环变量。[^3] 首先，回答第一个问题：Double.compare方法的作用。 Double.compare是Double类的一个静态方法，用于比较两个double值。它的方法签名如下： public static int compare(double d1, double d2) 作用：比较两个double数值，返回一个整数值来表示大小关系： - 如果d1在数值上等于d2，则返回0。 - 如果d1小于d2，则返回负整数（通常是-1）。 - 如果d1大于d2，则返回正整数（通常是1）。 为什么要使用Double.compare而不是直接使用关系运算符（如<, >, ==）？因为double是浮点数，存在一些特殊值（如NaN）和精度问题。直接使用关系运算符比较两个double值可能会出现问题，例如： - NaN（非数字）与任何值（包括它自己）比较，使用关系运算符都会返回false，而使用Double.compare则规定：NaN等于NaN（但实际上，根据IEEE 754标准，NaN与任何值比较都不相等，包括自身。但Java的Double.compare方法将NaN视为相等？实际上不是，我们来看一下官方文档）。实际上，根据Java文档，Double.compare方法对NaN的处理如下： - 如果d1和d2都是NaN，则返回0（即相等）。 - 如果d1是NaN而d2不是，则返回1（即d1大于d2？这里注意，实际上NaN在比较中应该被认为大于任何非NaN的数值？但根据文档：Double.NaN被认为等于自身，并且大于所有其他double值（包括Double.POSITIVE_INFINITY））。 - 如果d2是NaN而d1不是，则返回-1（即d1小于d2）。另外，正零和负零在比较时被认为是相等的（即0.0 == -0.0为true，但Double.compare(0.0, -0.0)返回0？实际上，根据IEEE标准，正零和负零在数值上是相等的，所以返回0。但是注意，在某些情况下，比如使用equals方法，Double对象会认为0.0和-0.0是不同的，但Double.compare方法认为相等。所以，使用Double.compare可以正确处理所有情况，包括NaN和正负零。第二个问题：为什么使用包装类Double而不是基本类型double？包装类的主要用途包括： 1. 在需要对象而非基本类型的场合使用。例如，在集合类（如ArrayList）中，只能存储对象，不能存储基本类型。因此，如果我们想将double值放入一个List中，就必须使用Double包装类。 2. 提供了一些有用的方法。例如，Double类提供了将字符串解析为double的方法（Double.parseDouble），以及将double转换为字符串的方法（Double.toString）。此外，还有比较方法（如compare）、常量（如MAX_VALUE、MIN_VALUE、NaN）等。 3. 允许null值。基本类型double不能为null，而Double对象可以为null。这在某些场景下是有用的，比如表示缺失值（但要注意空指针异常）。 4. 在泛型中必须使用包装类，因为Java泛型不支持基本类型。但是，使用包装类也有一些缺点： - 包装类对象比基本类型占用更多的内存（因为对象有对象头等开销）。 - 自动装箱和拆箱可能会带来性能开销（尽管在大多数情况下可以忽略）。所以，在需要对象特性或使用泛型时，我们使用包装类；而在需要高性能和节省内存时，我们使用基本类型。结合引用[3]中提到的浮点数比较问题：由于浮点数的精度问题，直接使用==比较两个double值可能会出现问题（尤其是经过计算后）。因此，比较两个double值通常使用一个误差范围（epsilon）。但是，Double.compare方法内部也是使用关系运算符，并且对特殊值（如NaN）进行了处理，但它并不解决精度问题。对于需要精度控制的比较，我们通常使用如下方式： Math.abs(a - b) < epsilon 但是，Double.compare方法并不考虑精度，它严格按照数值大小比较（包括处理特殊值）。所以，如果两个double值非常接近但在二进制表示上不同，Double.compare会认为它们不相等。总结： - Double.compare方法用于比较两个double值，并正确处理NaN和正负零。 - 包装类Double在需要对象、泛型、null值或使用Double类的方法时使用。下面给出一个代码示例： ```java public class DoubleComparisonExample { public static void main(String[] args) { double d1 = Double.NaN; double d2 = Double.NaN; double d3 = 0.0; double d4 = -0.0; // 使用关系运算符 System.out.println(d1 == d2); // false，因为NaN不等于任何值，包括自身 System.out.println(d3 == d4); // true，正零和负零在数值上相等 // 使用Double.compare System.out.println(Double.compare(d1, d2)); // 0，表示相等 System.out.println(Double.compare(d3, d4)); // 0，表示相等 // 比较一个NaN和一个非NaN System.out.println(Double.compare(d1, d3)); // 1，因为NaN被认为大于任何非NaN值 System.out.println(Double.compare(d3, d1)); // -1 } } ``` 输出： false true 0 0 1 -1 注意：在引用[3]中提到，浮点数比较要注意精度问题，所以如果两个double值是通过计算得到的，并且我们允许一定的误差，那么就不应该使用Double.compare，而应该使用误差范围比较。但是，Double.compare在需要严格按数值比较（如排序）时非常有用。最后，生成相关问题： 1. 在Java中，如何正确比较两个浮点数（float或double）？ 2. Java自动装箱和拆箱机制是什么？它如何影响性能？ 3. 为什么在集合类中不能使用基本数据类型？ 4. Double类中还有哪些常用的静态方法？</think>### Java中`Double.compare()`方法的作用及包装类的必要性 #### 1. `Double.compare()`方法详解 `Double.compare(double d1, double d2)`是Java中用于安全比较两个double值的静态方法，其核心作用包括： ```java // 方法签名 public static int compare(double d1, double d2) ``` **返回值含义**： - 返回负数：当 $d1 < d2$ - 返回0：当 $d1 = d2$ - 返回正数：当 $d1 > d2$ **特殊值处理机制**： | 场景 | 返回值 | 说明 | |--------------------------|--------|----------------------------------------------------------------------| | 两个NaN比较 | 0 | 认为NaN相等（不同于 `==` 运算符）[^3] | | NaN与任何非NaN值比较 | 1 | NaN被视为大于所有数值（包括无穷大） | | 正零(0.0)和负零(-0.0)比较| 0 | 认为数值相等（符合IEEE 754标准） | | 常规数值比较 | 按实际值 | 如 `compare(3.14, 2.71)` 返回正数 | **与运算符比较的区别**： ```java double nan = Double.NaN; double inf = Double.POSITIVE_INFINITY; // 错误方式（结果违反直觉） System.out.println(nan == nan); // false ❌ System.out.println(nan > inf); // false ❌ // 正确方式 System.out.println(Double.compare(nan, nan) == 0); // true ✅ System.out.println(Double.compare(nan, inf) > 0); // true ✅ ``` #### 2. 为何使用包装类Double 基本类型`double`与包装类`Double`的核心区别： | 特性 | `double`基本类型 | `Double`包装类 | |------------------|------------------|-------------------------| | 存储方式 | 栈内存 | 堆内存（对象） | | 默认值 | 0.0 | `null` | | 集合支持 | 不支持 | 支持（如List<Double>） | | 特殊值处理 | 有限 | 完整API支持（如NaN） | | 附加功能 | 无 | 比较/转换/常量等方法 | **必须使用包装类的场景**： 1. **泛型集合操作** ```java List<Double> prices = new ArrayList<>(); // 必须用包装类 prices.add(19.99); ``` 2. **特殊值处理** 需要表示缺失值时： ```java Double temperature = null; // 有效表示"未测量" // double temp = null; // 编译错误 ``` 3. **对象方法调用** 需要调用比较方法时： ```java Double.compare(d1, d2); // ✅ 正确 // d1.compareTo(d2); // ❌ 基本类型无此方法 ``` 4. **API兼容性** 反射等API要求对象类型： ```java Method method = Double.class.getMethod("isNaN"); method.invoke(Double.valueOf(0.0/0.0)); // 返回true ``` #### 3. 浮点数比较的精度问题虽然`Double.compare()`能正确处理特殊值，但**不解决精度问题**： ```java double a = 0.1 + 0.2; // ≈0.30000000000000004 double b = 0.3; // 0.3 // 精度问题导致错误结果 System.out.println(a == b); // false ❌ System.out.println(Double.compare(a, b)); // 1 (认为a>b) ❌ // 正确做法：使用误差范围 boolean isEqual = Math.abs(a - b) < 1e-10; // true ✅ ``` #### 4. 完整使用示例 ```java import java.util.*; public class DoubleComparisonDemo { public static void main(String[] args) { // 创建含特殊值的Double列表 List<Double> values = Arrays.asList( 3.14, Double.NaN, 0.0, -0.0, Double.POSITIVE_INFINITY, 1.0/0.0 ); // 使用Double.compare排序 Collections.sort(values, Double::compare); // 输出排序结果 [-0.0, 0.0, 3.14, ∞, ∞, NaN] System.out.println(values); } } ``` #### 5. 关键结论 1. `Double.compare()`： - 正确处理NaN、无穷大等特殊值 - 符合IEEE 754浮点数标准 - 适用于排序等需要确定顺序的场景[^1] 2. 包装类必要性： - 实现对象化操作（如集合存储） - 支持null值表示数据缺失 - 提供完整API（比较/转换/校验等）[^2] - 满足泛型要求（如`List<Double>`）[^2] 3. 精度警示： - 浮点数计算存在固有精度问题 - 比较相等时需使用误差范围 $|a-b| < \epsilon$ - 避免用浮点数作为循环计数器[^3]