java - JIT 优化器是否优化乘法？

Question

在我的计算机体系结构类(class)中，我刚刚了解到，如果所需的乘法次数少于 3，则通过乘法电路运行涉及乘法的代数表达式可能比通过加法电路运行它的成本更高。例如:3x。如果我执行这种类型的计算数十亿次，将其写为:x + x + x 是否值得，或者 JIT 优化器是否对此进行优化？

Answer 1

我不希望以一种或另一种方式编写它会产生巨大的差异。

编译器可能会负责使所有这些等效。

您可以尝试每种方法并测量需要多长时间，这可以为您回答自己的问题提供一个很好的提示。

下面的一些代码使用不同的方法(x + x + x、3*x 以及位移后进行减法)执行相同的计算 1000 万次。

它们似乎都花费了与 System.nanoTime 测量的大致相同的时间。

一次运行的示例输出:

sum   : 594599531
mult  : 568783654
shift : 564081012

您还可以看一下这个问题，它讨论了编译器的优化如何处理这些以及更复杂的情况:Is shifting bits faster than multiplying and dividing in Java? .NET?

代码:

    import java.util.Random;

    public class TestOptimization {

        public static void main(String args[]) {
            Random rn = new Random();
            long l1 = 0, l2 = 0, l3 = 0;
            long nano1 = System.nanoTime();
            for (int i = 1; i < 10000000; i++) {
                int num = rn.nextInt(100);
                l1 += sum(num);
            }
            long nano2 = System.nanoTime();
            for (int i = 1; i < 10000000; i++) {
                int num = rn.nextInt(100);
                l2 += mult(num);
            }
            long nano3 = System.nanoTime();
            for (int i = 1; i < 10000000; i++) {
                int num = rn.nextInt(100);
                l3 += shift(num);
            }
            long nano4 = System.nanoTime();
            System.out.println(l1);
            System.out.println(l2);
            System.out.println(l3);
            System.out.println("sum   : " + (nano2 - nano1));
            System.out.println("mult  : " + (nano3 - nano2));
            System.out.println("shift : " + (nano4 - nano3));
        }

        private static long sum(long x) {
            return x + x + x;
        }

        private static long mult(long x) {
            return 3 * x;
        }

        private static long shift(long x) {
            return (x << 2) - x;
        }

    }