How to match regular expression without creating objects in Java?

Question

I'm working on a reg expression match function. The problem is, this function will be called by the framework inside a nested loop. If temporary objects are created, GC will cause very big performance problem.

Is it possible to deal with regexp things without create temp objects (Pattern,Matcher)? Rewrite regexp classes is my last choice...

Answer 1

Your best bet is to deal with the issues as and when they arise - which they probably won't. Performance problems around GC'ing large numbers of small lived objects was a problem around a decade ago, but now it's incredibly good at it.

If you do need to optimise then this should be in the form of changing the GC options - the size of the young generation for instance, and not trying to optimise in code.

Answer 2

Matcher objects are not threadsafe so you can't re-use them unless you call the reset() method (which in a single thread should work fine) - see Is Java Regex Thread Safe?

Answer 3

To quote an old saying:

Make it work, make it right, make it fast. (in that order)

So before going down any heavy optomization steps, just write the initial straightforward appropriate code (which in this case would involve pre-compiling your patterns if you can). Run some tests and see if the performance is inadequate, and then optimize if the regex portion is a bottleneck.

If the object creation (and cleanup) is a serious bottleneck (as compared to the actual regex parsing itself), then you may need to implement your own solution that uses an object pool (so objects are not created, just reset and reused from the pool). I doubt that this will result in any serious performance gains though, so you should benchmark first just to see how much gain is even possible (if you improve object creation / cleanup performance by 50%, would it be worth it?).

Answer 4

This sounds like premature optimization.

Write the most straightforward code you can, then profile it in a realistic setting, and see whether there are any problems with performance or memory allocation patterns. If there are, address the specific issues you've uncovered.

Modern JVMs are incredibly good at garbage collecting short-lived objects.

Answer 5

You can precompile your regexes which makes sense if you reuse the same regex multiple times.

Instead of

boolean foundMatch = subjectString.matches("a.*b");

(where a temporary compiled Pattern will be created anyway), you can use

Pattern regex = Pattern.compile("a.*b");
// loop here
// do something...
    Matcher regexMatcher = regex.matcher(subjectString);
    boolean foundMatch = regexMatcher.matches()
// loop end

Hard to say if there will be any relevant performance benefit, though.

Answer 6

the way i see it you have 2 viable options:

1. Write your own logic for matching regex by looking at the source code: Pattern and Matcher.
2. explicitly initiate a collection of those objects when you are done with them by running their corresponding finalize() function instead of waiting for the GC to run it.

Pros and Cons

1. A lot of work, needs to be tested and maintained in the future, however you get full control what you are trying to do.

2. It's not recommended to interfere in the workings of the GC, clean solution and simple solution