(a==1 && a==2 && a==3) 在Java中可以评估为真吗？

Question

We know it can in JavaScript.

但是是否可以在 Java 中在下面给出的条件下打印“成功”消息？

if (a==1 && a==2 && a==3) {
    System.out.println("Success");
}

有人建议：

int _a = 1;
int a  = 2;
int a_ = 3;
if (_a == 1 && a == 2 && a_ == 3) {
    System.out.println("Success");
}

但是通过这样做，我们正在改变实际变量。有没有其他办法？

Answer 1

是的，如果您将变量 a 声明为 volatile，那么使用多个线程很容易实现这一点。

一个线程不断将变量 a 从 1 更改为 3，另一个线程不断测试 a == 1 && a == 2 && a == 3。经常会在控制台上打印连续的“成功”流。

（请注意，如果您添加 else {System.out.println("Failure");} 子句，您会发现测试失败的次数远多于成功的次数。）

实际上，它也可以在不将a 声明为 volatile 的情况下工作，但在我的 MacBook 上只有 21 次。如果没有volatile，则允许编译器或HotSpot 缓存a 或将if 语句替换为if (false)。最有可能的是，HotSpot 会在一段时间后启动并将其编译为缓存a 值的汇编指令。 使用 volatile，它会一直打印“成功”。

public class VolatileRace {
    private volatile int a;

    public void start() {
        new Thread(this::test).start();
        new Thread(this::change).start();
    }

    public void test() {
        while (true) {
            if (a == 1 && a == 2 && a == 3) {
                System.out.println("Success");
            }
        }
    }

    public void change() {
        while (true) {
            for (int i = 1; i < 4; i++) {
                a = i;
            }
        }
    }

    public static void main(String[] args) {
        new VolatileRace().start();
    }
}

Answer 2

使用来自brilliant code golf answer、Integer 值的概念（和代码）可能会被弄乱。

在这种情况下，它可以使 ints 转换为 Integers 在它们通常不相等时相等：

import java.lang.reflect.Field;

public class Test
{
    public static void main(String[] args) throws Exception
    {
        Class cache = Integer.class.getDeclaredClasses()[0];
        Field c = cache.getDeclaredField("cache");
        c.setAccessible(true);
        Integer[] array = (Integer[]) c.get(cache);
        // array[129] is 1
        array[130] = array[129]; // Set 2 to be 1
        array[131] = array[129]; // Set 3 to be 1

        Integer a = 1;
        if(a == (Integer)1 && a == (Integer)2 && a == (Integer)3)
            System.out.println("Success");
    }
}

不幸的是，它不如Erwin Bolwidt's multithreaded answer 优雅（因为这需要Integer 演员），但仍然有一些有趣的恶作剧发生。

Answer 3

在this question@aioobe 中建议（并反对）对Java 类使用C 预处理器。

虽然它非常作弊，但这是我的解决方案：

#define a evil++

public class Main {
    public static void main(String[] args) {
        int evil = 1;
        if (a==1 && a==2 && a==3)
            System.out.println("Success");
    }
}

如果使用以下命令执行，它将准确地输出一个Success：

cpp -P src/Main.java Main.java && javac Main.java && java Main

Answer 4

我们已经知道有可能让这段代码评估为真，这要归功于 Erwin Bolwidt 和 phflack 的出色回答，我想要表明您在处理与问题中提出的情况相似的情况时需要保持高度的注意力，因为有时您所看到的可能与您想象的不完全一样。

这是我试图证明此代码将Success! 打印到控制台的尝试。 我知道我作弊了一点，但我仍然认为这里是展示它的好地方。

无论编写这样的代码的目的是什么 - 最好知道如何处理以下情况以及如何检查您认为您看到的内容是否有误。

我使用了与拉丁语“a”不同的西里尔字母“a”。您可以检查 if 语句 here 中使用的字符。

这是可行的，因为变量的名称取自不同的字母表。它们是不同的标识符，创建了两个不同的变量，每个变量都有不同的值。

请注意，如果您希望此代码正常工作，则需要将字符编码更改为支持两个字符的编码，例如所有 Unicode 编码（UTF-8、UTF-16（BE 或 LE）、UTF-32，甚至 UTF-7）或 Windows-1251、ISO 8859-5、KOI8-R（谢谢 - Thomas Weller 和 Paŭlo Ebermann - 指出）：

public class A {
    public static void main(String[] args) {
        int а = 0;
        int a = 1;
        if(а == 0 && a == 1) {
            System.out.println("Success!");
        }
    }
}

（我希望您将来永远不必处理此类问题。）

Answer 5

还有另一种方法来解决这个问题（除了我之前发布的易失性数据竞赛方法之外），使用 PowerMock 的强大功能。 PowerMock 允许用其他实现替换方法。当它与自动拆箱结合使用时，原始表达式(a == 1 && a == 2 && a == 3)无需修改即可变为真。

@phflack 的答案依赖于修改 Java 中使用 Integer.valueOf(...) 调用的自动装箱过程。以下方法依赖于通过更改 Integer.intValue() 调用来修改自动拆箱。

以下方法的优点是问题中OP给出的原始if语句保持不变，我认为这是最优雅的。

import static org.powermock.api.support.membermodification.MemberMatcher.method;
import static org.powermock.api.support.membermodification.MemberModifier.replace;

import java.util.concurrent.atomic.AtomicInteger;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@PrepareForTest(Integer.class)
@RunWith(PowerMockRunner.class)
public class Ais123 {
    @Before
    public void before() {
        // "value" is just a place to store an incrementing integer
        AtomicInteger value = new AtomicInteger(1);
        replace(method(Integer.class, "intValue"))
            .with((proxy, method, args) -> value.getAndIncrement());
    }

    @Test
    public void test() {
        Integer a = 1;

        if (a == 1 && a == 2 && a == 3) {
            System.out.println("Success");
        } else {
            Assert.fail("(a == 1 && a == 2 && a == 3) != true, a = " + a.intValue());
        }
    }

}

Answer 6

由于这似乎是 this JavaScript question 的后续，值得注意的是 this trick 和 Java 中的类似作品：

public class Q48383521 {
    public static void main(String[] args) {
        int aﾠ = 1;
        int ﾠ2 = 3;
        int a = 3;
        if(aﾠ==1 && a==ﾠ2 && a==3) {
            System.out.println("success");
        }
    }
}

On Ideone

---

但请注意，这并不是使用 Unicode 所能做的最糟糕的事情。使用作为有效标识符部分的空格或控制字符或using different letters that look the same 仍然会创建不同且可以被发现的标识符，例如进行文本搜索时。

但是这个程序

public class Q48383521 {
    public static void main(String[] args) {
        int ä = 1;
        int ä = 2;
        if(ä == 1 && ä == 2) {
            System.out.println("success");
        }
    }
}

使用两个相同的标识符，至少从 Unicode 的角度来看是这样。他们只是使用不同的方式来编码相同的字符ä，使用U+00E4 和U+0061 U+0308。

On Ideone

因此，根据您使用的工具，它们可能不仅看起来相同，支持 Unicode 的文本工具甚至可能不会报告任何差异，在搜索时总是会找到两者。您甚至可能会遇到这样的问题，即在将源代码复制给其他人时会丢失不同的表示形式，可能是试图为“奇怪的行为”寻求帮助，从而使帮助者无法重现。

Answer 7

受到@Erwin 优秀的answer 的启发，我写了一个类似的例子，但是使用了Java Stream API。

有趣的是，我的解决方案有效，但在极少数情况下（因为just-in-time 编译器优化了这样的代码）。

诀窍是使用以下VM 选项禁用任何JIT 优化：

-Djava.compiler=NONE

在这种情况下，成功案例的数量显着增加。代码如下：

class Race {
    private static int a;

    public static void main(String[] args) {
        IntStream.range(0, 100_000).parallel().forEach(i -> {
            a = 1;
            a = 2;
            a = 3;
            testValue();
        });
    }

    private static void testValue() {
        if (a == 1 && a == 2 && a == 3) {
            System.out.println("Success");
        }
    }
}

附：并行流在底层使用ForkJoinPool，变量a在多个线程之间共享，没有任何同步，这就是结果不确定的原因。

Answer 8

沿着similar lines，通过除以（或乘法）一个大数来强制浮点（或双精度）下溢（或上溢）：

int a = 1;
if (a / Float.POSITIVE_INFINITY == 1 / Float.POSITIVE_INFINITY
        && a / Float.POSITIVE_INFINITY == 2 / Float.POSITIVE_INFINITY
        && a / Float.POSITIVE_INFINITY == 3 / Float.POSITIVE_INFINITY) {
    System.out.println("Success");
}