Guest User

Java - Speed comparison of local and static VarHandles and Unsafe

a guest
May 15th, 2026
77
0
Never
7
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 7.73 KB | Source Code | 0 0
  1. import sun.misc.Unsafe;
  2.  
  3. import java.lang.invoke.MethodHandles;
  4. import java.lang.invoke.VarHandle;
  5. import java.lang.reflect.Field;
  6. import java.nio.ByteOrder;
  7. import java.util.Arrays;
  8. import java.util.Random;
  9.  
  10. @SuppressWarnings("removal")
  11. public class ComparisonStaticAndLocalVarHandleAndUnsafe {
  12.     private static final int ITERATIONS = 2500;
  13.     private static final int LONG_COUNT = 1 << 21;
  14.  
  15.     private static final VarHandle READ_WRITE_LONG = MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.nativeOrder());
  16.  
  17.     private static final Unsafe UNSAFE;
  18.     private static final int ARRAY_BASE_OFFSET = Unsafe.ARRAY_BYTE_BASE_OFFSET;
  19.  
  20.     static {
  21.         try {
  22.             final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
  23.  
  24.             unsafeField.setAccessible(true);
  25.  
  26.             UNSAFE = (Unsafe) unsafeField.get(null);
  27.         } catch (NoSuchFieldException | IllegalAccessException e) {
  28.             throw new RuntimeException(e);
  29.         }
  30.     }
  31.  
  32.     static void main() {
  33.         useStaticVarHandle();
  34.         useLocalVarHandle();
  35.         useStaticUnsafe();
  36.         useLocalUnsafe();
  37.     }
  38.  
  39.     private static void useStaticVarHandle() {
  40.         final Random random = new Random(0);
  41.  
  42.         final long[] longs = new long[LONG_COUNT];
  43.         final byte[] bytes = new byte[LONG_COUNT * Long.BYTES];
  44.  
  45.         // Warmup
  46.         for (int i = 0; i < ITERATIONS; i++) {
  47.             for (int j = 0; j < longs.length; j++) {
  48.                 longs[j] = random.nextLong();
  49.             }
  50.  
  51.             for (int byteCursor = 0, longCursor = 0; longCursor < longs.length; byteCursor += Long.BYTES) {
  52.                 READ_WRITE_LONG.set(bytes, byteCursor, longs[longCursor++]);
  53.             }
  54.         }
  55.  
  56.         // Benchmark
  57.         final long[] nanoTimes = new long[ITERATIONS];
  58.  
  59.         for (int i = 0; i < nanoTimes.length; i++) {
  60.             for (int j = 0; j < longs.length; j++) {
  61.                 longs[j] = random.nextLong();
  62.             }
  63.  
  64.             final long start = System.nanoTime();
  65.  
  66.             for (int byteCursor = 0, longCursor = 0; longCursor < longs.length; byteCursor += Long.BYTES) {
  67.                 READ_WRITE_LONG.set(bytes, byteCursor, longs[longCursor++]);
  68.             }
  69.  
  70.             final long elapsed = System.nanoTime() - start;
  71.             nanoTimes[i] = elapsed;
  72.         }
  73.  
  74.         printStats(nanoTimes);
  75.     }
  76.  
  77.     private static void useLocalVarHandle() {
  78.         final VarHandle readWriteLong = MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.nativeOrder());
  79.  
  80.         final Random random = new Random(0);
  81.  
  82.         final long[] longs = new long[LONG_COUNT];
  83.         final byte[] bytes = new byte[LONG_COUNT * Long.BYTES];
  84.  
  85.         // Warmup
  86.         for (int i = 0; i < ITERATIONS; i++) {
  87.             for (int j = 0; j < longs.length; j++) {
  88.                 longs[j] = random.nextLong();
  89.             }
  90.  
  91.             for (int byteCursor = 0, longCursor = 0; longCursor < longs.length; byteCursor += Long.BYTES) {
  92.                 readWriteLong.set(bytes, byteCursor, longs[longCursor++]);
  93.             }
  94.         }
  95.  
  96.         // Benchmark
  97.         final long[] nanoTimes = new long[ITERATIONS];
  98.  
  99.         for (int i = 0; i < nanoTimes.length; i++) {
  100.             for (int j = 0; j < longs.length; j++) {
  101.                 longs[j] = random.nextLong();
  102.             }
  103.  
  104.             final long start = System.nanoTime();
  105.  
  106.             for (int byteCursor = 0, longCursor = 0; longCursor < longs.length; byteCursor += Long.BYTES) {
  107.                 readWriteLong.set(bytes, byteCursor, longs[longCursor++]);
  108.             }
  109.  
  110.             final long elapsed = System.nanoTime() - start;
  111.             nanoTimes[i] = elapsed;
  112.         }
  113.  
  114.         printStats(nanoTimes);
  115.     }
  116.  
  117.     private static void useStaticUnsafe() {
  118.         final Random random = new Random(0);
  119.  
  120.         final long[] longs = new long[LONG_COUNT];
  121.         final byte[] bytes = new byte[LONG_COUNT * Long.BYTES];
  122.  
  123.         // Warmup
  124.         for (int i = 0; i < ITERATIONS; i++) {
  125.             for (int j = 0; j < longs.length; j++) {
  126.                 longs[j] = random.nextLong();
  127.             }
  128.  
  129.             for (int byteCursor = ARRAY_BASE_OFFSET, longCursor = 0; longCursor < longs.length; byteCursor += Long.BYTES) {
  130.                 UNSAFE.putLong(bytes, byteCursor, longs[longCursor++]);
  131.             }
  132.         }
  133.  
  134.         // Benchmark
  135.         final long[] nanoTimes = new long[ITERATIONS];
  136.  
  137.         for (int i = 0; i < nanoTimes.length; i++) {
  138.             for (int j = 0; j < longs.length; j++) {
  139.                 longs[j] = random.nextLong();
  140.             }
  141.  
  142.             final long start = System.nanoTime();
  143.  
  144.             for (int byteCursor = ARRAY_BASE_OFFSET, longCursor = 0; longCursor < longs.length; byteCursor += Long.BYTES) {
  145.                 UNSAFE.putLong(bytes, byteCursor, longs[longCursor++]);
  146.             }
  147.  
  148.             final long elapsed = System.nanoTime() - start;
  149.             nanoTimes[i] = elapsed;
  150.         }
  151.  
  152.         printStats(nanoTimes);
  153.     }
  154.  
  155.     private static void useLocalUnsafe() {
  156.         final Unsafe unsafe;
  157.  
  158.         try {
  159.             final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
  160.  
  161.             unsafeField.setAccessible(true);
  162.  
  163.             unsafe = (Unsafe) unsafeField.get(null);
  164.         } catch (NoSuchFieldException | IllegalAccessException e) {
  165.             throw new RuntimeException(e);
  166.         }
  167.  
  168.         final Random random = new Random(0);
  169.  
  170.         final long[] longs = new long[LONG_COUNT];
  171.         final byte[] bytes = new byte[LONG_COUNT * Long.BYTES];
  172.  
  173.         // Warmup
  174.         for (int i = 0; i < ITERATIONS; i++) {
  175.             for (int j = 0; j < longs.length; j++) {
  176.                 longs[j] = random.nextLong();
  177.             }
  178.  
  179.             for (int byteCursor = ARRAY_BASE_OFFSET, longCursor = 0; longCursor < longs.length; byteCursor += Long.BYTES) {
  180.                 unsafe.putLong(bytes, byteCursor, longs[longCursor++]);
  181.             }
  182.         }
  183.  
  184.         // Benchmark
  185.         final long[] nanoTimes = new long[ITERATIONS];
  186.  
  187.         for (int i = 0; i < nanoTimes.length; i++) {
  188.             for (int j = 0; j < longs.length; j++) {
  189.                 longs[j] = random.nextLong();
  190.             }
  191.  
  192.             final long start = System.nanoTime();
  193.  
  194.             for (int byteCursor = ARRAY_BASE_OFFSET, longCursor = 0; longCursor < longs.length; byteCursor += Long.BYTES) {
  195.                 unsafe.putLong(bytes, byteCursor, longs[longCursor++]);
  196.             }
  197.  
  198.             final long elapsed = System.nanoTime() - start;
  199.             nanoTimes[i] = elapsed;
  200.         }
  201.  
  202.         printStats(nanoTimes);
  203.     }
  204.  
  205.     private static void printStats(long[] nanoTimes) {
  206.         // Print name of current method
  207.         System.out.println(Thread.currentThread().getStackTrace()[2].getMethodName());
  208.  
  209.         Arrays.sort(nanoTimes);
  210.  
  211.         long sum = 0L;
  212.  
  213.         for (final long time : nanoTimes) {
  214.             sum += time;
  215.         }
  216.  
  217.         double average = ((double) sum) / ((double) nanoTimes.length);
  218.  
  219.         double differenceSquareSum = 0d;
  220.  
  221.         for (final long time : nanoTimes) {
  222.             final double difference = ((double) time) - average;
  223.  
  224.             differenceSquareSum += (difference * difference);
  225.         }
  226.  
  227.         final double variance = differenceSquareSum / ((double) nanoTimes.length);
  228.         final double standardDeviation = Math.sqrt(variance);
  229.  
  230.         System.out.println(
  231.                 "min=" + nanoTimes[0] +
  232.                 ", max=" + nanoTimes[nanoTimes.length - 1] +
  233.                 ", median=" + nanoTimes[nanoTimes.length / 2] +
  234.                 ", average=" + average +
  235.                 ", standardDeviation=" + standardDeviation +
  236.                 "\n"
  237.         );
  238.     }
  239. }
  240.  
Advertisement
Comments
  • User was banned
  • User was banned
  • User was banned
  • User was banned
  • User was banned
  • User was banned
  • User was banned
Add Comment
Please, Sign In to add comment