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;
        }

    }

JIT 优化器是否优化乘法？

Does the JIT Optimizer Optimize Multiplication?

java

optimization

jit

compilation