The performance impact of using instanceof in Java

Question

I am working on an application and one design approach involves extremely heavy use of the instanceof operator  While I know that OO design generally tries to avoid using instanceof  that is a different story and this question is purely related to performance  I was wondering if there is any performance impact  Is is just as fast as      For example  I have a base class with 10 subclasses  In a single function that takes the base class  I do checks for if the class is an instance of the subclass and carry out some routine    One of the other ways I thought of solving it was to use a  type id  integer primitive instead  and use a bitmask to represent categories of the subclasses  and then just do a bit mask comparison of the subclasses  type id  to a constant mask representing the category   Is instanceof somehow optimized by the JVM to be faster than that  I want to stick to Java but the performance of the app is critical  It would be cool if someone that has been down this road before could offer some advice  Am I nitpicking too much or focusing on the wrong thing to optimize

User · Accepted Answer

Modern JVM JIT compilers have removed the performance hit of most of the traditionally  quot slow quot  operations  including instanceof  exception handling  reflection  etc  As Donald Knuth wrote   quot We should forget about small efficiencies  say about 97  of the time  premature optimization is the root of all evil  quot   The performance of instanceof probably won t be an issue  so don t waste your time coming up with exotic workarounds until you re sure that s the problem

User · Answer

Generally the reason why the  instanceof  operator is frowned upon in a case like that  where the instanceof is checking for subclasses of this base class  is because what you should be doing is moving the operations into a method and overridding it for the appropriate subclasses   For instance  if you have   if  o instanceof Class1     doThis    else if  o instanceof Class2     doThat            You can replace that with  o doEverything      and then have the implementation of  doEverything    in Class1 call  doThis     and in Class2 call  doThat     and so on

User · Answer

instanceof is very efficient  so your performance is unlikely to suffer  However  using lots of instanceof suggests a design issue   If you can use xClass    String class  this is faster   Note  you don t need instanceof for final classes

User · Answer

I just made a simple test to see how instanceOf performance is comparing to a simple s equals   call to a string object with only one letter   in a 10 000 000 loop the instanceOf gave me 63-96ms  and the string equals gave me 106-230ms  I used java jvm 6   So in my simple test is faster to do a instanceOf instead of a one character string comparison   using Integer s  equals   instead of string s gave me the same result  only when I used the    i was faster than instanceOf by 20ms  in a 10 000 000 loop

User · Answer

Instanceof is very fast  It boils down to a bytecode that is used for class reference comparison  Try a few million instanceofs in a loop and see for yourself

User · Answer

If speed is your sole aim then using int constants to identify sub classes seems to shave a milliseconds of the time  static final int ID A   0  static final int ID B   1  abstract class Base     final int id    Base int i    id   i      class A extends Base    A     super ID A       class B extends Base    B     super ID B           Base obj       switch obj id    case  ID A       break  case  ID B       break      terrible OO design  but if your performance analysis indicates this is where you bottleneck is then maybe  In my code the dispatch code takes 10  of total execution time and this maybe contributed to a 1  total speed improvement

User · Answer

instanceof is very efficient  so your performance is unlikely to suffer  However  using lots of instanceof suggests a design issue   If you can use xClass    String class  this is faster   Note  you don t need instanceof for final classes

User · Answer

You should measure profile if it s really a performance issue in your project  If it is I d recommend a redesign - if possible  I m pretty sure you can t beat the platform s native implementation  written in C   You should also consider the multiple inheritance in this case   You should tell more about the problem  maybe you could use an associative store  e g  a Map lt Class  Object  if you are only interested in the concrete types

User · Answer

instanceof is probably going to be more costly than a simple equals in most real world implementations  that is  the ones where instanceof is really needed  and you can t just solve it by overriding a common method  like every beginner textbook as well as Demian above suggest    Why is that  Because what is probably going to happen is that you have several interfaces  that provide some functionality  let s say  interfaces x  y and z   and some objects to manipulate that may  or not  implement one of those interfaces    but not directly  Say  for instance  I have   w extends x  A implements w  B extends A  C extends B  implements y  D extends C  implements z  Suppose I am processing an instance of D  the object d  Computing  d instanceof x  requires to take d getClass    loop through the interfaces it implements to know whether one is    to x  and if not do so again recursively for all of their ancestors    In our case  if you do a breadth first exploration of that tree  yields at least 8 comparisons  supposing y and z don t extend anything     The complexity of a real-world derivation tree is likely to be higher  In some cases  the JIT can optimize most of it away  if it is able to resolve in advance d as being  in all possible cases  an instance of something that extends x  Realistically  however  you are going to go through that tree traversal most of the time   If that becomes an issue  I would suggest using a handler map instead  linking the concrete class of the object to a closure that does the handling  It removes the tree traversal phase in favor of a direct mapping  However  beware that if you have set a handler for C class  my object d above will not be recognized   here are my 2 cents  I hope they help

User · Answer

instanceof  is actually an operator  like   or -  and I believe that it has its own JVM bytecode instruction   It should be plenty fast   I should not that if you have a switch where you are testing if an object is an instance of some subsclass  then your design might need to be reworked   Consider pushing the subclass-specific behavior down into the subclasses themselves

User · Answer

I thought it might be worth submitting a counter-example to the general consensus on this page that  instanceof  is not expensive enough to worry about  I found I had some code in an inner loop that  in some historic attempt at optimization  did  if    seq instanceof SingleItem       seq   seq head        where calling head   on a SingleItem returns the value unchanged  Replacing the code by  seq   seq head      gives me a speed-up from 269ms to 169ms  despite the fact that there are some quite heavy things happening in the loop  like string-to-double conversion  It s possible of course that the speed-up is more due to eliminating the conditional branch than to eliminating the instanceof operator itself  but I thought it worth mentioning

User · Answer

I ll get back to you on instanceof performance  But a way to avoid problem  or lack thereof  altogether would be to create a parent interface to all the subclasses on which you need to do instanceof  The interface will be a super set of all the methods in sub-classes for which you need to do instanceof check  Where a method does not apply to a specific sub-class  simply provide a dummy implementation of this method  If I didn t misunderstand the issue  this is how I ve gotten around the problem in the past

User · Answer

Demian and Paul mention a good point  however  the placement of the code to execute really depends on how you want to use the data     I m a big fan of small data objects that can be used in many ways  If you follow the override  polymorphic  approach  your objects can only be used  one way    This is where patterns come in     You can use double-dispatch  as in the visitor pattern  to ask each object to  call you  passing itself -- this will resolve the type of the object  However  again  you ll need a class that can  do stuff  with all of the possible subtypes   I prefer to use a strategy pattern  where you can register strategies for each subtype you want to handle  Something like the following  Note that this only helps for exact type matches  but has the advantage that it s extensible - third-party contributors can add their own types and handlers   This is good for dynamic frameworks like OSGi  where new bundles can be added   Hopefully this will inspire some other ideas     package com javadude sample   import java util HashMap  import java util Map   public class StrategyExample       static class SomeCommonSuperType        static class SubType1 extends SomeCommonSuperType        static class SubType2 extends SomeCommonSuperType        static class SubType3 extends SomeCommonSuperType         static interface Handler lt T extends SomeCommonSuperType gt            Object handle T object              static class HandlerMap           private Map lt Class lt   extends SomeCommonSuperType gt   Handler lt   extends SomeCommonSuperType gt  gt  handlers                new HashMap lt Class lt   extends SomeCommonSuperType gt   Handler lt   extends SomeCommonSuperType gt  gt             public  lt T extends SomeCommonSuperType gt  void add Class lt T gt  c  Handler lt T gt  handler                handlers  put c  handler                      SuppressWarnings  unchecked           public  lt T extends SomeCommonSuperType gt  Object handle T o                return   Handler lt T gt   handlers  get o getClass     handle o                        public static void main String   args            HandlerMap handlerMap   new HandlerMap             handlerMap add SubType1 class  new Handler lt SubType1 gt                   Override public Object handle SubType1 object                    System out println  Handling SubType1                    return null                            handlerMap add SubType2 class  new Handler lt SubType2 gt                   Override public Object handle SubType2 object                    System out println  Handling SubType2                    return null                            handlerMap add SubType3 class  new Handler lt SubType3 gt                   Override public Object handle SubType3 object                    System out println  Handling SubType3                    return null                             SubType1 subType1   new SubType1            handlerMap handle subType1           SubType2 subType2   new SubType2            handlerMap handle subType2           SubType3 subType3   new SubType3            handlerMap handle subType3

User · Answer

InstanceOf is a warning of poor Object Oriented design   Current JVMs do mean the instanceOf is not much of a performance worry in itself  If you are finding yourself using it a lot  especially for core functionality  it is probably time to look at the design  The performance  and simplicity maintainability  gains of refactoring to a better design will greatly outweigh any actual processor cycles spent on the actual instanceOf call   To give a very small simplistic programming example   if  SomeObject instanceOf Integer       do something    if  SomeObject instanceOf Double       do something different      Is a poor architecture a better choice would have been to have SomeObject be the parent class of two child classes where each child class overrides a method  doSomething  so the code would look as such   Someobject doSomething

User · Answer

You re focusing on the wrong thing   The difference between instanceof and any other method for checking the same thing would probably not even be measurable   If performance is critical then Java is probably the wrong language   The major reason being that you can t control when the VM decides it wants to go collect garbage  which can take the CPU to 100  for several seconds in a large program  MagicDraw 10 was great for that    Unless you are in control of every computer this program will run on you can t guarantee which version of JVM it will be on  and many of the older ones had major speed issues   If it s a small app you may be ok with Java  but if you are constantly reading and discarding data then you will notice when the GC kicks in

User · Answer

Answering your very last question  Unless a profiler tells you  that you spend ridiculous amounts of time in an instanceof  Yes  you re nitpicking   Before wondering about optimizing something that never needed to be optimized  Write your algorithm in the most readable way and run it  Run it  until the jit-compiler gets a chance to optimize it itself  If you then have problems with this piece of code  use a profiler to tell you  where to gain the most and optimize this   In times of highly optimizing compilers  your guesses about bottlenecks will be likely to be completely wrong   And in true spirit of this answer  which I wholeheartly believe   I absolutely don t know how instanceof and    relate once the jit-compiler got a chance to optimize it   I forgot  Never measure the first run

User · Answer

I also prefer an enum approach  but I would use a abstract base class to force the subclasses to implement the getType   method   public abstract class Base     protected enum TYPE         DERIVED A  DERIVED B        public abstract TYPE getType       class DerivedA extends Base          Override     public TYPE getType               return TYPE DERIVED A               class DerivedB extends Base          Override     public TYPE getType               return TYPE DERIVED B

User · Answer

I write a performance test based on jmh-java-benchmark-archetype 2 21  JDK is openjdk and version is 1 8 0 212  The test machine is mac pro  Test result is   Benchmark                Mode  Cnt    Score   Error   Units MyBenchmark getClasses  thrpt   30  510 818    4 190  ops us MyBenchmark instanceOf  thrpt   30  503 826    5 546  ops us   The result shows that  getClass is better than instanceOf  which is contrary with other test  However  I don t know why   The test code is below   public class MyBenchmark    public static final Object a   new LinkedHashMap lt String  String gt       Benchmark  BenchmarkMode Mode Throughput   OutputTimeUnit TimeUnit MICROSECONDS  public boolean instanceOf         return a instanceof Map      Benchmark  BenchmarkMode Mode Throughput   OutputTimeUnit TimeUnit MICROSECONDS  public boolean getClasses         return a getClass      HashMap class     public static void main String   args  throws RunnerException       Options opt           new OptionsBuilder   include MyBenchmark class getSimpleName    warmupIterations 20  measurementIterations 30  forks 1  build        new Runner opt  run

User · Answer

instanceof is really fast  taking only a few CPU instructions   Apparently  if a class X has no subclasses loaded  JVM knows   instanceof can be optimized as        x instanceof X        gt   x getClass    X class      gt   x classID    constant X ID   The main cost is just a read   If X does have subclasses loaded  a few more reads are needed  they are likely co-located so the extra cost is very low too   Good news everyone

User · Answer

instanceof is probably going to be more costly than a simple equals in most real world implementations  that is  the ones where instanceof is really needed  and you can t just solve it by overriding a common method  like every beginner textbook as well as Demian above suggest    Why is that  Because what is probably going to happen is that you have several interfaces  that provide some functionality  let s say  interfaces x  y and z   and some objects to manipulate that may  or not  implement one of those interfaces    but not directly  Say  for instance  I have   w extends x  A implements w  B extends A  C extends B  implements y  D extends C  implements z  Suppose I am processing an instance of D  the object d  Computing  d instanceof x  requires to take d getClass    loop through the interfaces it implements to know whether one is    to x  and if not do so again recursively for all of their ancestors    In our case  if you do a breadth first exploration of that tree  yields at least 8 comparisons  supposing y and z don t extend anything     The complexity of a real-world derivation tree is likely to be higher  In some cases  the JIT can optimize most of it away  if it is able to resolve in advance d as being  in all possible cases  an instance of something that extends x  Realistically  however  you are going to go through that tree traversal most of the time   If that becomes an issue  I would suggest using a handler map instead  linking the concrete class of the object to a closure that does the handling  It removes the tree traversal phase in favor of a direct mapping  However  beware that if you have set a handler for C class  my object d above will not be recognized   here are my 2 cents  I hope they help

User · Answer

I just made a simple test to see how instanceOf performance is comparing to a simple s equals   call to a string object with only one letter   in a 10 000 000 loop the instanceOf gave me 63-96ms  and the string equals gave me 106-230ms  I used java jvm 6   So in my simple test is faster to do a instanceOf instead of a one character string comparison   using Integer s  equals   instead of string s gave me the same result  only when I used the    i was faster than instanceOf by 20ms  in a 10 000 000 loop

User · Answer

With regard to Peter Lawrey s note that you don t need instanceof for final classes and can just use a reference equality  be careful   Even though the final classes cannot be extended  they are not guaranteed to be loaded by the same classloader   Only use x getClass      SomeFinal class or its ilk if you are absolutely positive that there is only one classloader in play for that section of code

User · Answer

The items which will determine the performance impact are    The number of possible classes for which the instanceof operator could return true The distribution of your data - are most of the instanceof operations resolved in the first or second attempt   You ll want to put your most likely to return true operations first  The deployment environment   Running on a Sun Solaris VM is significantly different than Sun s Windows JVM  Solaris will run in  server  mode by default  while Windows will run in client mode   The JIT optimizations on Solaris  will make all method access able the same      I created a microbenchmark for four different methods of dispatch   The results from Solaris are as follows  with the smaller number being faster   InstanceOf 3156 class   2925  OO 3083  Id 3067

User · Answer

I have got same question  but because i did not find  performance metrics  for use case similar to mine  i ve done some more sample code  On my hardware and Java 6  amp  7  the difference between instanceof and switch on 10mln iterations is  for 10 child classes - instanceof  1200ms vs switch  470ms for 5 child classes  - instanceof   375ms vs switch  204ms   So  instanceof is really slower  especially on huge number of if-else-if statements  however difference will be negligible within real application   import java util Date   public class InstanceOfVsEnum        public static int c1  c2  c3  c4  c5  c6  c7  c8  c9  cA       public static class Handler           public enum Type   Type1  Type2  Type3  Type4  Type5  Type6  Type7  Type8  Type9  TypeA           protected Handler Type type    this type   type            public final Type type           public static void addHandlerInstanceOf Handler h                if  h instanceof H1    c1                  else if  h instanceof H2    c2                  else if  h instanceof H3    c3                  else if  h instanceof H4    c4                  else if  h instanceof H5    c5                  else if  h instanceof H6    c6                  else if  h instanceof H7    c7                  else if  h instanceof H8    c8                  else if  h instanceof H9    c9                  else if  h instanceof HA    cA                         public static void addHandlerSwitch Handler h                switch  h type                     case Type1  c1    break                  case Type2  c2    break                  case Type3  c3    break                  case Type4  c4    break                  case Type5  c5    break                  case Type6  c6    break                  case Type7  c7    break                  case Type8  c8    break                  case Type9  c9    break                  case TypeA  cA    break                                     public static class H1 extends Handler   public H1     super Type Type1           public static class H2 extends Handler   public H2     super Type Type2           public static class H3 extends Handler   public H3     super Type Type3           public static class H4 extends Handler   public H4     super Type Type4           public static class H5 extends Handler   public H5     super Type Type5           public static class H6 extends Handler   public H6     super Type Type6           public static class H7 extends Handler   public H7     super Type Type7           public static class H8 extends Handler   public H8     super Type Type8           public static class H9 extends Handler   public H9     super Type Type9           public static class HA extends Handler   public HA     super Type TypeA            final static int cCycles   10000000       public static void main String   args            H1 h1   new H1            H2 h2   new H2            H3 h3   new H3            H4 h4   new H4            H5 h5   new H5            H6 h6   new H6            H7 h7   new H7            H8 h8   new H8            H9 h9   new H9            HA hA   new HA             Date dtStart   new Date            for  int i   0  i  lt  cCycles  i                   Handler addHandlerInstanceOf h1               Handler addHandlerInstanceOf h2               Handler addHandlerInstanceOf h3               Handler addHandlerInstanceOf h4               Handler addHandlerInstanceOf h5               Handler addHandlerInstanceOf h6               Handler addHandlerInstanceOf h7               Handler addHandlerInstanceOf h8               Handler addHandlerInstanceOf h9               Handler addHandlerInstanceOf hA                     System out println  Instance of -      new Date   getTime   - dtStart getTime               dtStart   new Date            for  int i   0  i  lt  cCycles  i                   Handler addHandlerSwitch h1               Handler addHandlerSwitch h2               Handler addHandlerSwitch h3               Handler addHandlerSwitch h4               Handler addHandlerSwitch h5               Handler addHandlerSwitch h6               Handler addHandlerSwitch h7               Handler addHandlerSwitch h8               Handler addHandlerSwitch h9               Handler addHandlerSwitch hA                     System out println  Switch of -      new Date   getTime   - dtStart getTime

User · Answer

It s hard to say how a certain JVM implements instance of  but in most cases  Objects are comparable to structs and classes are as well and every object struct has a pointer to the the class struct it is an instance of  So actually instanceof for  if  o instanceof java lang String    might be as fast as the following C code  if  objectStruct- gt iAmInstanceOf     amp java lang String class    assuming a JIT compiler is in place and does a decent job   Considering that this is only accessing a pointer  getting a pointer at a certain offset the pointer points to and comparing this to another pointer  which is basically the same as testing to 32 bit numbers being equal   I d say the operation can actually be very fast   It doesn t have to  though  it depends a lot on the JVM  However  if this would turn out to be the bottleneck operation in your code  I d consider the JVM implementation rather poor  Even one that has no JIT compiler and only interprets code should be able to make an instanceof test in virtually no time

User · Answer

In modern Java version the instanceof operator is faster as a simple method call  This means   if a instanceof AnyObject       is faster as   if a getType      XYZ       Another thing is if you need to cascade many instanceof  Then a switch that only call once getType   is faster

User · Answer

Approach  I wrote a benchmark program to evaluate different implementations    instanceof implementation  as reference   object orientated via an abstract class and  Override a test method using an own type implementation 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

[java] The performance impact of using instanceof in Java

Examples related to java

Examples related to performance

Examples related to instanceof