Index: src/main/java/org/apache/jackrabbit/server/jcr/JCRWebdavServer.java
===================================================================
--- src/main/java/org/apache/jackrabbit/server/jcr/JCRWebdavServer.java	(revision 1148512)
+++ src/main/java/org/apache/jackrabbit/server/jcr/JCRWebdavServer.java	(working copy)
@@ -38,32 +38,41 @@
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 /**
  * <code>JCRWebdavServer</code>...
  */
 public class JCRWebdavServer implements DavSessionProvider {
 
+	/** Concurrency level used to configure the internal cache ConcurrentHashMaps */
+	public static final int CONCURRENCY_LEVEL_DEFAULT = 50;
+	
     /** the default logger */
     private static Logger log = LoggerFactory.getLogger(JCRWebdavServer.class);
 
     /** the session cache */
-    private final SessionCache cache = new SessionCache();
+    private final SessionCache cache;
 
     /** the jcr repository */
     private final Repository repository;
 
     /** the provider for the credentials */
     private final SessionProvider sessionProvider;
+    
 
+
     /**
      * Creates a new JCRWebdavServer that operates on the given repository.
      *
      * @param repository
+     * @param concurrencyLevel 
      */
-    public JCRWebdavServer(Repository repository, SessionProvider sessionProvider) {
+    public JCRWebdavServer(Repository repository, SessionProvider sessionProvider, int concurrencyLevel) {
         this.repository = repository;
         this.sessionProvider = sessionProvider;
+        cache = new SessionCache(concurrencyLevel);
     }
 
     //---------------------------------------< DavSessionProvider interface >---
@@ -142,10 +151,29 @@
      */
     private class SessionCache {
 
-        private Map<DavSession, Set<Object>> sessionMap = new HashMap<DavSession, Set<Object>>();
-        private Map<Object, DavSession> referenceToSessionMap = new HashMap<Object, DavSession>();
+    	private static final int INITIAL_CAPACITY = 50;
+    	private static final int INITIAL_CAPACITY_REF_TO_SESSION = 3 * INITIAL_CAPACITY;
+    	
+        private ConcurrentMap<DavSession, Set<Object>> sessionMap;
+        private ConcurrentMap<Object, DavSession> referenceToSessionMap;
 
         /**
+         * Specify the level of concurrency for this server.  This value should probably be equal to the number of threads this server
+         * will be servicing.
+         * 
+         * @param cacheConcurrencyLevel
+         */
+        private SessionCache( int cacheConcurrencyLevel ) {
+        	
+        	if ( cacheConcurrencyLevel < 1 ) {
+        		cacheConcurrencyLevel = CONCURRENCY_LEVEL_DEFAULT;
+        	}
+        	
+        	sessionMap = new ConcurrentHashMap<DavSession, Set<Object>>(INITIAL_CAPACITY, .75f, cacheConcurrencyLevel);
+        	referenceToSessionMap = new ConcurrentHashMap<Object, DavSession>(INITIAL_CAPACITY_REF_TO_SESSION, .75f, cacheConcurrencyLevel);
+        }
+        
+        /**
          * Try to retrieve <code>DavSession</code> if a TransactionId or
          * SubscriptionId is present in the request header. If no cached session
          * was found <code>null</code> is returned.
@@ -186,6 +214,9 @@
             if (session == null) {
                 Session repSession = getRepositorySession(request);
                 session = new DavSessionImpl(repSession);
+                
+                // Could there be more than one thread working with the same session?  My understanding is not.  But if it's possible,
+                // then this method should probably be changed to the more concurrency oriented putIfAbsent()
                 sessionMap.put(session, new HashSet<Object>());
                 log.debug("login: User '" + repSession.getUserID() + "' logged in.");
             } else {