[Schmitzm-commits] r2033 - trunk/schmitzm-core/src/main/java/de/schmitzm/regex

[scm-commit at wald.intevation.org]

Author: alfonx
Date: 2012-05-27 23:01:05 +0200 (Sun, 27 May 2012)
New Revision: 2033

Modified:
   trunk/schmitzm-core/src/main/java/de/schmitzm/regex/RegexCache.java
Log:
Make use if RegExCache replaceAll instead of String.replaceAll for performance reasons

Modified: trunk/schmitzm-core/src/main/java/de/schmitzm/regex/RegexCache.java
===================================================================
--- trunk/schmitzm-core/src/main/java/de/schmitzm/regex/RegexCache.java	2012-05-27 20:14:02 UTC (rev 2032)
+++ trunk/schmitzm-core/src/main/java/de/schmitzm/regex/RegexCache.java	2012-05-27 21:01:05 UTC (rev 2033)
@@ -25,7 +25,7 @@
 	 * Matcher-Cache für Regex+Value verwenden? Durch die methode mather.reset wird pro Thread ein Matcher
 	 * wiederverwendet
 	 */
-	public static boolean matcherCacheEnabled = true;
+	public static boolean matcherCacheEnabled = false;
 
 	/**
 	 * Regex-Auswertungen komplett cachen
@@ -36,30 +36,30 @@
 	 * TODO Ein String der länger ist als die hier angegebene Anzahl Zeichen wir nicht gecached. Die Wahrscheinlichkeit,
 	 * dass der selbe Sting nochmal auftaucht wird als zu gering eingeschätzt.
 	 **/
-	private static final int CACHE_VALUES_TO_RESULT_MAX_VALUE_LENGTH = 500;
+	private static final int CACHE_VALUES_TO_RESULT_MAX_VALUE_LENGTH = 100;
 
 	/**
 	 * TODO Ein String der kürzer als die hier angegebene Anzahl Zeichen wir nicht gecached.
 	 **/
-	private static final int CACHE_VALUES_TO_RESULT_MIN_VALUE_LENGTH = 10;
+	private static final int CACHE_VALUES_TO_RESULT_MIN_VALUE_LENGTH = 1;
 
-	private final ConcurrentLRUCache<String, ThreadLocal<Matcher>> matchersCachedThreadLocalPerRegex = new ConcurrentLRUCache<String, ThreadLocal<Matcher>>(
-			25000, 15000);
+	private final ConcurrentLRUCache<String, ThreadLocal<Matcher>> matchersCache = new ConcurrentLRUCache<String, ThreadLocal<Matcher>>(
+			55000, 45000);
 
 	private static RegexCache singletonInstance;
 
-	private final ConcurrentLRUCache<String, Pattern> patternCache = new ConcurrentLRUCache<String, Pattern>(50000,
-			35000);
+	private final ConcurrentLRUCache<String, Pattern> patternCache = new ConcurrentLRUCache<String, Pattern>(70000,
+			50000);
 
 	public static RegexCache getInstance() {
 		return singletonInstance != null ? singletonInstance : new RegexCache();
 	}
 
 	private final ConcurrentLRUCache<String, MyMatchResult> resultsCache = new ConcurrentLRUCache<String, MyMatchResult>(
-			100000, 80000);
+			200000, 150000);
 
 	private RegexCache() {
-		singletonInstance=this;
+		singletonInstance = this;
 	}
 
 	/**
@@ -75,7 +75,7 @@
 			return getPattern(regex).matcher(text);
 		}
 
-		ThreadLocal<Matcher> threadLocal = matchersCachedThreadLocalPerRegex.get(regex);
+		ThreadLocal<Matcher> threadLocal = matchersCache.get(regex);
 
 		if (threadLocal == null) {
 
@@ -86,7 +86,9 @@
 					return getPattern(regex).matcher("");
 				}
 			};
-			matchersCachedThreadLocalPerRegex.put(regex, threadLocal);
+			matchersCache.put(regex, threadLocal);
+
+			return threadLocal.get();
 		}
 
 		return threadLocal.get().reset(text);
@@ -177,7 +179,7 @@
 	 * Liefert die aktuellen Statistiken des ResultsCache
 	 */
 	public Stats getMatcherCacheStats() {
-		return matchersCachedThreadLocalPerRegex.getStats();
+		return matchersCache.getStats();
 	}
 
 	/**
@@ -224,9 +226,9 @@
 			patternCache.destroy();
 		}
 
-		if (matchersCachedThreadLocalPerRegex != null) {
-			matchersCachedThreadLocalPerRegex.clear();
-			matchersCachedThreadLocalPerRegex.destroy();
+		if (matchersCache != null) {
+			matchersCache.clear();
+			matchersCache.destroy();
 		}
 	}
 
@@ -248,4 +250,30 @@
 
 	}
 
+	/**
+	 * Ist einem {@link String#replaceAll(String, String)} vorzuziehen, da hier das Pattern nicht immer neu erstellt
+	 * werden muss.
+	 * 
+	 * @param text
+	 * @param regex
+	 * @param replacement
+	 */
+	public String replaceAll(String text, String regex, String replacement) {
+		Matcher matcher = getMatcher(regex, text);
+		return matcher.replaceAll(replacement);
+	}
+
+	/**
+	 * Ist einem {@link String#replaceFirst(String, String)} vorzuziehen, da hier das Pattern nicht immer neu erstellt
+	 * werden muss.
+	 * 
+	 * @param text
+	 * @param regex
+	 * @param replacement
+	 */
+	public String replaceFirst(String text, String regex, String replacement) {
+		Matcher matcher = getMatcher(regex, text);
+		return matcher.replaceFirst(replacement);
+	}
+
 }