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

[scm-commit at wald.intevation.org]

Author: alfonx
Date: 2012-05-26 21:28:30 +0200 (Sat, 26 May 2012)
New Revision: 2010

Modified:
   trunk/schmitzm-core/src/main/java/de/schmitzm/regex/RegexCache.java
Log:


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-26 19:00:46 UTC (rev 2009)
+++ trunk/schmitzm-core/src/main/java/de/schmitzm/regex/RegexCache.java	2012-05-26 19:28:30 UTC (rev 2010)
@@ -3,6 +3,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.regex.MatchResult;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -89,35 +90,9 @@
 
 //	final static Map<String, ThreadLocal<Matcher>> matchersCachedThreadLocalPerRegex = Collections
 //			.synchronizedMap(new LimitedHashMap<String, ThreadLocal<Matcher>>(10000, TRUNC_METHOD.OLDEST_GET));
-//
-//	/**
-//	 * Diese Methode ist gedacht um die Erstellung von Matcher-Objekten in der JVM zu reduzieren. Es für bis zu 10000
-//	 * RegEx ein Cache verwaltet. Jeder dieser Caches ist ein ThreadLocal-Cache von Matchern. Somit liefert diese Methde
-//	 * für die selbe RegEx auf N Threads N unterschiedliche Matcher.<br/>
-//	 * Die Matcher werden für die Regex gecached. Wird ein Matcher für eine gecachte Regex mit einem anderen TEXT
-//	 * angeforderd, wird zuerst {@link Matcher#reset(CharSequence)} ausgeführt.
-//	 */
-//	public Matcher getMatcher(final String regex, final String text) {
-//		ThreadLocal<Matcher> threadLocal = matchersCachedThreadLocalPerRegex.get(regex);
-//
-//		synchronized (regex) {
-//
-//			if (threadLocal == null) {
-//
-//				threadLocal = new ThreadLocal<Matcher>() {
-//
-//					@Override
-//					protected Matcher initialValue() {
-//						return getPattern(regex).matcher(text);
-//					}
-//				};
-//				matchersCachedThreadLocalPerRegex.put(regex, threadLocal);
-//			}
-//
-//		}
-//
-//		return threadLocal.get().reset(text);
-//	}
+
+	final static Map<String, ThreadLocal<Matcher>> matchersCachedThreadLocalPerRegex = new ConcurrentHashMap<String, ThreadLocal<Matcher>>(10000);
+
 	
 	/**
 	 * Diese Methode ist gedacht um die Erstellung von Matcher-Objekten in der JVM zu reduzieren. Es für bis zu 10000
@@ -127,6 +102,36 @@
 	 * angeforderd, wird zuerst {@link Matcher#reset(CharSequence)} ausgeführt.
 	 */
 	public Matcher getMatcher(final String regex, final String text) {
+		ThreadLocal<Matcher> threadLocal = matchersCachedThreadLocalPerRegex.get(regex);
+
+		synchronized (regex) {
+
+			if (threadLocal == null) {
+
+				threadLocal = new ThreadLocal<Matcher>() {
+
+					@Override
+					protected Matcher initialValue() {
+						return getPattern(regex).matcher(text);
+					}
+				};
+				matchersCachedThreadLocalPerRegex.put(regex, threadLocal);
+			}
+
+		}
+
+		return threadLocal.get().reset(text);
+	}
+	
+	
+	/**
+	 * Diese Methode ist gedacht um die Erstellung von Matcher-Objekten in der JVM zu reduzieren. Es für bis zu 10000
+	 * RegEx ein Cache verwaltet. Jeder dieser Caches ist ein ThreadLocal-Cache von Matchern. Somit liefert diese Methde
+	 * für die selbe RegEx auf N Threads N unterschiedliche Matcher.<br/>
+	 * Die Matcher werden für die Regex gecached. Wird ein Matcher für eine gecachte Regex mit einem anderen TEXT
+	 * angeforderd, wird zuerst {@link Matcher#reset(CharSequence)} ausgeführt.
+	 */
+//	public Matcher getMatcher(final String regex, final String text) {
 //		ThreadLocal<Matcher> threadLocal = matchersCachedThreadLocalPerRegex.get(regex);
 //
 //		synchronized (regex) {
@@ -147,8 +152,8 @@
 //
 //		return threadLocal.get().reset(text);
 		
-		return getPattern(regex).matcher(text);
-	}
+//		return getPattern(regex).matcher(text);
+//	}
 
 
 	/**