public CacheStoreDso(final boolean unlockedReads, final CacheConfig config) { super(config, new ConcurrentDistributedMap<String, TimestampedValue<V>>(LockType.WRITE, new HashcodeLockStrategy(true, unlockedReads))); } }
private static <K, V> Map<K, V> newMap() { return new ConcurrentDistributedMap<K, V>(LockType.WRITE, new HashcodeLockStrategy()); }
public ClusteredStoreBackend(final LockType lockType, final CacheConfig config, final RegisteredEventListeners listeners) { super(config, new ConcurrentDistributedMap<Object, TimestampedValue<Object>>(lockType, new HashcodeLockStrategy())); initializeTransients(listeners); }
private static ConcurrentMap<String, EhcacheXAStore> getOrCreateXAStoreMap( ConcurrentMap<String, ConcurrentMap<String, EhcacheXAStore>> xaStoreRoot, String cacheMgrName) { ConcurrentMap<String, EhcacheXAStore> xaResourceMap = xaStoreRoot.get(cacheMgrName); if (null == xaResourceMap) { xaResourceMap = new ConcurrentDistributedMap<String, EhcacheXAStore>(LockType.WRITE, new HashcodeLockStrategy(), 8); ConcurrentMap<String, EhcacheXAStore> prev = xaStoreRoot.putIfAbsent(cacheMgrName, xaResourceMap); if (prev != null) { xaResourceMap = prev; } } setNotClearable(xaResourceMap); return xaResourceMap; }
private static ConcurrentMap<String, ClusteredStore> getOrCreateStoreMap( ConcurrentMap<String, ConcurrentMap<String, ClusteredStore>> storeRoot, String cacheMgrName) { ConcurrentMap<String, ClusteredStore> storeMap = storeRoot.get(cacheMgrName); if (null == storeMap) { storeMap = new ConcurrentDistributedMap<String, ClusteredStore>(LockType.WRITE, new HashcodeLockStrategy(), 8); ConcurrentMap<String, ClusteredStore> prev = storeRoot.putIfAbsent(cacheMgrName, storeMap); if (prev != null) { storeMap = prev; } } setNotClearable(storeMap); return storeMap; }
private static ConcurrentMap<String, AsyncCoordinator> getOrCreateAsyncCoordinatorMap( ConcurrentMap<String, ConcurrentMap<String, AsyncCoordinator>> asyncCoordinatorRoot, String cacheMgrName) { ConcurrentMap<String, AsyncCoordinator> storeMap = asyncCoordinatorRoot.get(cacheMgrName); if (null == storeMap) { storeMap = new ConcurrentDistributedMap<String, AsyncCoordinator>(LockType.WRITE, new HashcodeLockStrategy(), 8); ConcurrentMap<String, AsyncCoordinator> prev = asyncCoordinatorRoot.putIfAbsent(cacheMgrName, storeMap); if (prev != null) { storeMap = prev; } } setNotClearable(storeMap); return storeMap; }
private static ConcurrentMap<String, ClusteredEventReplicator> getOrCreateEventReplicatorMap( ConcurrentMap<String, ConcurrentMap<String, ClusteredEventReplicator>> replicatorRoot, String cacheMgrName) { ConcurrentMap<String, ClusteredEventReplicator> storeMap = replicatorRoot.get(cacheMgrName); if (null == storeMap) { storeMap = new ConcurrentDistributedMap<String, ClusteredEventReplicator>(LockType.WRITE, new HashcodeLockStrategy(), 8); ConcurrentMap<String, ClusteredEventReplicator> prev = replicatorRoot.putIfAbsent(cacheMgrName, storeMap); if (prev != null) { storeMap = prev; } } setNotClearable(storeMap); return storeMap; }
private static DsoSerializationStrategy getSingletonDsoSerializationStrategy() { ConcurrentMap<String, Object> root = new ConcurrentDistributedMap<String, Object>(LockType.WRITE, new HashcodeLockStrategy(), 8); ManagerUtil.beginLock(ROOT_NAME_UTILITIES, Manager.LOCK_TYPE_WRITE); try { root = (ConcurrentMap<String, Object>) ManagerUtil.lookupOrCreateRoot(ROOT_NAME_UTILITIES, root); root.putIfAbsent(DsoSerializationStrategy.class.getName(), new DsoSerializationStrategy()); setNotClearable(root); } finally { ManagerUtil.commitLock(ROOT_NAME_UTILITIES, Manager.LOCK_TYPE_WRITE); } return (DsoSerializationStrategy) root.get(DsoSerializationStrategy.class.getName()); }
private static ConcurrentMap<String, ConcurrentMap<String, ClusteredEventReplicator>> getEventReplicatorRoot() { ConcurrentMap<String, ConcurrentMap<String, ClusteredEventReplicator>> root = new ConcurrentDistributedMap<String, ConcurrentMap<String, ClusteredEventReplicator>>( LockType.WRITE, new HashcodeLockStrategy(), 8); ManagerUtil.beginLock(ROOT_NAME_EVENT_REPLICATOR, Manager.LOCK_TYPE_WRITE); try { root = (ConcurrentMap<String, ConcurrentMap<String, ClusteredEventReplicator>>) ManagerUtil .lookupOrCreateRoot(ROOT_NAME_EVENT_REPLICATOR, root); setNotClearable(root); } finally { ManagerUtil.commitLock(ROOT_NAME_EVENT_REPLICATOR, Manager.LOCK_TYPE_WRITE); } return root; }
private static ConcurrentMap<String, ConcurrentMap<String, AsyncCoordinator>> getAsyncCoordinatorRoot() { ConcurrentMap<String, ConcurrentMap<String, AsyncCoordinator>> root = new ConcurrentDistributedMap<String, ConcurrentMap<String, AsyncCoordinator>>( LockType.WRITE, new HashcodeLockStrategy(), 8); ManagerUtil.beginLock(ROOT_NAME_EHCACHE_ASYNC_COORDINATOR, Manager.LOCK_TYPE_WRITE); try { root = (ConcurrentMap<String, ConcurrentMap<String, AsyncCoordinator>>) ManagerUtil .lookupOrCreateRoot(ROOT_NAME_EHCACHE_ASYNC_COORDINATOR, root); setNotClearable(root); } finally { ManagerUtil.commitLock(ROOT_NAME_EHCACHE_ASYNC_COORDINATOR, Manager.LOCK_TYPE_WRITE); } return root; }
private static ConcurrentMap<String, ConcurrentMap<String, EhcacheXAStore>> getXAStoreRoot() { // XXX: This root name is certainly open for debate // XXX: Caching this root lookup and/or being optimistic and using a read lock is possible, though likely not a // useful optimization String rootName = "ehcache-xastore-store"; ConcurrentMap<String, ConcurrentMap<String, EhcacheXAStore>> root = new ConcurrentDistributedMap<String, ConcurrentMap<String, EhcacheXAStore>>( LockType.WRITE, new HashcodeLockStrategy(), 8); ManagerUtil.beginLock(rootName, Manager.LOCK_TYPE_WRITE); try { root = (ConcurrentMap<String, ConcurrentMap<String, EhcacheXAStore>>) ManagerUtil.lookupOrCreateRoot(rootName, root); setNotClearable(root); } finally { ManagerUtil.commitLock(rootName, Manager.LOCK_TYPE_WRITE); } return root; }
private static ConcurrentMap<String, ConcurrentMap<String, ClusteredStore>> getStoreRoot(String rootName) { // XXX: This root name is certainly open for debate // XXX: Caching this root lookup and/or being optimistic and using a read lock is possible, though likely not a // useful optimization ConcurrentMap<String, ConcurrentMap<String, ClusteredStore>> root = new ConcurrentDistributedMap<String, ConcurrentMap<String, ClusteredStore>>( LockType.WRITE, new HashcodeLockStrategy(), 8); ManagerUtil.beginLock(rootName, Manager.LOCK_TYPE_WRITE); try { root = (ConcurrentMap<String, ConcurrentMap<String, ClusteredStore>>) ManagerUtil.lookupOrCreateRoot(rootName, root); setNotClearable(root); } finally { ManagerUtil.commitLock(rootName, Manager.LOCK_TYPE_WRITE); } return root; }