Why is reflection slow?

Question

Is it because we should load class (by string for example), create instance, then search for appropriate method, pack parameters, and then just invoke method? S

Answer 1

As an addendum to Jon Skeet's answer above (I need more reputation in order to be able to comment.):

Reflection is dependent on CPU resources being available; if you have problem with your application being slow, reflection won't solve anything, just make it slower.

Like Java itself, reflection isn't slow any more - it is more of an old rumor ;)

Answer 2

If you use it in an appropriate way, it is not that slow. For example, I used it for scanning all the property from model class, it was working perfectly.

In other cases, such as checking whether the target has the same type or signature, it is absolutely slow.

Event it is sometime slow, but it is important for out of the box implementation...:D.

Answer 3

When you call a method, you need to know if you're doing so with valid arguments, on a valid object, what the return type is, and what bytecode to execute. When the exact method is specified in code, java can quickly figure this stuff out and move on to actually executing the method.

When you do this with reflection, you know a lot less. Since the method to be invoked wasn't specified in the code, none of this can be done beforehand, and the VM has to do things at run time that are far more complex and processor intensive.

Polymorphic method calls can be though of as somewhere between these two extremes. You don't know what method to invoke until run time, but at least you can be sure of the method's name, arguments, and return type. The more you know about what method to execute, the more Java can avoid doing at run time.

This proves that reflection is slower, but not that it is actually "slow." If you need reflection or polymorphic methods, use them, and save the judgement of what is "slow" for later.

Answer 4

According to Oracle documentations

Reflection is slower Because it involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

Answer 5

Every step you take needs to be validated every time you take it when you use reflection. For example, when you invoke a method, it needs to check whether the target is actually an instance of the declarer of the method, whether you've got the right number of arguments, whether each argument is of the right type, etc.

There's absolutely no possibility of inlining or other performance tricks.

If you're finding types or methods by name, that's at best going to involve a simple map lookup - which will be performed every time you execute it, rather than once at JIT time.

Basically there's a lot more to do. However, reflection has become a lot faster than it used to be... if you're finding it much too slow, you may well be overusing it.