Long.numberOfTrailingZeros()的Java实现

Question

文档链接：http://download.oracle.com/javase/6/docs/api/java/lang/Long.html#numberOfTrailingZeros%28long%29

这里是Java实现源码：

/**
 * Returns the number of zero bits following the lowest-order ("rightmost")
 * one-bit in the two's complement binary representation of the specified
 * <tt>long</tt> value.  Returns 64 if the specified value has no
 * one-bits in its two's complement representation, in other words if it is
 * equal to zero.
 *
 * @return the number of zero bits following the lowest-order ("rightmost")
 *     one-bit in the two's complement binary representation of the
 *     specified <tt>long</tt> value, or 64 if the value is equal
 *     to zero.
 * @since 1.5
 */
public static int numberOfTrailingZeros(long i) {
    // HD, Figure 5-14
int x, y;
if (i == 0) return 64;
int n = 63;
y = (int)i; if (y != 0) { n = n -32; x = y; } else x = (int)(i>>>32);
y = x <<16; if (y != 0) { n = n -16; x = y; }
y = x << 8; if (y != 0) { n = n - 8; x = y; }
y = x << 4; if (y != 0) { n = n - 4; x = y; }
y = x << 2; if (y != 0) { n = n - 2; x = y; }
return n - ((x << 1) >>> 31);
}

该算法将 long 分成两个 int 并处理每个 int。我的问题是为什么不使用 y = x << 32 instead of breaking the long apart?

这是我的版本：

public static int bit(long i)
{
    if (i == 0) return 64;
    long x = i;
    long y;
    int n = 63;
    y = x << 32; if (y != 0) { n -= 32; x = y; }
    y = x << 16; if (y != 0) { n -= 16; x = y; }
    y = x <<  8; if (y != 0) { n -=  8; x = y; }
    y = x <<  4; if (y != 0) { n -=  4; x = y; }
    y = x <<  2; if (y != 0) { n -=  2; x = y; }
    return (int) (n - ((x << 1) >>> 63));
}

我测试了两种方法并取平均值。实现时间：595，我的版本时间：593。也许原来的实现在32位系统上更快，因为我使用的是Windows 7 64位。至少 Java 应该在他们的 x64 sdk 中使用像我的版本这样的东西。有什么想法吗？

Answer 1

几乎每个应用程序中 0.5% 的性能差异都可以忽略不计。如果您正在开发一个需要查看此单一方法性能的应用程序，您可以自己实现它。

Answer 2

在 Java 的最新版本中，例如 Java 8，此类函数是内在函数。

http://hg.openjdk.java.net/jdk8/jdk8/hotspot/file/87ee5ee27509/src/share/vm/classfile/vmSymbols.hpp#l681

Answer 3

很晚了，但还是会回复。我认为如果这个函数在代码中实际使用的话，JVM 实际上会更多地剥离这个函数，所以改变它的一小部分并不重要。