JIT 优化器是否优化乘法？

Question

在我的计算机体系结构课程中，我刚刚了解到，如果所需的乘法次数少于 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;
        }

    }