diff --git a/pom.xml b/pom.xml
index aa13db3015..3d254101d3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -688,9 +688,9 @@
             <version>2.0</version>
         </dependency>
         <dependency>
-            <groupId>com.google.collections</groupId>
-            <artifactId>google-collections</artifactId>
-            <version>1.0</version>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>11.0.2</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.security</groupId>
diff --git a/source/java/org/alfresco/repo/cache/DefaultCacheFactory.java b/source/java/org/alfresco/repo/cache/DefaultCacheFactory.java
index 7828002c24..8f4432053f 100644
--- a/source/java/org/alfresco/repo/cache/DefaultCacheFactory.java
+++ b/source/java/org/alfresco/repo/cache/DefaultCacheFactory.java
@@ -45,14 +45,8 @@ public class DefaultCacheFactory<K extends Serializable, V> extends AbstractCach
     
     private SimpleCache<K, V> createLocalCache(String cacheName)
     {
-        DefaultSimpleCache<K, V> cache = new DefaultSimpleCache<K, V>();
-        cache.setCacheName(cacheName);
         int maxItems = maxItems(cacheName);
-        // maxItems of zero has no effect, DefaultSimpleCache will use its default capacity.
-        if (maxItems > 0)
-        {
-            cache.setMaxItems(maxItems);
-        }
+        DefaultSimpleCache<K, V> cache = new DefaultSimpleCache<K, V>(maxItems, cacheName);
         if (log.isDebugEnabled())
         {
             log.debug("Creating cache: " + cache);
diff --git a/source/java/org/alfresco/repo/cache/DefaultCacheProvider.java b/source/java/org/alfresco/repo/cache/DefaultCacheProvider.java
index dd1d9ee9ca..f5da70085e 100644
--- a/source/java/org/alfresco/repo/cache/DefaultCacheProvider.java
+++ b/source/java/org/alfresco/repo/cache/DefaultCacheProvider.java
@@ -47,8 +47,7 @@ public class DefaultCacheProvider implements CacheProvider
         {
             log.debug("building cache for regionName=" + regionName + ", with properties: " + properties);
         }
-        DefaultSimpleCache<Serializable, Object> cache = new DefaultSimpleCache<Serializable, Object>();
-        cache.setMaxItems(defaultMaxItems);
+        DefaultSimpleCache<Serializable, Object> cache = new DefaultSimpleCache<Serializable, Object>(defaultMaxItems, null);
         Cache hibCache = new HibernateSimpleCacheAdapter(cache, regionName);
         return hibCache;
     }
diff --git a/source/java/org/alfresco/repo/cache/DefaultSimpleCache.java b/source/java/org/alfresco/repo/cache/DefaultSimpleCache.java
index 6d75d23301..93648b1fab 100644
--- a/source/java/org/alfresco/repo/cache/DefaultSimpleCache.java
+++ b/source/java/org/alfresco/repo/cache/DefaultSimpleCache.java
@@ -24,11 +24,11 @@ import java.util.Collection;
 
 import org.springframework.beans.factory.BeanNameAware;
 
-import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
-import com.googlecode.concurrentlinkedhashmap.Weighers;
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
 
 /**
- * {@link SimpleCache} implementation backed by a {@link ConcurrentLinkedHashMap}.
+ * {@link SimpleCache} implementation backed by a Google {@link Cache} implementation.
  * 
  * @author Matt Ward
  */
@@ -36,8 +36,9 @@ public final class DefaultSimpleCache<K extends Serializable, V extends Object>
     implements SimpleCache<K, V>, BeanNameAware
 {
     private static final int DEFAULT_CAPACITY = 200000;
-    private ConcurrentLinkedHashMap<K, AbstractMap.SimpleImmutableEntry<K, V>> map;
+    private Cache<K, AbstractMap.SimpleImmutableEntry<K, V>> map;
     private String cacheName;
+    private final int maxItems;
     
     /**
      * Construct a cache using the specified capacity and name.
@@ -50,14 +51,17 @@ public final class DefaultSimpleCache<K extends Serializable, V extends Object>
         {
             throw new IllegalArgumentException("maxItems must be a positive integer, but was " + maxItems);
         }
-        
+        else if (maxItems == 0)
+        {
+            maxItems = DEFAULT_CAPACITY;
+        }
+        this.maxItems = maxItems;
         setBeanName(cacheName);
         
         // The map will have a bounded size determined by the maxItems member variable.
-        map = new ConcurrentLinkedHashMap.Builder<K, AbstractMap.SimpleImmutableEntry<K, V>>()
-                    .maximumWeightedCapacity(maxItems)
+        map = CacheBuilder.newBuilder()
+                    .maximumSize(maxItems)
                     .concurrencyLevel(32)
-                    .weigher(Weighers.singleton())
                     .build();
     }
     
@@ -73,19 +77,19 @@ public final class DefaultSimpleCache<K extends Serializable, V extends Object>
     @Override
     public boolean contains(K key)
     {
-        return map.containsKey(key);
+        return map.asMap().containsKey(key);
     }
 
     @Override
     public Collection<K> getKeys()
     {
-        return map.keySet();
+        return map.asMap().keySet();
     }
 
     @Override
     public V get(K key)
     {
-        AbstractMap.SimpleImmutableEntry<K, V> kvp = map.get(key);
+        AbstractMap.SimpleImmutableEntry<K, V> kvp = map.getIfPresent(key);
         if (kvp == null)
         {
             return null;
@@ -107,36 +111,26 @@ public final class DefaultSimpleCache<K extends Serializable, V extends Object>
     public boolean putAndCheckUpdate(K key, V value)
     {
         AbstractMap.SimpleImmutableEntry<K, V> kvp = new AbstractMap.SimpleImmutableEntry<K, V>(key, value);
-        AbstractMap.SimpleImmutableEntry<K, V> priorKVP = map.put(key, kvp);
+        AbstractMap.SimpleImmutableEntry<K, V> priorKVP = map.asMap().put(key, kvp);
         return priorKVP != null && (! priorKVP.equals(kvp));
     }
     
     @Override
     public void remove(K key)
     {
-        map.remove(key);
+        map.invalidate(key);
     }
 
     @Override
     public void clear()
     {
-        map.clear();
+        map.invalidateAll();
     }
 
     @Override
     public String toString()
     {
-        return "DefaultSimpleCache[maxItems=" + map.capacity() + ", cacheName=" + cacheName + "]";
-    }
-
-    /**
-     * Sets the maximum number of items that the cache will hold.
-     * 
-     * @param maxItems
-     */
-    public void setMaxItems(int maxItems)
-    {
-        map.setCapacity(maxItems);
+        return "DefaultSimpleCache[maxItems=" + maxItems + ", cacheName=" + cacheName + "]";
     }
     
     /**
@@ -146,7 +140,7 @@ public final class DefaultSimpleCache<K extends Serializable, V extends Object>
      */
     public int getMaxItems()
     {
-        return map.capacity();
+        return maxItems;
     }
     
     
diff --git a/source/test-java/org/alfresco/repo/cache/DefaultSimpleCacheTest.java b/source/test-java/org/alfresco/repo/cache/DefaultSimpleCacheTest.java
index 1299eda236..f3e5b1b511 100644
--- a/source/test-java/org/alfresco/repo/cache/DefaultSimpleCacheTest.java
+++ b/source/test-java/org/alfresco/repo/cache/DefaultSimpleCacheTest.java
@@ -41,7 +41,7 @@ public class DefaultSimpleCacheTest extends SimpleCacheTestBase<DefaultSimpleCac
     public void boundedSizeCache() throws Exception
     {
         // We'll only keep the LAST 3 items
-        cache.setMaxItems(3);
+        cache = new DefaultSimpleCache<Integer, String>(3, getClass().getName());
         
         cache.put(1, "1");
         cache.put(2, "2");