Using Method Handles

A few weeks ago I ran some tests pitting method handles against typical reflection to see what was faster. The result was that reflection was faster although since it was a quick test I don't have the result data or what run configuration I used. Now that I'm tasked with looking into porting our core systems to Java 7 I thought I'd take a more critical look.

Below is the source code I used to run the test. It calls a method on a class called Incrementer a million times. I didn't notice any difference when running the methods several times when running the test several times before timing values to "warm up" server mode.

	import java.lang.invoke.MethodHandle;
	import java.lang.invoke.MethodHandles;
	import java.lang.invoke.MethodType;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	public class MethodHandleTest
	{
	private static final String METHOD_NAME = "increment";
	private static final int LOOPS = 1000000;
	static class Incrementer
	{
	long incrementedNumber;
	public void increment(String arg)
	{
	// just do something
	incrementedNumber += 1;
	}
	}
	public static void main(String[] args) throws Throwable
	{
	usingReflection();
	usingMethodHandles();
	}
	private static void usingReflection() throws NoSuchMethodException,
	IllegalAccessException, InvocationTargetException
	{
	Method method = Incrementer.class.getMethod(METHOD_NAME, String.class);
	long startTime = System.currentTimeMillis();
	Incrementer increments = new Incrementer();
	for (int i = 0; i < LOOPS; i++)
	{
	method.invoke(increments, "12345");
	}
	long elapsed = System.currentTimeMillis() - startTime;
	System.out.println("reflection took " + elapsed + "ms, result is " + increments.incrementedNumber);
	}
	private static void usingMethodHandles() throws NoSuchMethodException,
	IllegalAccessException, Throwable
	{
	MethodType methodType;
	MethodHandle methodHandle;
	MethodHandles.Lookup lookup = MethodHandles.lookup();
	methodType = MethodType.methodType(void.class, String.class);
	methodHandle = lookup.findVirtual(Incrementer.class, METHOD_NAME, methodType);
	long startTime = System.currentTimeMillis();
	Incrementer increments = new Incrementer();
	for (int i = 0; i < LOOPS; i++)
	{
	methodHandle.invokeExact(increments, "12345");
	}
	long elapsed = System.currentTimeMillis() - startTime;
	System.out.println("method handles took " + elapsed + "ms, result is " + increments.incrementedNumber);
	}
	}

view raw MethodHandleTest.java hosted with ❤ by GitHub

Note that this code throws an exception when run from eclipse. I had to use the javac/java executables from the command line for this to work. When running the class in mixed mode I got the following results:

java -verbose:gc MethodHandleTest
[GC 4416K->141K(15872K), 0.0011714 secs]
[GC 4557K->141K(15872K), 0.0006216 secs]
[GC 4557K->141K(15872K), 0.0006387 secs]
reflection took 515ms, result is 1000000
method handles took 16ms, result is 1000000

There is plenty of garbage collection happening but not enough to account for the huge time difference. When running in server mode I got the following results:

java -verbose:gc -server MethodHandleTest
reflection took 47ms, result is 1000000
method handles took 15ms, result is 1000000

java -verbose:gc -server MethodHandleTest
reflection took 32ms, result is 1000000
method handles took 31ms, result is 1000000

All runs of the test gave almost identical results to the above where method handles would be twice as fast as reflection or equal with no garbage collection. Interestingly, if I comment out the increment of the long value the same result as with the increment is produced:

java -verbose:gc MethodHandleTest
[GC 4416K->141K(15872K), 0.0011488 secs]
[GC 4557K->141K(15872K), 0.0006595 secs]
[GC 4557K->141K(15872K), 0.0006482 secs]
reflection took 500ms, result is 0
method handles took 31ms, result is 0

This makes me think that incrementing the long is a very small proportion of the time it takes for the reflection example to run and the majority is for calling the method through reflection. In server mode the reflection call is JITted and almost identical results are produced. This is mostly conjecture since it is quite difficult to work out what the Hotspot compiler is doing.

In conclusion, method handles consistently performs as good as, or better than reflection no matter what run configuration you are using. Stability is an issue with the current tools, eclipse will have to support Java 7 before I could use method handles in our systems.