JIT优化器是否优化乘法？

Question

在我的计算机体系结构课程中，我刚刚学到，通过乘法电路运行一个涉及乘法的代数表达式可能比通过加法电路运行它的代价更高，如果所需乘法数小于3.ex: 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;
        }

    }