How is 'instanceof' implemented in the JVM? [closed]

Question

Does it use reflectione, and if so, what's going on behind the scenes?

Answer 1

Jon is right about how the operator maps to byte-code. As far as implementations, most JVMs represent objects in memory as tagged unions of the loaded concrete classes:

a tagged union, also called a variant, variant record, discriminated union, disjoint union, or sum type, is a data structure used to hold a value that could take on several different, but fixed types.

So x instanceof MyClassType can be answered by looking at a sparse boolean matrix that has a bit set when a concrete type is an instance of a class type.

x instanceof InterfaceType is a bit trickier but similar methods can help with that too.

The JVM can keep a large sparse matrix in memory with a row per nominal types (class or interface types) and a column per class type.

For example:

                           [all nominal types]
                     Object String Integer Number Comparable Iterable ...
[only       String   ✓      ✓                     ✓
 concrete   Integer  ✓             ✓       ✓      ✓
 types]     ...

When the JVM has to garbage collect classes, maintaining this matrix becomes trickier, so you usually store a row with the class object.

---

Proxy classes are an interesting corner case but my best guess is that proxy class definition involves generating some byte-code at runtime that then goes through the normal class loading system in most JVMs.

Answer 2

It's part of the JVM instruction set, basically - there's a specific instanceof instruction. So for example, a method like this:

public static void checkString(Object x) {
    if (x instanceof String) {
        System.out.println("Foo");
    }
}

is compiled into:

public static void checkString(java.lang.Object);
  Code:
     0: aload_0
     1: instanceof    #2                  // class java/lang/String
     4: ifeq          15
     7: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
    10: ldc           #4                  // String Foo
    12: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    15: return
}

(That's just the output of javap.)

The JVM specification has details of what the instruction has to do. See section 6.5 for exact details of the instruction. How it's implemented is up to the VM implementation - but one sample implementation could be:

• Check whether the first operand is null (and return false if so)
• Find the execution-time type of the object that the first operand refers to.
• Navigate up the type hierarchy (including implemented interfaces) until you can prove that the actual type either is or is not compatible with the second operand.