This is more like a mini-blog post... While experimenting with some new Java 8 features, I stumbled on some amazing things.
The first: Java 8 can call via an indirection through a variable, an aribtrary method, essentially just as fast as if you coded a direct call. So, for instance, if you have a method "m", and called it like this: myinstance.m(some_args) you can also do something like: MyFunctionalInterface fi = ... // code that returns a CallSite cast to a functional interface, which has the method "m" inside it and then call it fi.apply(some_args) and it runs essentially just as fast as the direct call. My first test of this was with my attempt at doing a mini-java-benchmark, trying to be careful to avoid the JIT optimizing away everything... With this, I measured this result - this new approach is much faster than old-fashioned reflection. Then, I climbed the learning curve on Java Microbenchmarking Harness (jmh). There's a great presentation on this here: https://vimeo.com/78900556 Using this I more accurately could determine the performance, and confirmed it runs a bit slower than direct, but almost as fast. To make the functional interface that's fast, I'm using the LambaMetafactory.metafactory approach. other approaches, such as using MethodHandleProxies.asInterfaceInstance seem (with current Java 8) to not perform well. This discovery can enable designs which can include more reflection style invocations, I think. -Marshall
