The performance impact of using instanceof in Java

by

Approach

I wrote a benchmark program to evaluate different implementations:

  1. instanceof implementation (as reference)
  2. object-orientated via an abstract class and @Override a test method
  3. using an own type implementation
  4. getClass() == _.class implementation

I used jmh to run the benchmark with 100 warmup calls, 1000 iterations under measuring, and with 10 forks. So each option was measured with 10 000 times, which takes 12:18:57 to run the whole benchmark on my MacBook Pro with macOS 10.12.4 and Java 1.8. The benchmark measures the average time of each option. For more details see my implementation on GitHub.

For the sake of completeness: There is a previous version of this answer and my benchmark.

Results

| Operation  | Runtime in nanoseconds per operation | Relative to instanceof |
|------------|--------------------------------------|------------------------|
| INSTANCEOF | 39,598 ± 0,022 ns/op                 | 100,00 %               |
| GETCLASS   | 39,687 ± 0,021 ns/op                 | 100,22 %               |
| TYPE       | 46,295 ± 0,026 ns/op                 | 116,91 %               |
| OO         | 48,078 ± 0,026 ns/op                 | 121,42 %               |

tl;dr

In Java 1.8 instanceof is the fastest approach, although getClass() is very close.

More Related Contents:

  1. Performance of java if-else with return statement [duplicate]
  2. Does Java JIT compiler sacrifice performance to favor Collections?
  3. Array or List in Java. Which is faster?
  4. Swing animation running extremely slow
  5. What is microbenchmarking?
  6. Java 8: performance of Streams vs Collections
  7. C++ equivalent of java’s instanceof
  8. In java, is it more efficient to use byte or short instead of int and float instead of double?
  9. Is instanceof considered bad practice? If so, under what circumstances is instanceof still preferable?
  10. Technique or utility to minimize Java “warm-up” time?
  11. Counting the number of files in a directory using Java
  12. Performance difference between Java 8 lambdas and anonymous inner classes
  13. How can I avoid garbage collection delays in Java games? (Best Practices) [closed]
  14. Which part of throwing an Exception is expensive?
  15. Java benchmarking – why is the second loop faster?
  16. Why does Java switch on contiguous ints appear to run faster with added cases?
  17. Are volatile variable ‘reads’ as fast as normal reads?
  18. Java Streams: How to do an efficient “distinct and sort”?
  19. Support for Compressed Strings being Dropped in HotSpot JVM?
  20. Java toString() using reflection?
  21. Fastest way to strip all non-printable characters from a Java String
  22. Is there a memory-efficient replacement of java.lang.String?
  23. In JNI, how do I cache the class, methodID, and fieldIDs per IBM’s performance recommendations?
  24. Integer.parseInt(scanner.nextLine()) vs scanner.nextInt()
  25. HQL joined query to eager fetch a large number of relationships
  26. Theoretical limit for number of keys (objects) that can be stored in a HashMap?
  27. Recycler view – resizing item view while scrolling (for carousel like effect)
  28. Benchmarking inside Java code
  29. Measuring time spent on GC
  30. Try Catch Performance Java

Leave a Comment