Question

在我的计算机体系结构类中，我刚刚了解到，如果所需乘法的数量小于3，运行通过乘法电路进行乘法的代数表达式可能比通过加法电路运行它更昂贵。例如：3x。如果我进行这种类型的计算几十亿次，那么将它写成：x + x + x或者JIT优化器是否会为此进行优化会得到回报？

Answer 1

我不希望以某种方式写它是一个巨大的差异。

编译器可能会将所有这些等效。

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

这里有一些代码使用不同的方法进行1000万次相同的计算（x + x + x，3 * x，然后是一个位移，然后是一个减法）。

他们似乎花费的时间与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 Optimizer是否优化了乘法？

1 个答案: