It is recommended to use ConcurrentHashMap instead of synchronous Has…

library/src/main/java/com/nostra13/universalimageloader/cache/disc/impl/LimitedAgeDiskCache.java

@@ -37,8 +37,7 @@ public class LimitedAgeDiskCache extends BaseDiskCache {
 
 	private final long maxFileAge;
 
-	private final Map<File, Long> loadingDates = Collections.synchronizedMap(new HashMap<File, Long>());
-
+	private final ConcurrentHashMap<File, Long> loadingDates = new ConcurrentHashMap<>();
 	/**
 	 * @param cacheDir Directory for file caching
 	 * @param maxAge   Max file age (in seconds). If file age will exceed this value then it'll be removed on next

library/src/main/java/com/nostra13/universalimageloader/cache/memory/BaseMemoryCache.java

@@ -19,6 +19,7 @@
 
 import java.lang.ref.Reference;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Base memory cache. Implements common functionality for memory cache. Provides object references (
@@ -30,7 +31,7 @@
 public abstract class BaseMemoryCache implements MemoryCache {
 
 	/** Stores not strong references to objects */
-	private final Map<String, Reference<Bitmap>> softMap = Collections.synchronizedMap(new HashMap<String, Reference<Bitmap>>());
+	private final ConcurrentHashMap<String, Reference<Bitmap>> softMap = = new ConcurrentHashMap<>();
 
 	@Override
 	public Bitmap get(String key) {

library/src/main/java/com/nostra13/universalimageloader/cache/memory/impl/LargestLimitedMemoryCache.java

@@ -25,6 +25,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Limited {@link Bitmap bitmap} cache. Provides {@link Bitmap bitmaps} storing. Size of all stored bitmaps will not to
@@ -43,7 +44,7 @@ public class LargestLimitedMemoryCache extends LimitedMemoryCache {
 	 * size will exceed limit then object with the largest size is deleted (but it continue exist at
 	 * {@link #softMap} and can be collected by GC at any time)
 	 */
-	private final Map<Bitmap, Integer> valueSizes = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());
+	private final ConcurrentHashMap<Bitmap, Integer> valueSizes = new ConcurrentHashMap<>();
 
 	public LargestLimitedMemoryCache(int sizeLimit) {
 		super(sizeLimit);

library/src/main/java/com/nostra13/universalimageloader/cache/memory/impl/LimitedAgeMemoryCache.java

@@ -23,6 +23,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Decorator for {@link MemoryCache}. Provides special feature for cache: if some cached object age exceeds defined
@@ -37,7 +38,7 @@ public class LimitedAgeMemoryCache implements MemoryCache {
 	private final MemoryCache cache;
 
 	private final long maxAge;
-	private final Map<String, Long> loadingDates = Collections.synchronizedMap(new HashMap<String, Long>());
+	private final ConcurrentHashMap<String, Long> loadingDates = new ConcurrentHashMap<>();
 
 	/**
 	 * @param cache  Wrapped memory cache

library/src/main/java/com/nostra13/universalimageloader/cache/memory/impl/UsingFreqLimitedMemoryCache.java

@@ -25,7 +25,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
-
+import java.util.concurrent.ConcurrentHashMap;
 /**
  * Limited {@link Bitmap bitmap} cache. Provides {@link Bitmap bitmaps} storing. Size of all stored bitmaps will not to
  * exceed size limit. When cache reaches limit size then the bitmap which used the least frequently is deleted from
@@ -43,7 +43,7 @@ public class UsingFreqLimitedMemoryCache extends LimitedMemoryCache {
 	 * size will exceed limit then object with the least frequently usage is deleted (but it continue exist at
 	 * {@link #softMap} and can be collected by GC at any time)
 	 */
-	private final Map<Bitmap, Integer> usingCounts = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());
+	private final ConcurrentHashMap<Bitmap, Integer> usingCounts = new ConcurrentHashMap<>();
 
 	public UsingFreqLimitedMemoryCache(int sizeLimit) {
 		super(sizeLimit);