private void commitLock(String lockID, int type) { if (!nullLockStrategy) { ManagerUtil.commitLock(lockID, type); } }
private void commitLock(String lockID, int type) { if (!nullLockStrategy) { ManagerUtil.commitLock(lockID, type); } }
private void commitLock(String lockID, int type) { if (!nullLockStrategy) { ManagerUtil.commitLock(lockID, type); } }
private void commitLock(String lockID, int type) { if (!nullLockStrategy) { ManagerUtil.commitLock(lockID, type); } }
public void commitLock(String lockID, int type) { ManagerUtil.commitLock(lockID, type); }
public void commitLock(String lockID, int type) { ManagerUtil.commitLock(lockID, type); }
public void commitLock(String lockID, int type) { ManagerUtil.commitLock(lockID, type); }
private synchronized void setLastAccessedTime(final int usedAtTime, int entry,K key) { ManagerUtil.beginLock(timeStampUpdateLock, Manager.LOCK_TYPE_CONCURRENT); try { //entry.setLastAccessedTime(usedAtTime); lastAccessedMap.put(key, usedAtTime); } finally { ManagerUtil.commitLock(timeStampUpdateLock, Manager.LOCK_TYPE_CONCURRENT); } }
private void clearIfNecessary() { if (clearMap) { ManagerUtil.beginLock(CONCURRENT_TXN_LOCK_ID, Manager.LOCK_TYPE_CONCURRENT); try { clusteredStoreBackend.clear(); } finally { ManagerUtil.commitLock(CONCURRENT_TXN_LOCK_ID, Manager.LOCK_TYPE_CONCURRENT); // reset clearMap = false; } } }
@Override public boolean containsKey(final Object key) { if (__tc_isManaged()) { final String lockID = generateLockIdForKey(key); ManagerUtil.beginLock(lockID, Manager.LOCK_TYPE_READ); try { return store.containsKey(key); } finally { ManagerUtil.commitLock(lockID); } } else { return store.containsKey(key); } }
public void putFromWAN(Object key, Object value, int version) { if (__tc_isManaged()) { final String lockID = generateLockIdForKey(key); ManagerUtil.beginLock(lockID, this.dsoLockType); try { if (store.put(key, value) != value) { versionMap.put(key, version); ManagerUtil.logicalInvoke(this, SerializationUtil.PUT_SIGNATURE, new Object[] { key, value }); } } finally { ManagerUtil.commitLock(lockID); } } else { store.put(key, value); } }
@Override public int size() { if (__tc_isManaged()) { ManagerUtil.beginLock(getInstanceDsoLockName(), Manager.LOCK_TYPE_READ); try { return store.size(); } finally { ManagerUtil.commitLock(getInstanceDsoLockName()); } } else { return store.size(); } }
public int getVersion(Object key) { if (__tc_isManaged()) { final String lockID = generateLockIdForKey(key); ManagerUtil.beginLock(lockID, Manager.LOCK_TYPE_READ); try { Integer version = versionMap.get(key); if (version == null) return -1; return version; } finally { ManagerUtil.commitLock(lockID); } } else { return -1; } }
@Override public V get(final Object key) { if (__tc_isManaged()) { final String lockID = generateLockIdForKey(key); ManagerUtil.beginLock(lockID, Manager.LOCK_TYPE_READ); try { return lookupAndFaultIn(key, store.get(key)); } finally { ManagerUtil.commitLock(lockID); } } else { return (V) store.get(key); } }
private synchronized void setLastAccessedTime(final int usedAtTime, final String lockId) { if (CacheConfigFactory.DSO_ACTIVE) { ManagerUtil.beginLock(lockId, Manager.LOCK_TYPE_CONCURRENT); try { setLastAccessedTimeInternal(usedAtTime); } finally { ManagerUtil.commitLock(lockId, Manager.LOCK_TYPE_CONCURRENT); } } else { setLastAccessedTimeInternal(usedAtTime); } }
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()); }
public void clearFromWAN() { if (__tc_isManaged()) { ManagerUtil.beginLock(getInstanceDsoLockName(), this.dsoLockType); try { store.clear(); clearVersionMap(); ManagerUtil.logicalInvoke(this, SerializationUtil.CLEAR_SIGNATURE, NO_ARGS); } finally { ManagerUtil.commitLock(getInstanceDsoLockName()); } } else { store.clear(); } }
public void clear() { if (__tc_isManaged()) { ManagerUtil.beginLock(getInstanceDsoLockName(), this.dsoLockType); try { store.clear(); clearVersionMap(); remoteClear(); ManagerUtil.logicalInvoke(this, SerializationUtil.CLEAR_SIGNATURE, NO_ARGS); } finally { ManagerUtil.commitLock(getInstanceDsoLockName()); } } else { store.clear(); } }
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, 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; }